src/system/gen/php/classes/reflection.cpp

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010- 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 // @generated by HipHop Compiler
  17
  18 #include <runtime/base/hphp_system.h>
  19 #include <system/gen/sys/literal_strings_remap.h>
  20 #include <system/gen/sys/scalar_arrays_remap.h>
  21 #include <php/classes/reflection.fws.h>
  22 #include <php/classes/reflection.h>
  23
  24 // Dependencies
  25 #include <php/classes/exception.h>
  26 #include <php/classes/stdclass.h>
  27 #include <runtime/ext/ext.h>
  28 #include <runtime/eval/eval.h>
  29 namespace hphp_impl_starter {}
  30
  31 namespace HPHP {
  32 ///////////////////////////////////////////////////////////////////////////////
  33
  34 /* preface starts */
  35 extern CallInfo ci_;
  36 /* preface finishes */
  37 /* SRC: classes/reflection.php line 46 */
  38 IMPLEMENT_CLASS_NO_DEFAULT_SWEEP(ReflectionParameter)
  39 const InstanceOfInfo c_ReflectionParameter::s_instanceof_table[] = {
  40   {0x62F7F85447C0A605LL,1,"Reflector",(const ObjectStaticCallbacks*)2},
  41   {0x2E7081C468A05993LL,1,"ReflectionParameter",&cw_ReflectionParameter},
  42 };
  43 const int c_ReflectionParameter::s_instanceof_index[] = {
  44   3,
  45   -1,0,-1,1,
  46 };
  47 CallInfo c_ReflectionParameter::ci___tostring((void*)&c_ReflectionParameter::i___tostring, (void*)&c_ReflectionParameter::ifa___tostring, 0, 4, 0x0000000000000000LL);
  48 CallInfo c_ReflectionParameter::ci_ispassedbyreference((void*)&c_ReflectionParameter::i_ispassedbyreference, (void*)&c_ReflectionParameter::ifa_ispassedbyreference, 0, 4, 0x0000000000000000LL);
  49 CallInfo c_ReflectionParameter::ci_isarray((void*)&c_ReflectionParameter::i_isarray, (void*)&c_ReflectionParameter::ifa_isarray, 0, 4, 0x0000000000000000LL);
  50 CallInfo c_ReflectionParameter::ci_getdefaultvalue((void*)&c_ReflectionParameter::i_getdefaultvalue, (void*)&c_ReflectionParameter::ifa_getdefaultvalue, 0, 4, 0x0000000000000000LL);
  51 CallInfo c_ReflectionParameter::ci_getclass((void*)&c_ReflectionParameter::i_getclass, (void*)&c_ReflectionParameter::ifa_getclass, 0, 4, 0x0000000000000000LL);
  52 CallInfo c_ReflectionParameter::ci_getposition((void*)&c_ReflectionParameter::i_getposition, (void*)&c_ReflectionParameter::ifa_getposition, 0, 4, 0x0000000000000000LL);
  53 CallInfo c_ReflectionParameter::ci_isoptional((void*)&c_ReflectionParameter::i_isoptional, (void*)&c_ReflectionParameter::ifa_isoptional, 0, 4, 0x0000000000000000LL);
  54 CallInfo c_ReflectionParameter::ci_getdeclaringclass((void*)&c_ReflectionParameter::i_getdeclaringclass, (void*)&c_ReflectionParameter::ifa_getdeclaringclass, 0, 4, 0x0000000000000000LL);
  55 CallInfo c_ReflectionParameter::ci_isdefaultvalueavailable((void*)&c_ReflectionParameter::i_isdefaultvalueavailable, (void*)&c_ReflectionParameter::ifa_isdefaultvalueavailable, 0, 4, 0x0000000000000000LL);
  56 CallInfo c_ReflectionParameter::ci_getname((void*)&c_ReflectionParameter::i_getname, (void*)&c_ReflectionParameter::ifa_getname, 0, 4, 0x0000000000000000LL);
  57 CallInfo c_ReflectionParameter::ci_export((void*)&c_ReflectionParameter::i_export, (void*)&c_ReflectionParameter::ifa_export, 3, 12, 0x0000000000000000LL);
  58 CallInfo c_ReflectionParameter::ci_allowsnull((void*)&c_ReflectionParameter::i_allowsnull, (void*)&c_ReflectionParameter::ifa_allowsnull, 0, 4, 0x0000000000000000LL);
  59 CallInfo c_ReflectionParameter::ci___construct((void*)&c_ReflectionParameter::i___construct, (void*)&c_ReflectionParameter::ifa___construct, 2, 4, 0x0000000000000000LL);
  60 Variant c_ReflectionParameter::i___construct(MethodCallPackage &mcp, CArrRef params) {
  61   return invoke_meth_few_handler(mcp, params, &ifa___construct);
  62 }
  63 Variant c_ReflectionParameter::i___tostring(MethodCallPackage &mcp, CArrRef params) {
  64   return invoke_meth_few_handler(mcp, params, &ifa___tostring);
  65 }
  66 Variant c_ReflectionParameter::i_export(MethodCallPackage &mcp, CArrRef params) {
  67   return invoke_meth_few_handler(mcp, params, &ifa_export);
  68 }
  69 Variant c_ReflectionParameter::i_getname(MethodCallPackage &mcp, CArrRef params) {
  70   return invoke_meth_few_handler(mcp, params, &ifa_getname);
  71 }
  72 Variant c_ReflectionParameter::i_ispassedbyreference(MethodCallPackage &mcp, CArrRef params) {
  73   return invoke_meth_few_handler(mcp, params, &ifa_ispassedbyreference);
  74 }
  75 Variant c_ReflectionParameter::i_getdeclaringclass(MethodCallPackage &mcp, CArrRef params) {
  76   return invoke_meth_few_handler(mcp, params, &ifa_getdeclaringclass);
  77 }
  78 Variant c_ReflectionParameter::i_getclass(MethodCallPackage &mcp, CArrRef params) {
  79   return invoke_meth_few_handler(mcp, params, &ifa_getclass);
  80 }
  81 Variant c_ReflectionParameter::i_isarray(MethodCallPackage &mcp, CArrRef params) {
  82   return invoke_meth_few_handler(mcp, params, &ifa_isarray);
  83 }
  84 Variant c_ReflectionParameter::i_allowsnull(MethodCallPackage &mcp, CArrRef params) {
  85   return invoke_meth_few_handler(mcp, params, &ifa_allowsnull);
  86 }
  87 Variant c_ReflectionParameter::i_isoptional(MethodCallPackage &mcp, CArrRef params) {
  88   return invoke_meth_few_handler(mcp, params, &ifa_isoptional);
  89 }
  90 Variant c_ReflectionParameter::i_isdefaultvalueavailable(MethodCallPackage &mcp, CArrRef params) {
  91   return invoke_meth_few_handler(mcp, params, &ifa_isdefaultvalueavailable);
  92 }
  93 Variant c_ReflectionParameter::i_getdefaultvalue(MethodCallPackage &mcp, CArrRef params) {
  94   return invoke_meth_few_handler(mcp, params, &ifa_getdefaultvalue);
  95 }
  96 Variant c_ReflectionParameter::i_getposition(MethodCallPackage &mcp, CArrRef params) {
  97   return invoke_meth_few_handler(mcp, params, &ifa_getposition);
  98 }
  99 Variant c_ReflectionParameter::ifa___construct(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 100   if (UNLIKELY(mcp.obj == 0)) {
 101     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa___construct, coo_ReflectionParameter);
 102   }
 103   c_ReflectionParameter *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionParameter*>(mcp.obj));
 104   if (UNLIKELY(count != 2)) return throw_wrong_arguments("ReflectionParameter::__construct", count, 2, 2, 2);
 105   CVarRef arg0(a0);
 106   CVarRef arg1(a1);
 107   return (self->t___construct(arg0, arg1), null);
 108 }
 109 Variant c_ReflectionParameter::ifa___tostring(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 110   if (UNLIKELY(mcp.obj == 0)) {
 111     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa___tostring, coo_ReflectionParameter);
 112   }
 113   c_ReflectionParameter *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionParameter*>(mcp.obj));
 114   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionParameter::__toString", 0, 1);
 115   return (self->t___tostring());
 116 }
 117 Variant c_ReflectionParameter::ifa_export(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 118   if (UNLIKELY(count != 3)) return throw_wrong_arguments("ReflectionParameter::export", count, 3, 3, 1);
 119   CVarRef arg0(a0);
 120   CVarRef arg1(a1);
 121   CVarRef arg2(a2);
 122   return (c_ReflectionParameter::t_export(arg0, arg1, arg2));
 123 }
 124 Variant c_ReflectionParameter::ifa_getname(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 125   if (UNLIKELY(mcp.obj == 0)) {
 126     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getname, coo_ReflectionParameter);
 127   }
 128   c_ReflectionParameter *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionParameter*>(mcp.obj));
 129   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionParameter::getName", 0, 1);
 130   return (self->t_getname());
 131 }
 132 Variant c_ReflectionParameter::ifa_ispassedbyreference(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 133   if (UNLIKELY(mcp.obj == 0)) {
 134     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_ispassedbyreference, coo_ReflectionParameter);
 135   }
 136   c_ReflectionParameter *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionParameter*>(mcp.obj));
 137   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionParameter::isPassedByReference", 0, 1);
 138   return (self->t_ispassedbyreference());
 139 }
 140 Variant c_ReflectionParameter::ifa_getdeclaringclass(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 141   if (UNLIKELY(mcp.obj == 0)) {
 142     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getdeclaringclass, coo_ReflectionParameter);
 143   }
 144   c_ReflectionParameter *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionParameter*>(mcp.obj));
 145   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionParameter::getDeclaringClass", 0, 1);
 146   return (self->t_getdeclaringclass());
 147 }
 148 Variant c_ReflectionParameter::ifa_getclass(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 149   if (UNLIKELY(mcp.obj == 0)) {
 150     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getclass, coo_ReflectionParameter);
 151   }
 152   c_ReflectionParameter *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionParameter*>(mcp.obj));
 153   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionParameter::getClass", 0, 1);
 154   return (self->t_getclass());
 155 }
 156 Variant c_ReflectionParameter::ifa_isarray(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 157   if (UNLIKELY(mcp.obj == 0)) {
 158     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isarray, coo_ReflectionParameter);
 159   }
 160   c_ReflectionParameter *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionParameter*>(mcp.obj));
 161   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionParameter::isArray", 0, 1);
 162   return (self->t_isarray());
 163 }
 164 Variant c_ReflectionParameter::ifa_allowsnull(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 165   if (UNLIKELY(mcp.obj == 0)) {
 166     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_allowsnull, coo_ReflectionParameter);
 167   }
 168   c_ReflectionParameter *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionParameter*>(mcp.obj));
 169   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionParameter::allowsNull", 0, 1);
 170   return (self->t_allowsnull());
 171 }
 172 Variant c_ReflectionParameter::ifa_isoptional(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 173   if (UNLIKELY(mcp.obj == 0)) {
 174     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isoptional, coo_ReflectionParameter);
 175   }
 176   c_ReflectionParameter *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionParameter*>(mcp.obj));
 177   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionParameter::isOptional", 0, 1);
 178   return (self->t_isoptional());
 179 }
 180 Variant c_ReflectionParameter::ifa_isdefaultvalueavailable(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 181   if (UNLIKELY(mcp.obj == 0)) {
 182     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isdefaultvalueavailable, coo_ReflectionParameter);
 183   }
 184   c_ReflectionParameter *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionParameter*>(mcp.obj));
 185   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionParameter::isDefaultValueAvailable", 0, 1);
 186   return (self->t_isdefaultvalueavailable());
 187 }
 188 Variant c_ReflectionParameter::ifa_getdefaultvalue(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 189   if (UNLIKELY(mcp.obj == 0)) {
 190     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getdefaultvalue, coo_ReflectionParameter);
 191   }
 192   c_ReflectionParameter *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionParameter*>(mcp.obj));
 193   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionParameter::getDefaultValue", 0, 1);
 194   return (self->t_getdefaultvalue());
 195 }
 196 Variant c_ReflectionParameter::ifa_getposition(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 197   if (UNLIKELY(mcp.obj == 0)) {
 198     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getposition, coo_ReflectionParameter);
 199   }
 200   c_ReflectionParameter *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionParameter*>(mcp.obj));
 201   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionParameter::getPosition", 0, 1);
 202   return (self->t_getposition());
 203 }
 204 const MethodCallInfoTable c_ReflectionParameter::s_call_info_table[] = {
 205   { 0x6ED51288559D6063LL, 1, 17, "getDeclaringClass", &c_ReflectionParameter::ci_getdeclaringclass },
 206   { 0x23F51CDECC198965LL, 1, 7, "getName", &c_ReflectionParameter::ci_getname },
 207   { 0x0B5ABC58C98E70E8LL, 1, 6, "export", &c_ReflectionParameter::ci_export },
 208   { 0x4044F1EEBF3BB8C8LL, 0, 11, "getPosition", &c_ReflectionParameter::ci_getposition },
 209   { 0x4F51DA0B633E9909LL, 1, 8, "getClass", &c_ReflectionParameter::ci_getclass },
 210   { 0x24ED05F4504C4C09LL, 0, 10, "allowsNull", &c_ReflectionParameter::ci_allowsnull },
 211   { 0x27C482A6C7951E0CLL, 1, 15, "getDefaultValue", &c_ReflectionParameter::ci_getdefaultvalue },
 212   { 0x13E3F304BDD89FB1LL, 1, 19, "isPassedByReference", &c_ReflectionParameter::ci_ispassedbyreference },
 213   { 0x6E34805C91257C92LL, 1, 23, "isDefaultValueAvailable", &c_ReflectionParameter::ci_isdefaultvalueavailable },
 214   { 0x642C2D2994B34A13LL, 1, 10, "__toString", &c_ReflectionParameter::ci___tostring },
 215   { 0x2D6EF48BBAB22735LL, 1, 10, "isOptional", &c_ReflectionParameter::ci_isoptional },
 216   { 0x5A9CE40C0F25871DLL, 1, 7, "isArray", &c_ReflectionParameter::ci_isarray },
 217   { 0x0D31D0AC229C615FLL, 1, 11, "__construct", &c_ReflectionParameter::ci___construct },
 218   { 0, 1, 0, 0 }
 219 };
 220 const int c_ReflectionParameter::s_call_info_index[] = {
 221   31,
 222   -1,-1,-1,0,-1,1,-1,-1,
 223   2,4,-1,-1,6,-1,-1,-1,
 224   -1,7,8,9,-1,10,-1,-1,
 225   -1,-1,-1,-1,-1,11,-1,12,
 226
 227 };
 228 c_ReflectionParameter *c_ReflectionParameter::create(CVarRef v_func, CVarRef v_param) {
 229   CountableHelper h(this);
 230   init();
 231   t___construct(v_func, v_param);
 232   return this;
 233 }
 234 const ObjectStaticCallbacks cw_ReflectionParameter = {
 235   (ObjectData*(*)(ObjectData*))coo_ReflectionParameter,
 236   c_ReflectionParameter::s_call_info_table,c_ReflectionParameter::s_call_info_index,
 237   c_ReflectionParameter::s_instanceof_table,c_ReflectionParameter::s_instanceof_index,
 238   &c_ReflectionParameter::s_class_name,
 239   &c_ReflectionParameter::os_prop_table,&c_ReflectionParameter::ci___construct,0,0
 240 };
 241 /* SRC: classes/reflection.php line 49 */
 242 void c_ReflectionParameter::t___construct(Variant v_func, Variant v_param) {
 243   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionParameter, ReflectionParameter::__construct);
 244   bool oldInCtor = gasInCtor(true);
 245   Variant v_params;
 246
 247   Variant tmp_ref;
 248   if ((toBoolean(v_func) && toBoolean(v_param))) {
 249     {
 250       {
 251         MethodCallPackage mcp0;
 252         CVarRef obj0 = v_func;
 253         mcp0.methodCall((obj0), NAMSTR(s_sys_ss1902bc14, "getParameters"), 0x3E62225132C2A32DLL);
 254         const CallInfo *cit0 ATTRIBUTE_UNUSED = mcp0.ci;
 255         Variant tmp1(((mcp0.bindClass(fi)->getMeth0Args())(mcp0, 0)));
 256         v_params.assignVal(tmp1);
 257       }
 258       {
 259         const Variant &tmp0((v_params.rvalRef(v_param, tmp_ref, AccessFlags::Error).o_getPublic(NAMSTR(s_sys_ss33988b3e, "info"), true)));
 260         m_info.assignVal(tmp0);
 261         tmp_ref.unset();
 262       }
 263     }
 264   }
 265   gasInCtor(oldInCtor);
 266 }
 267 namespace hphp_impl_splitter {}
 268 /* SRC: classes/reflection.php line 56 */
 269 String c_ReflectionParameter::t___tostring() {
 270   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionParameter, ReflectionParameter::__toString);
 271   return toString(null);
 272 }
 273 namespace hphp_impl_splitter {}
 274 /* SRC: classes/reflection.php line 75 */
 275 Variant c_ReflectionParameter::t_export(CVarRef v_func, CVarRef v_param, CVarRef v_ret) {
 276   STATIC_METHOD_INJECTION_BUILTIN(ReflectionParameter, ReflectionParameter::export);
 277   p_ReflectionParameter v_obj;
 278   String v_str;
 279
 280   {
 281     p_ReflectionParameter tmp0 = coo_ReflectionParameter();
 282     ((c_ReflectionParameter*)tmp0.get()->create(v_func, v_param));
 283     v_obj = tmp0;
 284   }
 285   v_str = (toString(v_obj));
 286   if (toBoolean(v_ret)) {
 287     {
 288       return v_str;
 289     }
 290   }
 291   print(v_str);
 292   return null;
 293 }
 294 namespace hphp_impl_splitter {}
 295 /* SRC: classes/reflection.php line 93 */
 296 Variant c_ReflectionParameter::t_getname() {
 297   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionParameter, ReflectionParameter::getName);
 298   return m_info.rvalAt(NAMSTR(s_sys_ssdc3cbddc, "name"), AccessFlags::Error_Key);
 299 }
 300 namespace hphp_impl_splitter {}
 301 /* SRC: classes/reflection.php line 108 */
 302 Variant c_ReflectionParameter::t_ispassedbyreference() {
 303   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionParameter, ReflectionParameter::isPassedByReference);
 304   return m_info.rvalAt(NAMSTR(s_sys_ss134fd5fa, "ref"), AccessFlags::Error_Key);
 305 }
 306 namespace hphp_impl_splitter {}
 307 /* SRC: classes/reflection.php line 122 */
 308 Variant c_ReflectionParameter::t_getdeclaringclass() {
 309   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionParameter, ReflectionParameter::getDeclaringClass);
 310   {
 311     bool tmp0;
 312     {
 313       tmp0 = (empty(m_info, NAMSTR(s_sys_ssc82dbd12, "class"), true));
 314     }
 315     if (tmp0) {
 316       {
 317         return null;
 318       }
 319     }
 320   }
 321   {
 322     p_ReflectionClass tmp0 = coo_ReflectionClass();
 323     const Variant &tmp1((m_info.rvalAt(NAMSTR(s_sys_ssc82dbd12, "class"), AccessFlags::Error_Key)));
 324     return ((c_ReflectionClass*)tmp0.get()->create(tmp1), tmp0);
 325   }
 326 }
 327 namespace hphp_impl_splitter {}
 328 /* SRC: classes/reflection.php line 139 */
 329 Variant c_ReflectionParameter::t_getclass() {
 330   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionParameter, ReflectionParameter::getClass);
 331   {
 332     bool tmp0;
 333     {
 334       tmp0 = (empty(m_info, NAMSTR(s_sys_ss724a760a, "type"), true));
 335     }
 336     if (tmp0) {
 337       {
 338         return null;
 339       }
 340     }
 341   }
 342   {
 343     p_ReflectionClass tmp0 = coo_ReflectionClass();
 344     const Variant &tmp1((m_info.rvalAt(NAMSTR(s_sys_ss724a760a, "type"), AccessFlags::Error_Key)));
 345     return ((c_ReflectionClass*)tmp0.get()->create(tmp1), tmp0);
 346   }
 347 }
 348 namespace hphp_impl_splitter {}
 349 /* SRC: classes/reflection.php line 155 */
 350 bool c_ReflectionParameter::t_isarray() {
 351   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionParameter, ReflectionParameter::isArray);
 352   {
 353     const Variant &tmp0((m_info.rvalAt(NAMSTR(s_sys_ss724a760a, "type"), AccessFlags::Error_Key)));
 354     return equal(tmp0, NAMSTR(s_sys_ss8c04b960, "array"));
 355   }
 356 }
 357 namespace hphp_impl_splitter {}
 358 /* SRC: classes/reflection.php line 169 */
 359 Variant c_ReflectionParameter::t_allowsnull() {
 360   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionParameter, ReflectionParameter::allowsNull);
 361   return m_info.rvalAt(NAMSTR(s_sys_ssedd47a43, "nullable"), AccessFlags::Error_Key);
 362 }
 363 namespace hphp_impl_splitter {}
 364 /* SRC: classes/reflection.php line 182 */
 365 bool c_ReflectionParameter::t_isoptional() {
 366   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionParameter, ReflectionParameter::isOptional);
 367   return x_array_key_exists(NAMVAR(s_sys_svs570270cc, "default"), m_info);
 368 }
 369 namespace hphp_impl_splitter {}
 370 /* SRC: classes/reflection.php line 197 */
 371 bool c_ReflectionParameter::t_isdefaultvalueavailable() {
 372   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionParameter, ReflectionParameter::isDefaultValueAvailable);
 373   return x_array_key_exists(NAMVAR(s_sys_svs570270cc, "default"), m_info);
 374 }
 375 namespace hphp_impl_splitter {}
 376 /* SRC: classes/reflection.php line 212 */
 377 Variant c_ReflectionParameter::t_getdefaultvalue() {
 378   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionParameter, ReflectionParameter::getDefaultValue);
 379   Variant v_defaultValue;
 380
 381   {
 382     bool tmp0;
 383     {
 384       bool tmp1((t_isoptional()));
 385       tmp0 = (!(tmp1));
 386     }
 387     if (tmp0) {
 388       {
 389         throw_exception(p_ReflectionException(((c_ReflectionException*)coo_ReflectionException())->create(NAMSTR(s_sys_ss4ad0c110, "Parameter is not optional"))));
 390       }
 391     }
 392   }
 393   {
 394     const Variant &tmp0((m_info.rvalAt(NAMSTR(s_sys_ss570270cc, "default"), AccessFlags::Error_Key)));
 395     v_defaultValue.assignVal(tmp0);
 396   }
 397   if (instanceOf(v_defaultValue, NAMSTR(s_sys_ss41c7a197, "stdclass"))) {
 398     {
 399       {
 400         const String &tmp0((toString(v_defaultValue.o_getPublic(NAMSTR(s_sys_ss309aefff, "msg"), true))));
 401         x_hphp_throw_fatal_error(tmp0);
 402       }
 403     }
 404   }
 405   return v_defaultValue;
 406 }
 407 namespace hphp_impl_splitter {}
 408 /* SRC: classes/reflection.php line 233 */
 409 Variant c_ReflectionParameter::t_getposition() {
 410   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionParameter, ReflectionParameter::getPosition);
 411   return m_info.rvalAt(NAMSTR(s_sys_ssc0ff3081, "index"), AccessFlags::Error_Key);
 412 }
 413 namespace hphp_impl_splitter {}
 414 /* SRC: classes/reflection.php line 1607 */
 415 const int64 q_ReflectionMethod$$IS_STATIC = 1LL;
 416 const int64 q_ReflectionMethod$$IS_PUBLIC = 256LL;
 417 const int64 q_ReflectionMethod$$IS_PROTECTED = 512LL;
 418 const int64 q_ReflectionMethod$$IS_PRIVATE = 1024LL;
 419 const int64 q_ReflectionMethod$$IS_ABSTRACT = 2LL;
 420 const int64 q_ReflectionMethod$$IS_FINAL = 4LL;
 421 IMPLEMENT_CLASS_NO_DEFAULT_SWEEP(ReflectionMethod)
 422 const InstanceOfInfo c_ReflectionMethod::s_instanceof_table[] = {
 423   {0x43BBC8F6F28E44B0LL,1,"ReflectionMethod",&cw_ReflectionMethod},
 424   {0x33BD46E935281082LL,1,"ReflectionFunctionAbstract",&cw_ReflectionFunctionAbstract},
 425   {0x62F7F85447C0A605LL,1,"Reflector",(const ObjectStaticCallbacks*)2},
 426 };
 427 const int c_ReflectionMethod::s_instanceof_index[] = {
 428   7,
 429   0,-1,1,-1,-1,2,-1,-1,
 430
 431 };
 432 CallInfo c_ReflectionMethod::ci___tostring((void*)&c_ReflectionMethod::i___tostring, (void*)&c_ReflectionMethod::ifa___tostring, 0, 4, 0x0000000000000000LL);
 433 CallInfo c_ReflectionMethod::ci_invokeargs((void*)&c_ReflectionMethod::i_invokeargs, (void*)&c_ReflectionMethod::ifa_invokeargs, 2, 4, 0x0000000000000000LL);
 434 CallInfo c_ReflectionMethod::ci_isdestructor((void*)&c_ReflectionMethod::i_isdestructor, (void*)&c_ReflectionMethod::ifa_isdestructor, 0, 4, 0x0000000000000000LL);
 435 CallInfo c_ReflectionMethod::ci_isprotected((void*)&c_ReflectionMethod::i_isprotected, (void*)&c_ReflectionMethod::ifa_isprotected, 0, 4, 0x0000000000000000LL);
 436 CallInfo c_ReflectionMethod::ci_getclosure((void*)&c_ReflectionMethod::i_getclosure, (void*)&c_ReflectionMethod::ifa_getclosure, 0, 4, 0x0000000000000000LL);
 437 CallInfo c_ReflectionMethod::ci_getmodifiers((void*)&c_ReflectionMethod::i_getmodifiers, (void*)&c_ReflectionMethod::ifa_getmodifiers, 0, 4, 0x0000000000000000LL);
 438 CallInfo c_ReflectionMethod::ci_invoke((void*)&c_ReflectionMethod::i_invoke, (void*)&c_ReflectionMethod::ifa_invoke, 1, 5, 0x0000000000000000LL);
 439 CallInfo c_ReflectionMethod::ci_getdeclaringclass((void*)&c_ReflectionMethod::i_getdeclaringclass, (void*)&c_ReflectionMethod::ifa_getdeclaringclass, 0, 4, 0x0000000000000000LL);
 440 CallInfo c_ReflectionMethod::ci_isfinal((void*)&c_ReflectionMethod::i_isfinal, (void*)&c_ReflectionMethod::ifa_isfinal, 0, 4, 0x0000000000000000LL);
 441 CallInfo c_ReflectionMethod::ci_isprivate((void*)&c_ReflectionMethod::i_isprivate, (void*)&c_ReflectionMethod::ifa_isprivate, 0, 4, 0x0000000000000000LL);
 442 CallInfo c_ReflectionMethod::ci_export((void*)&c_ReflectionMethod::i_export, (void*)&c_ReflectionMethod::ifa_export, 3, 12, 0x0000000000000000LL);
 443 CallInfo c_ReflectionMethod::ci_isstatic((void*)&c_ReflectionMethod::i_isstatic, (void*)&c_ReflectionMethod::ifa_isstatic, 0, 4, 0x0000000000000000LL);
 444 CallInfo c_ReflectionMethod::ci_isabstract((void*)&c_ReflectionMethod::i_isabstract, (void*)&c_ReflectionMethod::ifa_isabstract, 0, 4, 0x0000000000000000LL);
 445 CallInfo c_ReflectionMethod::ci_isconstructor((void*)&c_ReflectionMethod::i_isconstructor, (void*)&c_ReflectionMethod::ifa_isconstructor, 0, 4, 0x0000000000000000LL);
 446 CallInfo c_ReflectionMethod::ci_ispublic((void*)&c_ReflectionMethod::i_ispublic, (void*)&c_ReflectionMethod::ifa_ispublic, 0, 4, 0x0000000000000000LL);
 447 CallInfo c_ReflectionMethod::ci___construct((void*)&c_ReflectionMethod::i___construct, (void*)&c_ReflectionMethod::ifa___construct, 2, 4, 0x0000000000000000LL);
 448 Variant c_ReflectionMethod::i___construct(MethodCallPackage &mcp, CArrRef params) {
 449   return invoke_meth_few_handler(mcp, params, &ifa___construct);
 450 }
 451 Variant c_ReflectionMethod::i___tostring(MethodCallPackage &mcp, CArrRef params) {
 452   return invoke_meth_few_handler(mcp, params, &ifa___tostring);
 453 }
 454 Variant c_ReflectionMethod::i_export(MethodCallPackage &mcp, CArrRef params) {
 455   return invoke_meth_few_handler(mcp, params, &ifa_export);
 456 }
 457 Variant c_ReflectionMethod::i_invoke(MethodCallPackage &mcp, CArrRef params) {
 458   if (UNLIKELY(mcp.obj == 0)) {
 459     return ObjectData::i_dummy(mcp, params, i_invoke, coo_ReflectionMethod);
 460   }
 461   c_ReflectionMethod *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionMethod*>(mcp.obj));
 462   int count ATTRIBUTE_UNUSED = params.size();
 463   if (UNLIKELY(count < 1)) return throw_missing_arguments("ReflectionMethod::invoke", count+1, 1);
 464   {
 465     ArrayData *ad(params.get());
 466     ssize_t pos = ad ? ad->iter_begin() : ArrayData::invalid_index;
 467     CVarRef arg0((ad->getValue(pos)));
 468     const Array &p(count > 1 ? params.slice(1, count - 1, false) : Array());
 469     return (self->t_invoke(count, arg0, p));
 470   }
 471 }
 472 Variant c_ReflectionMethod::i_invokeargs(MethodCallPackage &mcp, CArrRef params) {
 473   return invoke_meth_few_handler(mcp, params, &ifa_invokeargs);
 474 }
 475 Variant c_ReflectionMethod::i_isfinal(MethodCallPackage &mcp, CArrRef params) {
 476   return invoke_meth_few_handler(mcp, params, &ifa_isfinal);
 477 }
 478 Variant c_ReflectionMethod::i_isabstract(MethodCallPackage &mcp, CArrRef params) {
 479   return invoke_meth_few_handler(mcp, params, &ifa_isabstract);
 480 }
 481 Variant c_ReflectionMethod::i_ispublic(MethodCallPackage &mcp, CArrRef params) {
 482   return invoke_meth_few_handler(mcp, params, &ifa_ispublic);
 483 }
 484 Variant c_ReflectionMethod::i_isprivate(MethodCallPackage &mcp, CArrRef params) {
 485   return invoke_meth_few_handler(mcp, params, &ifa_isprivate);
 486 }
 487 Variant c_ReflectionMethod::i_isprotected(MethodCallPackage &mcp, CArrRef params) {
 488   return invoke_meth_few_handler(mcp, params, &ifa_isprotected);
 489 }
 490 Variant c_ReflectionMethod::i_isstatic(MethodCallPackage &mcp, CArrRef params) {
 491   return invoke_meth_few_handler(mcp, params, &ifa_isstatic);
 492 }
 493 Variant c_ReflectionMethod::i_isconstructor(MethodCallPackage &mcp, CArrRef params) {
 494   return invoke_meth_few_handler(mcp, params, &ifa_isconstructor);
 495 }
 496 Variant c_ReflectionMethod::i_isdestructor(MethodCallPackage &mcp, CArrRef params) {
 497   return invoke_meth_few_handler(mcp, params, &ifa_isdestructor);
 498 }
 499 Variant c_ReflectionMethod::i_getmodifiers(MethodCallPackage &mcp, CArrRef params) {
 500   return invoke_meth_few_handler(mcp, params, &ifa_getmodifiers);
 501 }
 502 Variant c_ReflectionMethod::i_getclosure(MethodCallPackage &mcp, CArrRef params) {
 503   return invoke_meth_few_handler(mcp, params, &ifa_getclosure);
 504 }
 505 Variant c_ReflectionMethod::i_getdeclaringclass(MethodCallPackage &mcp, CArrRef params) {
 506   return invoke_meth_few_handler(mcp, params, &ifa_getdeclaringclass);
 507 }
 508 Variant c_ReflectionMethod::ifa___construct(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 509   if (UNLIKELY(mcp.obj == 0)) {
 510     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa___construct, coo_ReflectionMethod);
 511   }
 512   c_ReflectionMethod *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionMethod*>(mcp.obj));
 513   if (UNLIKELY(count < 1 || count > 2)) return throw_wrong_arguments("ReflectionMethod::__construct", count, 1, 2, 2);
 514   CVarRef arg0(a0);
 515   if (count <= 1) return (self->t___construct(arg0), null);
 516   CVarRef arg1(a1);
 517   return (self->t___construct(arg0, arg1), null);
 518 }
 519 Variant c_ReflectionMethod::ifa___tostring(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 520   if (UNLIKELY(mcp.obj == 0)) {
 521     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa___tostring, coo_ReflectionMethod);
 522   }
 523   c_ReflectionMethod *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionMethod*>(mcp.obj));
 524   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionMethod::__toString", 0, 1);
 525   return (self->t___tostring());
 526 }
 527 Variant c_ReflectionMethod::ifa_export(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 528   if (UNLIKELY(count != 3)) return throw_wrong_arguments("ReflectionMethod::export", count, 3, 3, 1);
 529   CVarRef arg0(a0);
 530   CVarRef arg1(a1);
 531   CVarRef arg2(a2);
 532   return (c_ReflectionMethod::t_export(arg0, arg1, arg2));
 533 }
 534 Variant c_ReflectionMethod::ifa_invoke(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 535   if (UNLIKELY(mcp.obj == 0)) {
 536     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_invoke, coo_ReflectionMethod);
 537   }
 538   c_ReflectionMethod *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionMethod*>(mcp.obj));
 539   if (UNLIKELY(count < 1)) return throw_missing_arguments("ReflectionMethod::invoke", count+1, 1);
 540   CVarRef arg0(a0);
 541   Array p;
 542   if (count >= 2) p.append(a1);
 543   if (count >= 3) p.append(a2);
 544   if (count >= 4) p.append(a3);
 545   if (count >= 5) p.append(a4);
 546   if (count >= 6) p.append(a5);
 547   return (self->t_invoke(count, arg0, p));
 548 }
 549 Variant c_ReflectionMethod::ifa_invokeargs(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 550   if (UNLIKELY(mcp.obj == 0)) {
 551     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_invokeargs, coo_ReflectionMethod);
 552   }
 553   c_ReflectionMethod *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionMethod*>(mcp.obj));
 554   if (UNLIKELY(count != 2)) return throw_wrong_arguments("ReflectionMethod::invokeArgs", count, 2, 2, 1);
 555   CVarRef arg0(a0);
 556   CVarRef arg1(a1);
 557   return (self->t_invokeargs(arg0, arg1));
 558 }
 559 Variant c_ReflectionMethod::ifa_isfinal(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 560   if (UNLIKELY(mcp.obj == 0)) {
 561     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isfinal, coo_ReflectionMethod);
 562   }
 563   c_ReflectionMethod *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionMethod*>(mcp.obj));
 564   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionMethod::isFinal", 0, 1);
 565   return (self->t_isfinal());
 566 }
 567 Variant c_ReflectionMethod::ifa_isabstract(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 568   if (UNLIKELY(mcp.obj == 0)) {
 569     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isabstract, coo_ReflectionMethod);
 570   }
 571   c_ReflectionMethod *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionMethod*>(mcp.obj));
 572   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionMethod::isAbstract", 0, 1);
 573   return (self->t_isabstract());
 574 }
 575 Variant c_ReflectionMethod::ifa_ispublic(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 576   if (UNLIKELY(mcp.obj == 0)) {
 577     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_ispublic, coo_ReflectionMethod);
 578   }
 579   c_ReflectionMethod *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionMethod*>(mcp.obj));
 580   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionMethod::isPublic", 0, 1);
 581   return (self->t_ispublic());
 582 }
 583 Variant c_ReflectionMethod::ifa_isprivate(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 584   if (UNLIKELY(mcp.obj == 0)) {
 585     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isprivate, coo_ReflectionMethod);
 586   }
 587   c_ReflectionMethod *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionMethod*>(mcp.obj));
 588   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionMethod::isPrivate", 0, 1);
 589   return (self->t_isprivate());
 590 }
 591 Variant c_ReflectionMethod::ifa_isprotected(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 592   if (UNLIKELY(mcp.obj == 0)) {
 593     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isprotected, coo_ReflectionMethod);
 594   }
 595   c_ReflectionMethod *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionMethod*>(mcp.obj));
 596   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionMethod::isProtected", 0, 1);
 597   return (self->t_isprotected());
 598 }
 599 Variant c_ReflectionMethod::ifa_isstatic(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 600   if (UNLIKELY(mcp.obj == 0)) {
 601     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isstatic, coo_ReflectionMethod);
 602   }
 603   c_ReflectionMethod *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionMethod*>(mcp.obj));
 604   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionMethod::isStatic", 0, 1);
 605   return (self->t_isstatic());
 606 }
 607 Variant c_ReflectionMethod::ifa_isconstructor(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 608   if (UNLIKELY(mcp.obj == 0)) {
 609     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isconstructor, coo_ReflectionMethod);
 610   }
 611   c_ReflectionMethod *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionMethod*>(mcp.obj));
 612   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionMethod::isConstructor", 0, 1);
 613   return (self->t_isconstructor());
 614 }
 615 Variant c_ReflectionMethod::ifa_isdestructor(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 616   if (UNLIKELY(mcp.obj == 0)) {
 617     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isdestructor, coo_ReflectionMethod);
 618   }
 619   c_ReflectionMethod *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionMethod*>(mcp.obj));
 620   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionMethod::isDestructor", 0, 1);
 621   return (self->t_isdestructor());
 622 }
 623 Variant c_ReflectionMethod::ifa_getmodifiers(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 624   if (UNLIKELY(mcp.obj == 0)) {
 625     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getmodifiers, coo_ReflectionMethod);
 626   }
 627   c_ReflectionMethod *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionMethod*>(mcp.obj));
 628   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionMethod::getModifiers", 0, 1);
 629   return (self->t_getmodifiers());
 630 }
 631 Variant c_ReflectionMethod::ifa_getclosure(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 632   if (UNLIKELY(mcp.obj == 0)) {
 633     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getclosure, coo_ReflectionMethod);
 634   }
 635   c_ReflectionMethod *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionMethod*>(mcp.obj));
 636   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionMethod::getClosure", 0, 1);
 637   return (self->t_getclosure());
 638 }
 639 Variant c_ReflectionMethod::ifa_getdeclaringclass(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
 640   if (UNLIKELY(mcp.obj == 0)) {
 641     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getdeclaringclass, coo_ReflectionMethod);
 642   }
 643   c_ReflectionMethod *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionMethod*>(mcp.obj));
 644   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionMethod::getDeclaringClass", 0, 1);
 645   return (self->t_getdeclaringclass());
 646 }
 647 const MethodCallInfoTable c_ReflectionMethod::s_call_info_table[] = {
 648   { 0x3FCE192CF6199942LL, 1, 6, "invoke", &c_ReflectionMethod::ci_invoke },
 649   { 0x33A6C2CFBDB05EE2LL, 0, 10, "getClosure", &c_ReflectionMethod::ci_getclosure },
 650   { 0x6ED51288559D6063LL, 1, 17, "getDeclaringClass", &c_ReflectionMethod::ci_getdeclaringclass },
 651   { 0x3235AF57F23103C4LL, 1, 10, "invokeArgs", &c_ReflectionMethod::ci_invokeargs },
 652   { 0x51A20EA0E327F607LL, 1, 12, "isDestructor", &c_ReflectionMethod::ci_isdestructor },
 653   { 0x0B5ABC58C98E70E8LL, 1, 6, "export", &c_ReflectionMethod::ci_export },
 654   { 0x2D7209A590477CEALL, 1, 11, "isProtected", &c_ReflectionMethod::ci_isprotected },
 655   { 0x06FB6A7DC3D795AELL, 1, 7, "isFinal", &c_ReflectionMethod::ci_isfinal },
 656   { 0x37AAE0845E2F636FLL, 1, 9, "isPrivate", &c_ReflectionMethod::ci_isprivate },
 657   { 0x642C2D2994B34A13LL, 1, 10, "__toString", &c_ReflectionMethod::ci___tostring },
 658   { 0x24253EBA491D6014LL, 1, 12, "getModifiers", &c_ReflectionMethod::ci_getmodifiers },
 659   { 0x7460D945DA32FDB7LL, 1, 10, "isAbstract", &c_ReflectionMethod::ci_isabstract },
 660   { 0x7A15DC56E8CC0B19LL, 1, 8, "isStatic", &c_ReflectionMethod::ci_isstatic },
 661   { 0x654B5F965C5CAC7ALL, 1, 13, "isConstructor", &c_ReflectionMethod::ci_isconstructor },
 662   { 0x2820F10358723B7CLL, 1, 8, "isPublic", &c_ReflectionMethod::ci_ispublic },
 663   { 0x0D31D0AC229C615FLL, 1, 11, "__construct", &c_ReflectionMethod::ci___construct },
 664   { 0, 1, 0, 0 }
 665 };
 666 const int c_ReflectionMethod::s_call_info_index[] = {
 667   31,
 668   -1,-1,0,2,3,-1,-1,4,
 669   5,-1,6,-1,-1,-1,7,8,
 670   -1,-1,-1,9,10,-1,-1,11,
 671   -1,12,13,-1,14,-1,-1,15,
 672
 673 };
 674 c_ReflectionMethod *c_ReflectionMethod::create(CVarRef v_cls, CVarRef v_name //  = NAMVAR(s_sys_svs00000000, "")
 675 ) {
 676   CountableHelper h(this);
 677   init();
 678   t___construct(v_cls, v_name);
 679   return this;
 680 }
 681 const ObjectStaticCallbacks cw_ReflectionMethod = {
 682   (ObjectData*(*)(ObjectData*))coo_ReflectionMethod,
 683   c_ReflectionMethod::s_call_info_table,c_ReflectionMethod::s_call_info_index,
 684   c_ReflectionMethod::s_instanceof_table,c_ReflectionMethod::s_instanceof_index,
 685   &c_ReflectionMethod::s_class_name,
 686   &c_ReflectionMethod::os_prop_table,&c_ReflectionMethod::ci___construct,0,&cw_ReflectionFunctionAbstract
 687 };
 688 /* SRC: classes/reflection.php line 1619 */
 689 void c_ReflectionMethod::t___construct(Variant v_cls, Variant v_name //  = NAMSTR(s_sys_ss00000000, "")
 690 ) {
 691   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionMethod, ReflectionMethod::__construct);
 692   bool oldInCtor = gasInCtor(true);
 693   Variant v_arr;
 694   Variant v_method;
 695
 696   if ((!(toBoolean(v_name)) && x_is_string(v_cls))) {
 697     {
 698       {
 699         const Variant &tmp0((x_explode(NAMSTR(s_sys_ss819481f3, "::"), toString(v_cls))));
 700         v_arr.assignVal(tmp0);
 701       }
 702       {
 703         bool tmp0;
 704         {
 705           int tmp1((x_count(v_arr)));
 706           tmp0 = (equal(tmp1, 2LL));
 707         }
 708         if (tmp0) {
 709           {
 710             {
 711               const Variant &tmp0((v_arr.rvalAt(0LL, AccessFlags::Error)));
 712               v_cls.assignVal(tmp0);
 713             }
 714             {
 715               const Variant &tmp0((v_arr.rvalAt(1LL, AccessFlags::Error)));
 716               v_name.assignVal(tmp0);
 717             }
 718           }
 719         }
 720       }
 721     }
 722   }
 723   if ((toBoolean(v_cls) && toBoolean(v_name))) {
 724     {
 725       if (!(x_is_object(v_cls))) {
 726         {
 727           {
 728             p_ReflectionClass tmp0 = coo_ReflectionClass();
 729             ((c_ReflectionClass*)tmp0.get()->create(v_cls));
 730             v_cls = tmp0;
 731           }
 732         }
 733       }
 734       else {
 735         {
 736           {
 737             p_ReflectionClass tmp0 = coo_ReflectionClass();
 738             const Variant &tmp1((x_get_class(v_cls)));
 739             ((c_ReflectionClass*)tmp0.get()->create(tmp1));
 740             v_cls = tmp0;
 741           }
 742         }
 743       }
 744       {
 745         MethodCallPackage mcp0;
 746         CVarRef obj0 = v_cls;
 747         mcp0.methodCall((obj0), NAMSTR(s_sys_sscdbb2d67, "getMethod"), 0x0D81ECE253A3B5B6LL);
 748         const CallInfo *cit0 ATTRIBUTE_UNUSED = mcp0.ci;
 749         Variant tmp1(((mcp0.bindClass(fi)->getMeth1Args())(mcp0, 1, v_name)));
 750         v_method.assignVal(tmp1);
 751       }
 752       if (toBoolean(v_method)) {
 753         {
 754           {
 755             const Variant &tmp0((v_method.o_getPublic(NAMSTR(s_sys_ss33988b3e, "info"), true)));
 756             m_info.assignVal(tmp0);
 757           }
 758           {
 759             const Variant &tmp0((v_method.o_getPublic(NAMSTR(s_sys_ssdc3cbddc, "name"), true)));
 760             m_name.assignVal(tmp0);
 761           }
 762           {
 763             const Variant &tmp0((v_method.o_getPublic(NAMSTR(s_sys_ssc82dbd12, "class"), true)));
 764             m_class.assignVal(tmp0);
 765           }
 766         }
 767       }
 768     }
 769   }
 770   gasInCtor(oldInCtor);
 771 }
 772 namespace hphp_impl_splitter {}
 773 /* SRC: classes/reflection.php line 1642 */
 774 String c_ReflectionMethod::t___tostring() {
 775   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionMethod, ReflectionMethod::__toString);
 776   return toString(null);
 777 }
 778 namespace hphp_impl_splitter {}
 779 /* SRC: classes/reflection.php line 1663 */
 780 Variant c_ReflectionMethod::t_export(Variant v_cls, CVarRef v_name, CVarRef v_ret) {
 781   STATIC_METHOD_INJECTION_BUILTIN(ReflectionMethod, ReflectionMethod::export);
 782   Variant v_obj;
 783   String v_str;
 784
 785   if (!(x_is_object(v_cls))) {
 786     {
 787       {
 788         p_ReflectionClass tmp0 = coo_ReflectionClass();
 789         ((c_ReflectionClass*)tmp0.get()->create(v_cls));
 790         v_cls = tmp0;
 791       }
 792     }
 793   }
 794   else {
 795     {
 796       {
 797         p_ReflectionClass tmp0 = coo_ReflectionClass();
 798         const Variant &tmp1((x_get_class(v_cls)));
 799         ((c_ReflectionClass*)tmp0.get()->create(tmp1));
 800         v_cls = tmp0;
 801       }
 802     }
 803   }
 804   {
 805     MethodCallPackage mcp0;
 806     CVarRef obj0 = v_cls;
 807     mcp0.methodCall((obj0), NAMSTR(s_sys_sscdbb2d67, "getMethod"), 0x0D81ECE253A3B5B6LL);
 808     const CallInfo *cit0 ATTRIBUTE_UNUSED = mcp0.ci;
 809     Variant tmp1(((mcp0.bindClass(fi)->getMeth1Args())(mcp0, 1, v_name)));
 810     v_obj.assignVal(tmp1);
 811   }
 812   v_str = (toString(v_obj));
 813   if (toBoolean(v_ret)) {
 814     {
 815       return v_str;
 816     }
 817   }
 818   print(v_str);
 819   return null;
 820 }
 821 namespace hphp_impl_splitter {}
 822 /* SRC: classes/reflection.php line 1688 */
 823 Variant c_ReflectionMethod::t_invoke(int num_args, CVarRef v_obj, Array args /* = Array() */) {
 824   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionMethod, ReflectionMethod::invoke);
 825   Variant v_args;
 826
 827   {
 828     const Array &tmp0((func_get_args(num_args, Array(ArrayInit(1).set(v_obj).create()),args)));
 829     v_args = tmp0;
 830   }
 831   x_array_shift(ref(v_args));
 832   {
 833     Variant tmp0((v_obj));
 834     const String &tmp1((toString(m_info.rvalAt(NAMSTR(s_sys_ssc82dbd12, "class"), AccessFlags::Error_Key))));
 835     const String &tmp2((toString(m_info.rvalAt(NAMSTR(s_sys_ssdc3cbddc, "name"), AccessFlags::Error_Key))));
 836     return x_hphp_invoke_method(tmp0, tmp1, tmp2, toArray(v_args));
 837   }
 838 }
 839 namespace hphp_impl_splitter {}
 840 /* SRC: classes/reflection.php line 1709 */
 841 Variant c_ReflectionMethod::t_invokeargs(CVarRef v_obj, CVarRef v_args) {
 842   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionMethod, ReflectionMethod::invokeArgs);
 843   {
 844     Variant tmp0((v_obj));
 845     const String &tmp1((toString(m_info.rvalAt(NAMSTR(s_sys_ssc82dbd12, "class"), AccessFlags::Error_Key))));
 846     const String &tmp2((toString(m_info.rvalAt(NAMSTR(s_sys_ssdc3cbddc, "name"), AccessFlags::Error_Key))));
 847     const Array &tmp3((toArray(x_array_values(v_args))));
 848     return x_hphp_invoke_method(tmp0, tmp1, tmp2, tmp3);
 849   }
 850 }
 851 namespace hphp_impl_splitter {}
 852 /* SRC: classes/reflection.php line 1722 */
 853 Variant c_ReflectionMethod::t_isfinal() {
 854   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionMethod, ReflectionMethod::isFinal);
 855   return m_info.rvalAt(NAMSTR(s_sys_ss2145036e, "final"), AccessFlags::Error_Key);
 856 }
 857 namespace hphp_impl_splitter {}
 858 /* SRC: classes/reflection.php line 1735 */
 859 Variant c_ReflectionMethod::t_isabstract() {
 860   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionMethod, ReflectionMethod::isAbstract);
 861   return m_info.rvalAt(NAMSTR(s_sys_ss12c8a8a6, "abstract"), AccessFlags::Error_Key);
 862 }
 863 namespace hphp_impl_splitter {}
 864 /* SRC: classes/reflection.php line 1747 */
 865 bool c_ReflectionMethod::t_ispublic() {
 866   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionMethod, ReflectionMethod::isPublic);
 867   {
 868     const Variant &tmp0((m_info.rvalAt(NAMSTR(s_sys_ss750cda3b, "access"), AccessFlags::Error_Key)));
 869     return equal(tmp0, NAMSTR(s_sys_ss4ce85288, "public"));
 870   }
 871 }
 872 namespace hphp_impl_splitter {}
 873 /* SRC: classes/reflection.php line 1760 */
 874 bool c_ReflectionMethod::t_isprivate() {
 875   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionMethod, ReflectionMethod::isPrivate);
 876   {
 877     const Variant &tmp0((m_info.rvalAt(NAMSTR(s_sys_ss750cda3b, "access"), AccessFlags::Error_Key)));
 878     return equal(tmp0, NAMSTR(s_sys_sse781f7da, "private"));
 879   }
 880 }
 881 namespace hphp_impl_splitter {}
 882 /* SRC: classes/reflection.php line 1773 */
 883 bool c_ReflectionMethod::t_isprotected() {
 884   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionMethod, ReflectionMethod::isProtected);
 885   {
 886     const Variant &tmp0((m_info.rvalAt(NAMSTR(s_sys_ss750cda3b, "access"), AccessFlags::Error_Key)));
 887     return equal(tmp0, NAMSTR(s_sys_ss9fb56979, "protected"));
 888   }
 889 }
 890 namespace hphp_impl_splitter {}
 891 /* SRC: classes/reflection.php line 1785 */
 892 Variant c_ReflectionMethod::t_isstatic() {
 893   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionMethod, ReflectionMethod::isStatic);
 894   return m_info.rvalAt(NAMSTR(s_sys_ssf08d205d, "static"), AccessFlags::Error_Key);
 895 }
 896 namespace hphp_impl_splitter {}
 897 /* SRC: classes/reflection.php line 1798 */
 898 bool c_ReflectionMethod::t_isconstructor() {
 899   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionMethod, ReflectionMethod::isConstructor);
 900   {
 901     return isset(m_info, NAMSTR(s_sys_ssefecb9dd, "constructor"), true);
 902   }
 903 }
 904 namespace hphp_impl_splitter {}
 905 /* SRC: classes/reflection.php line 1811 */
 906 bool c_ReflectionMethod::t_isdestructor() {
 907   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionMethod, ReflectionMethod::isDestructor);
 908   {
 909     const Variant &tmp0((t_getname()));
 910     return equal(tmp0, NAMSTR(s_sys_ssa5a7f4f9, "__destruct"));
 911   }
 912 }
 913 namespace hphp_impl_splitter {}
 914 /* SRC: classes/reflection.php line 1833 */
 915 Variant c_ReflectionMethod::t_getmodifiers() {
 916   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionMethod, ReflectionMethod::getModifiers);
 917   return m_info.rvalAt(NAMSTR(s_sys_ss9f244c80, "modifiers"), AccessFlags::Error_Key);
 918 }
 919 namespace hphp_impl_splitter {}
 920 /* SRC: classes/reflection.php line 1837 */
 921 Variant c_ReflectionMethod::t_getclosure() {
 922   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionMethod, ReflectionMethod::getClosure);
 923   return m_info.rvalAt(NAMSTR(s_sys_ss4cd61020, "closure"), AccessFlags::Error_Key);
 924 }
 925 namespace hphp_impl_splitter {}
 926 /* SRC: classes/reflection.php line 1851 */
 927 Variant c_ReflectionMethod::t_getdeclaringclass() {
 928   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionMethod, ReflectionMethod::getDeclaringClass);
 929   {
 930     bool tmp0;
 931     {
 932       tmp0 = (empty(m_info, NAMSTR(s_sys_ssc82dbd12, "class"), true));
 933     }
 934     if (tmp0) {
 935       {
 936         return null;
 937       }
 938     }
 939   }
 940   {
 941     p_ReflectionClass tmp0 = coo_ReflectionClass();
 942     const Variant &tmp1((m_info.rvalAt(NAMSTR(s_sys_ssc82dbd12, "class"), AccessFlags::Error_Key)));
 943     return ((c_ReflectionClass*)tmp0.get()->create(tmp1), tmp0);
 944   }
 945 }
 946 namespace hphp_impl_splitter {}
 947 /* SRC: classes/reflection.php line 1869 */
 948 IMPLEMENT_CLASS_NO_DEFAULT_SWEEP(ReflectionExtension)
 949 const InstanceOfInfo c_ReflectionExtension::s_instanceof_table[] = {
 950   {0x62F7F85447C0A605LL,1,"Reflector",(const ObjectStaticCallbacks*)2},
 951   {0x0B61E0BFCFA06573LL,1,"ReflectionExtension",&cw_ReflectionExtension},
 952 };
 953 const int c_ReflectionExtension::s_instanceof_index[] = {
 954   3,
 955   -1,0,-1,1,
 956 };
 957 CallInfo c_ReflectionExtension::ci_getclassnames((void*)&c_ReflectionExtension::i_getclassnames, (void*)&c_ReflectionExtension::ifa_getclassnames, 0, 4, 0x0000000000000000LL);
 958 CallInfo c_ReflectionExtension::ci___construct((void*)&c_ReflectionExtension::i___construct, (void*)&c_ReflectionExtension::ifa___construct, 1, 4, 0x0000000000000000LL);
 959 CallInfo c_ReflectionExtension::ci_export((void*)&c_ReflectionExtension::i_export, (void*)&c_ReflectionExtension::ifa_export, 2, 12, 0x0000000000000000LL);
 960 CallInfo c_ReflectionExtension::ci_getconstants((void*)&c_ReflectionExtension::i_getconstants, (void*)&c_ReflectionExtension::ifa_getconstants, 0, 4, 0x0000000000000000LL);
 961 CallInfo c_ReflectionExtension::ci_getname((void*)&c_ReflectionExtension::i_getname, (void*)&c_ReflectionExtension::ifa_getname, 0, 4, 0x0000000000000000LL);
 962 CallInfo c_ReflectionExtension::ci___tostring((void*)&c_ReflectionExtension::i___tostring, (void*)&c_ReflectionExtension::ifa___tostring, 0, 4, 0x0000000000000000LL);
 963 CallInfo c_ReflectionExtension::ci_getclasses((void*)&c_ReflectionExtension::i_getclasses, (void*)&c_ReflectionExtension::ifa_getclasses, 0, 4, 0x0000000000000000LL);
 964 CallInfo c_ReflectionExtension::ci_getversion((void*)&c_ReflectionExtension::i_getversion, (void*)&c_ReflectionExtension::ifa_getversion, 0, 4, 0x0000000000000000LL);
 965 CallInfo c_ReflectionExtension::ci_info((void*)&c_ReflectionExtension::i_info, (void*)&c_ReflectionExtension::ifa_info, 0, 4, 0x0000000000000000LL);
 966 CallInfo c_ReflectionExtension::ci_getinientries((void*)&c_ReflectionExtension::i_getinientries, (void*)&c_ReflectionExtension::ifa_getinientries, 0, 4, 0x0000000000000000LL);
 967 CallInfo c_ReflectionExtension::ci_getfunctions((void*)&c_ReflectionExtension::i_getfunctions, (void*)&c_ReflectionExtension::ifa_getfunctions, 0, 4, 0x0000000000000000LL);
 968 Variant c_ReflectionExtension::i___construct(MethodCallPackage &mcp, CArrRef params) {
 969   return invoke_meth_few_handler(mcp, params, &ifa___construct);
 970 }
 971 Variant c_ReflectionExtension::i___tostring(MethodCallPackage &mcp, CArrRef params) {
 972   return invoke_meth_few_handler(mcp, params, &ifa___tostring);
 973 }
 974 Variant c_ReflectionExtension::i_export(MethodCallPackage &mcp, CArrRef params) {
 975   return invoke_meth_few_handler(mcp, params, &ifa_export);
 976 }
 977 Variant c_ReflectionExtension::i_getname(MethodCallPackage &mcp, CArrRef params) {
 978   return invoke_meth_few_handler(mcp, params, &ifa_getname);
 979 }
 980 Variant c_ReflectionExtension::i_getversion(MethodCallPackage &mcp, CArrRef params) {
 981   return invoke_meth_few_handler(mcp, params, &ifa_getversion);
 982 }
 983 Variant c_ReflectionExtension::i_getfunctions(MethodCallPackage &mcp, CArrRef params) {
 984   return invoke_meth_few_handler(mcp, params, &ifa_getfunctions);
 985 }
 986 Variant c_ReflectionExtension::i_getconstants(MethodCallPackage &mcp, CArrRef params) {
 987   return invoke_meth_few_handler(mcp, params, &ifa_getconstants);
 988 }
 989 Variant c_ReflectionExtension::i_getinientries(MethodCallPackage &mcp, CArrRef params) {
 990   return invoke_meth_few_handler(mcp, params, &ifa_getinientries);
 991 }
 992 Variant c_ReflectionExtension::i_getclasses(MethodCallPackage &mcp, CArrRef params) {
 993   return invoke_meth_few_handler(mcp, params, &ifa_getclasses);
 994 }
 995 Variant c_ReflectionExtension::i_getclassnames(MethodCallPackage &mcp, CArrRef params) {
 996   return invoke_meth_few_handler(mcp, params, &ifa_getclassnames);
 997 }
 998 Variant c_ReflectionExtension::i_info(MethodCallPackage &mcp, CArrRef params) {
 999   return invoke_meth_few_handler(mcp, params, &ifa_info);
1000 }
1001 Variant c_ReflectionExtension::ifa___construct(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1002   if (UNLIKELY(mcp.obj == 0)) {
1003     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa___construct, coo_ReflectionExtension);
1004   }
1005   c_ReflectionExtension *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionExtension*>(mcp.obj));
1006   if (UNLIKELY(count != 1)) return throw_wrong_arguments("ReflectionExtension::__construct", count, 1, 1, 2);
1007   CVarRef arg0(a0);
1008   return (self->t___construct(arg0), null);
1009 }
1010 Variant c_ReflectionExtension::ifa___tostring(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1011   if (UNLIKELY(mcp.obj == 0)) {
1012     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa___tostring, coo_ReflectionExtension);
1013   }
1014   c_ReflectionExtension *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionExtension*>(mcp.obj));
1015   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionExtension::__toString", 0, 1);
1016   return (self->t___tostring());
1017 }
1018 Variant c_ReflectionExtension::ifa_export(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1019   if (UNLIKELY(count != 2)) return throw_wrong_arguments("ReflectionExtension::export", count, 2, 2, 1);
1020   CVarRef arg0(a0);
1021   CVarRef arg1(a1);
1022   return (c_ReflectionExtension::t_export(arg0, arg1));
1023 }
1024 Variant c_ReflectionExtension::ifa_getname(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1025   if (UNLIKELY(mcp.obj == 0)) {
1026     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getname, coo_ReflectionExtension);
1027   }
1028   c_ReflectionExtension *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionExtension*>(mcp.obj));
1029   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionExtension::getName", 0, 1);
1030   return (self->t_getname());
1031 }
1032 Variant c_ReflectionExtension::ifa_getversion(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1033   if (UNLIKELY(mcp.obj == 0)) {
1034     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getversion, coo_ReflectionExtension);
1035   }
1036   c_ReflectionExtension *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionExtension*>(mcp.obj));
1037   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionExtension::getVersion", 0, 1);
1038   return (self->t_getversion());
1039 }
1040 Variant c_ReflectionExtension::ifa_getfunctions(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1041   if (UNLIKELY(mcp.obj == 0)) {
1042     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getfunctions, coo_ReflectionExtension);
1043   }
1044   c_ReflectionExtension *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionExtension*>(mcp.obj));
1045   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionExtension::getFunctions", 0, 1);
1046   return (self->t_getfunctions());
1047 }
1048 Variant c_ReflectionExtension::ifa_getconstants(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1049   if (UNLIKELY(mcp.obj == 0)) {
1050     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getconstants, coo_ReflectionExtension);
1051   }
1052   c_ReflectionExtension *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionExtension*>(mcp.obj));
1053   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionExtension::getConstants", 0, 1);
1054   return (self->t_getconstants());
1055 }
1056 Variant c_ReflectionExtension::ifa_getinientries(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1057   if (UNLIKELY(mcp.obj == 0)) {
1058     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getinientries, coo_ReflectionExtension);
1059   }
1060   c_ReflectionExtension *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionExtension*>(mcp.obj));
1061   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionExtension::getINIEntries", 0, 1);
1062   return (self->t_getinientries());
1063 }
1064 Variant c_ReflectionExtension::ifa_getclasses(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1065   if (UNLIKELY(mcp.obj == 0)) {
1066     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getclasses, coo_ReflectionExtension);
1067   }
1068   c_ReflectionExtension *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionExtension*>(mcp.obj));
1069   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionExtension::getClasses", 0, 1);
1070   return (self->t_getclasses());
1071 }
1072 Variant c_ReflectionExtension::ifa_getclassnames(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1073   if (UNLIKELY(mcp.obj == 0)) {
1074     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getclassnames, coo_ReflectionExtension);
1075   }
1076   c_ReflectionExtension *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionExtension*>(mcp.obj));
1077   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionExtension::getClassNames", 0, 1);
1078   return (self->t_getclassnames());
1079 }
1080 Variant c_ReflectionExtension::ifa_info(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1081   if (UNLIKELY(mcp.obj == 0)) {
1082     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_info, coo_ReflectionExtension);
1083   }
1084   c_ReflectionExtension *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionExtension*>(mcp.obj));
1085   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionExtension::info", 0, 1);
1086   return (self->t_info());
1087 }
1088 const MethodCallInfoTable c_ReflectionExtension::s_call_info_table[] = {
1089   { 0x0113D73FC859EDC2LL, 1, 10, "getClasses", &c_ReflectionExtension::ci_getclasses },
1090   { 0x23F51CDECC198965LL, 1, 7, "getName", &c_ReflectionExtension::ci_getname },
1091   { 0x0B5ABC58C98E70E8LL, 1, 6, "export", &c_ReflectionExtension::ci_export },
1092   { 0x652BDFA6E22F17AFLL, 1, 12, "getFunctions", &c_ReflectionExtension::ci_getfunctions },
1093   { 0x642C2D2994B34A13LL, 1, 10, "__toString", &c_ReflectionExtension::ci___tostring },
1094   { 0x5CE2786E11341594LL, 1, 13, "getClassNames", &c_ReflectionExtension::ci_getclassnames },
1095   { 0x1CC71CB013143955LL, 1, 12, "getConstants", &c_ReflectionExtension::ci_getconstants },
1096   { 0x306B5F4D1D03D335LL, 0, 13, "getINIEntries", &c_ReflectionExtension::ci_getinientries },
1097   { 0x7521E8833BE3D316LL, 1, 10, "getVersion", &c_ReflectionExtension::ci_getversion },
1098   { 0x0D31D0AC229C615FLL, 1, 11, "__construct", &c_ReflectionExtension::ci___construct },
1099   { 0x0F2EF58F157D479FLL, 0, 4, "info", &c_ReflectionExtension::ci_info },
1100   { 0, 1, 0, 0 }
1101 };
1102 const int c_ReflectionExtension::s_call_info_index[] = {
1103   31,
1104   -1,-1,0,-1,-1,1,-1,-1,
1105   2,-1,-1,-1,-1,-1,-1,3,
1106   -1,-1,-1,4,5,6,8,-1,
1107   -1,-1,-1,-1,-1,-1,-1,9,
1108
1109 };
1110 c_ReflectionExtension *c_ReflectionExtension::create(CVarRef v_name) {
1111   CountableHelper h(this);
1112   init();
1113   t___construct(v_name);
1114   return this;
1115 }
1116 const ObjectStaticCallbacks cw_ReflectionExtension = {
1117   (ObjectData*(*)(ObjectData*))coo_ReflectionExtension,
1118   c_ReflectionExtension::s_call_info_table,c_ReflectionExtension::s_call_info_index,
1119   c_ReflectionExtension::s_instanceof_table,c_ReflectionExtension::s_instanceof_index,
1120   &c_ReflectionExtension::s_class_name,
1121   &c_ReflectionExtension::os_prop_table,&c_ReflectionExtension::ci___construct,0,0
1122 };
1123 /* SRC: classes/reflection.php line 1873 */
1124 void c_ReflectionExtension::t___construct(Variant v_name) {
1125   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionExtension, ReflectionExtension::__construct);
1126   bool oldInCtor = gasInCtor(true);
1127   {
1128     const Array &tmp0((x_hphp_get_extension_info(toString(v_name))));
1129     m_info = tmp0;
1130   }
1131   gasInCtor(oldInCtor);
1132 }
1133 namespace hphp_impl_splitter {}
1134 /* SRC: classes/reflection.php line 1877 */
1135 String c_ReflectionExtension::t___tostring() {
1136   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionExtension, ReflectionExtension::__toString);
1137   return toString(null);
1138 }
1139 namespace hphp_impl_splitter {}
1140 /* SRC: classes/reflection.php line 1896 */
1141 Variant c_ReflectionExtension::t_export(CVarRef v_name, CVarRef v_ret) {
1142   STATIC_METHOD_INJECTION_BUILTIN(ReflectionExtension, ReflectionExtension::export);
1143   p_ReflectionExtension v_obj;
1144   String v_str;
1145
1146   {
1147     p_ReflectionExtension tmp0 = coo_ReflectionExtension();
1148     ((c_ReflectionExtension*)tmp0.get()->create(v_name));
1149     v_obj = tmp0;
1150   }
1151   v_str = (toString(v_obj));
1152   if (toBoolean(v_ret)) {
1153     {
1154       return v_str;
1155     }
1156   }
1157   print(v_str);
1158   return null;
1159 }
1160 namespace hphp_impl_splitter {}
1161 /* SRC: classes/reflection.php line 1914 */
1162 Variant c_ReflectionExtension::t_getname() {
1163   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionExtension, ReflectionExtension::getName);
1164   return m_info.rvalAt(NAMSTR(s_sys_ssdc3cbddc, "name"), AccessFlags::Error_Key);
1165 }
1166 namespace hphp_impl_splitter {}
1167 /* SRC: classes/reflection.php line 1927 */
1168 Variant c_ReflectionExtension::t_getversion() {
1169   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionExtension, ReflectionExtension::getVersion);
1170   return m_info.rvalAt(NAMSTR(s_sys_ss7cd91db4, "version"), AccessFlags::Error_Key);
1171 }
1172 namespace hphp_impl_splitter {}
1173 /* SRC: classes/reflection.php line 1943 */
1174 Variant c_ReflectionExtension::t_getfunctions() {
1175   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionExtension, ReflectionExtension::getFunctions);
1176   return m_info.rvalAt(NAMSTR(s_sys_ssc8396b02, "functions"), AccessFlags::Error_Key);
1177 }
1178 namespace hphp_impl_splitter {}
1179 /* SRC: classes/reflection.php line 1956 */
1180 Variant c_ReflectionExtension::t_getconstants() {
1181   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionExtension, ReflectionExtension::getConstants);
1182   return m_info.rvalAt(NAMSTR(s_sys_ss623ae369, "constants"), AccessFlags::Error_Key);
1183 }
1184 namespace hphp_impl_splitter {}
1185 /* SRC: classes/reflection.php line 1970 */
1186 Variant c_ReflectionExtension::t_getinientries() {
1187   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionExtension, ReflectionExtension::getINIEntries);
1188   return m_info.rvalAt(NAMSTR(s_sys_sscedef5dc, "ini"), AccessFlags::Error_Key);
1189 }
1190 namespace hphp_impl_splitter {}
1191 /* SRC: classes/reflection.php line 1985 */
1192 Variant c_ReflectionExtension::t_getclasses() {
1193   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionExtension, ReflectionExtension::getClasses);
1194   return m_info.rvalAt(NAMSTR(s_sys_ss0415e4a0, "classes"), AccessFlags::Error_Key);
1195 }
1196 namespace hphp_impl_splitter {}
1197 /* SRC: classes/reflection.php line 2000 */
1198 Array c_ReflectionExtension::t_getclassnames() {
1199   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionExtension, ReflectionExtension::getClassNames);
1200   Array v_ret;
1201   Variant v_cls;
1202
1203   v_ret = s_sys_sa00000000;
1204   {
1205     LOOP_COUNTER(1);
1206     Variant map2 = m_info.rvalAt(NAMSTR(s_sys_ss0415e4a0, "classes"), AccessFlags::Error_Key);
1207     for (ArrayIter iter3 = map2.begin(s_class_name, true); !iter3.end(); iter3.next()) {
1208       LOOP_COUNTER_CHECK(1);
1209       iter3.second(v_cls);
1210       {
1211         {
1212           MethodCallPackage mcp0;
1213           CVarRef obj0 = v_cls;
1214           mcp0.methodCall((obj0), NAMSTR(s_sys_ssc2df217e, "getName"), 0x23F51CDECC198965LL);
1215           const CallInfo *cit0 ATTRIBUTE_UNUSED = mcp0.ci;
1216           Variant tmp1(((mcp0.bindClass(fi)->getMeth0Args())(mcp0, 0)));
1217           v_ret.append((tmp1));
1218         }
1219       }
1220     }
1221   }
1222   return v_ret;
1223 }
1224 namespace hphp_impl_splitter {}
1225 /* SRC: classes/reflection.php line 2016 */
1226 Variant c_ReflectionExtension::t_info() {
1227   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionExtension, ReflectionExtension::info);
1228   return m_info.rvalAt(NAMSTR(s_sys_ss33988b3e, "info"), AccessFlags::Error_Key);
1229 }
1230 namespace hphp_impl_splitter {}
1231 /* SRC: classes/reflection.php line 461 */
1232 const int64 q_ReflectionFunction$$IS_DEPRECATED = 262144LL;
1233 IMPLEMENT_CLASS_NO_DEFAULT_SWEEP(ReflectionFunction)
1234 const InstanceOfInfo c_ReflectionFunction::s_instanceof_table[] = {
1235   {0x21EF70351574EC09LL,1,"ReflectionFunction",&cw_ReflectionFunction},
1236   {0x33BD46E935281082LL,1,"ReflectionFunctionAbstract",&cw_ReflectionFunctionAbstract},
1237   {0x62F7F85447C0A605LL,1,"Reflector",(const ObjectStaticCallbacks*)2},
1238 };
1239 const int c_ReflectionFunction::s_instanceof_index[] = {
1240   7,
1241   -1,0,1,-1,-1,2,-1,-1,
1242
1243 };
1244 CallInfo c_ReflectionFunction::ci_export((void*)&c_ReflectionFunction::i_export, (void*)&c_ReflectionFunction::ifa_export, 2, 12, 0x0000000000000000LL);
1245 CallInfo c_ReflectionFunction::ci_invoke((void*)&c_ReflectionFunction::i_invoke, (void*)&c_ReflectionFunction::ifa_invoke, 0, 5, 0x0000000000000000LL);
1246 CallInfo c_ReflectionFunction::ci_invokeargs((void*)&c_ReflectionFunction::i_invokeargs, (void*)&c_ReflectionFunction::ifa_invokeargs, 1, 4, 0x0000000000000000LL);
1247 CallInfo c_ReflectionFunction::ci___construct((void*)&c_ReflectionFunction::i___construct, (void*)&c_ReflectionFunction::ifa___construct, 1, 4, 0x0000000000000000LL);
1248 CallInfo c_ReflectionFunction::ci___tostring((void*)&c_ReflectionFunction::i___tostring, (void*)&c_ReflectionFunction::ifa___tostring, 0, 4, 0x0000000000000000LL);
1249 Variant c_ReflectionFunction::i___construct(MethodCallPackage &mcp, CArrRef params) {
1250   return invoke_meth_few_handler(mcp, params, &ifa___construct);
1251 }
1252 Variant c_ReflectionFunction::i___tostring(MethodCallPackage &mcp, CArrRef params) {
1253   return invoke_meth_few_handler(mcp, params, &ifa___tostring);
1254 }
1255 Variant c_ReflectionFunction::i_export(MethodCallPackage &mcp, CArrRef params) {
1256   return invoke_meth_few_handler(mcp, params, &ifa_export);
1257 }
1258 Variant c_ReflectionFunction::i_invoke(MethodCallPackage &mcp, CArrRef params) {
1259   if (UNLIKELY(mcp.obj == 0)) {
1260     return ObjectData::i_dummy(mcp, params, i_invoke, coo_ReflectionFunction);
1261   }
1262   c_ReflectionFunction *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunction*>(mcp.obj));
1263   int count ATTRIBUTE_UNUSED = params.size();
1264   const Array &p(count > 0 ? ArrayUtil::EnsureIntKeys(params) : Array());
1265   return (self->t_invoke(count, p));
1266 }
1267 Variant c_ReflectionFunction::i_invokeargs(MethodCallPackage &mcp, CArrRef params) {
1268   return invoke_meth_few_handler(mcp, params, &ifa_invokeargs);
1269 }
1270 Variant c_ReflectionFunction::ifa___construct(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1271   if (UNLIKELY(mcp.obj == 0)) {
1272     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa___construct, coo_ReflectionFunction);
1273   }
1274   c_ReflectionFunction *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunction*>(mcp.obj));
1275   if (UNLIKELY(count != 1)) return throw_wrong_arguments("ReflectionFunction::__construct", count, 1, 1, 2);
1276   CVarRef arg0(a0);
1277   return (self->t___construct(arg0), null);
1278 }
1279 Variant c_ReflectionFunction::ifa___tostring(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1280   if (UNLIKELY(mcp.obj == 0)) {
1281     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa___tostring, coo_ReflectionFunction);
1282   }
1283   c_ReflectionFunction *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunction*>(mcp.obj));
1284   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionFunction::__toString", 0, 1);
1285   return (self->t___tostring());
1286 }
1287 Variant c_ReflectionFunction::ifa_export(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1288   if (UNLIKELY(count != 2)) return throw_wrong_arguments("ReflectionFunction::export", count, 2, 2, 1);
1289   CVarRef arg0(a0);
1290   CVarRef arg1(a1);
1291   return (c_ReflectionFunction::t_export(arg0, arg1));
1292 }
1293 Variant c_ReflectionFunction::ifa_invoke(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1294   if (UNLIKELY(mcp.obj == 0)) {
1295     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_invoke, coo_ReflectionFunction);
1296   }
1297   c_ReflectionFunction *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunction*>(mcp.obj));
1298   Array p;
1299   if (count >= 1) p.append(a0);
1300   if (count >= 2) p.append(a1);
1301   if (count >= 3) p.append(a2);
1302   if (count >= 4) p.append(a3);
1303   if (count >= 5) p.append(a4);
1304   if (count >= 6) p.append(a5);
1305   return (self->t_invoke(count, p));
1306 }
1307 Variant c_ReflectionFunction::ifa_invokeargs(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1308   if (UNLIKELY(mcp.obj == 0)) {
1309     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_invokeargs, coo_ReflectionFunction);
1310   }
1311   c_ReflectionFunction *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunction*>(mcp.obj));
1312   if (UNLIKELY(count != 1)) return throw_wrong_arguments("ReflectionFunction::invokeArgs", count, 1, 1, 1);
1313   CVarRef arg0(a0);
1314   return (self->t_invokeargs(arg0));
1315 }
1316 const MethodCallInfoTable c_ReflectionFunction::s_call_info_table[] = {
1317   { 0x3FCE192CF6199942LL, 1, 6, "invoke", &c_ReflectionFunction::ci_invoke },
1318   { 0x642C2D2994B34A13LL, 1, 10, "__toString", &c_ReflectionFunction::ci___tostring },
1319   { 0x3235AF57F23103C4LL, 1, 10, "invokeArgs", &c_ReflectionFunction::ci_invokeargs },
1320   { 0x0B5ABC58C98E70E8LL, 1, 6, "export", &c_ReflectionFunction::ci_export },
1321   { 0x0D31D0AC229C615FLL, 1, 11, "__construct", &c_ReflectionFunction::ci___construct },
1322   { 0, 1, 0, 0 }
1323 };
1324 const int c_ReflectionFunction::s_call_info_index[] = {
1325   15,
1326   -1,-1,0,1,2,-1,-1,-1,
1327   3,-1,-1,-1,-1,-1,-1,4,
1328
1329 };
1330 c_ReflectionFunction *c_ReflectionFunction::create(CVarRef v_name) {
1331   CountableHelper h(this);
1332   init();
1333   t___construct(v_name);
1334   return this;
1335 }
1336 const ObjectStaticCallbacks cw_ReflectionFunction = {
1337   (ObjectData*(*)(ObjectData*))coo_ReflectionFunction,
1338   c_ReflectionFunction::s_call_info_table,c_ReflectionFunction::s_call_info_index,
1339   c_ReflectionFunction::s_instanceof_table,c_ReflectionFunction::s_instanceof_index,
1340   &c_ReflectionFunction::s_class_name,
1341   &c_ReflectionFunction::os_prop_table,&c_ReflectionFunction::ci___construct,0,&cw_ReflectionFunctionAbstract
1342 };
1343 /* SRC: classes/reflection.php line 465 */
1344 void c_ReflectionFunction::t___construct(Variant v_name) {
1345   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionFunction, ReflectionFunction::__construct);
1346   bool oldInCtor = gasInCtor(true);
1347   {
1348     const Array &tmp0((x_hphp_get_function_info(toString(v_name))));
1349     m_info = tmp0;
1350   }
1351   if (empty(m_info)) {
1352     {
1353       {
1354         p_ReflectionException tmp0 = coo_ReflectionException();
1355         throw_exception(((c_ReflectionException*)tmp0.get()->create(concat3(NAMSTR(s_sys_ss985d885e, "Function "), toString(v_name), NAMSTR(s_sys_ss5784ed2b, " does not exist"))), tmp0));
1356       }
1357     }
1358   }
1359   gasInCtor(oldInCtor);
1360 }
1361 namespace hphp_impl_splitter {}
1362 /* SRC: classes/reflection.php line 472 */
1363 String c_ReflectionFunction::t___tostring() {
1364   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionFunction, ReflectionFunction::__toString);
1365   return toString(null);
1366 }
1367 namespace hphp_impl_splitter {}
1368 /* SRC: classes/reflection.php line 492 */
1369 Variant c_ReflectionFunction::t_export(CVarRef v_name, CVarRef v_ret) {
1370   STATIC_METHOD_INJECTION_BUILTIN(ReflectionFunction, ReflectionFunction::export);
1371   p_ReflectionFunction v_obj;
1372   String v_str;
1373
1374   {
1375     p_ReflectionFunction tmp0 = coo_ReflectionFunction();
1376     ((c_ReflectionFunction*)tmp0.get()->create(v_name));
1377     v_obj = tmp0;
1378   }
1379   v_str = (toString(v_obj));
1380   if (toBoolean(v_ret)) {
1381     {
1382       return v_str;
1383     }
1384   }
1385   print(v_str);
1386   return null;
1387 }
1388 namespace hphp_impl_splitter {}
1389 /* SRC: classes/reflection.php line 508 */
1390 Variant c_ReflectionFunction::t_invoke(int num_args, Array args /* = Array() */) {
1391   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionFunction, ReflectionFunction::invoke);
1392   Array v_args;
1393
1394   {
1395     const Array &tmp0(((args.isNull() ? Array::Create() : args)));
1396     v_args = tmp0;
1397   }
1398   {
1399     const String &tmp0((toString(m_info.rvalAt(NAMSTR(s_sys_ssdc3cbddc, "name"), AccessFlags::Error_Key))));
1400     return x_hphp_invoke(tmp0, v_args);
1401   }
1402 }
1403 namespace hphp_impl_splitter {}
1404 /* SRC: classes/reflection.php line 523 */
1405 Variant c_ReflectionFunction::t_invokeargs(CVarRef v_args) {
1406   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionFunction, ReflectionFunction::invokeArgs);
1407   {
1408     const String &tmp0((toString(m_info.rvalAt(NAMSTR(s_sys_ssdc3cbddc, "name"), AccessFlags::Error_Key))));
1409     const Array &tmp1((toArray(x_array_values(v_args))));
1410     return x_hphp_invoke(tmp0, tmp1);
1411   }
1412 }
1413 namespace hphp_impl_splitter {}
1414 /* SRC: classes/reflection.php line 1355 */
1415 const int64 q_ReflectionProperty$$IS_STATIC = 1LL;
1416 const int64 q_ReflectionProperty$$IS_PUBLIC = 256LL;
1417 const int64 q_ReflectionProperty$$IS_PROTECTED = 512LL;
1418 const int64 q_ReflectionProperty$$IS_PRIVATE = 1024LL;
1419 IMPLEMENT_CLASS_NO_DEFAULT_SWEEP(ReflectionProperty)
1420 const InstanceOfInfo c_ReflectionProperty::s_instanceof_table[] = {
1421   {0x75AA2571BDB659E4LL,1,"ReflectionProperty",&cw_ReflectionProperty},
1422   {0x62F7F85447C0A605LL,1,"Reflector",(const ObjectStaticCallbacks*)2},
1423 };
1424 const int c_ReflectionProperty::s_instanceof_index[] = {
1425   3,
1426   0,1,-1,-1,
1427 };
1428 CallInfo c_ReflectionProperty::ci___tostring((void*)&c_ReflectionProperty::i___tostring, (void*)&c_ReflectionProperty::ifa___tostring, 0, 4, 0x0000000000000000LL);
1429 CallInfo c_ReflectionProperty::ci_setaccessible((void*)&c_ReflectionProperty::i_setaccessible, (void*)&c_ReflectionProperty::ifa_setaccessible, 1, 4, 0x0000000000000000LL);
1430 CallInfo c_ReflectionProperty::ci_isprotected((void*)&c_ReflectionProperty::i_isprotected, (void*)&c_ReflectionProperty::ifa_isprotected, 0, 4, 0x0000000000000000LL);
1431 CallInfo c_ReflectionProperty::ci_getmodifiers((void*)&c_ReflectionProperty::i_getmodifiers, (void*)&c_ReflectionProperty::ifa_getmodifiers, 0, 4, 0x0000000000000000LL);
1432 CallInfo c_ReflectionProperty::ci_getvalue((void*)&c_ReflectionProperty::i_getvalue, (void*)&c_ReflectionProperty::ifa_getvalue, 1, 4, 0x0000000000000000LL);
1433 CallInfo c_ReflectionProperty::ci_getdeclaringclass((void*)&c_ReflectionProperty::i_getdeclaringclass, (void*)&c_ReflectionProperty::ifa_getdeclaringclass, 0, 4, 0x0000000000000000LL);
1434 CallInfo c_ReflectionProperty::ci_isdefault((void*)&c_ReflectionProperty::i_isdefault, (void*)&c_ReflectionProperty::ifa_isdefault, 0, 4, 0x0000000000000000LL);
1435 CallInfo c_ReflectionProperty::ci_isprivate((void*)&c_ReflectionProperty::i_isprivate, (void*)&c_ReflectionProperty::ifa_isprivate, 0, 4, 0x0000000000000000LL);
1436 CallInfo c_ReflectionProperty::ci_getdoccomment((void*)&c_ReflectionProperty::i_getdoccomment, (void*)&c_ReflectionProperty::ifa_getdoccomment, 0, 4, 0x0000000000000000LL);
1437 CallInfo c_ReflectionProperty::ci_getname((void*)&c_ReflectionProperty::i_getname, (void*)&c_ReflectionProperty::ifa_getname, 0, 4, 0x0000000000000000LL);
1438 CallInfo c_ReflectionProperty::ci_export((void*)&c_ReflectionProperty::i_export, (void*)&c_ReflectionProperty::ifa_export, 3, 12, 0x0000000000000000LL);
1439 CallInfo c_ReflectionProperty::ci_isstatic((void*)&c_ReflectionProperty::i_isstatic, (void*)&c_ReflectionProperty::ifa_isstatic, 0, 4, 0x0000000000000000LL);
1440 CallInfo c_ReflectionProperty::ci_setvalue((void*)&c_ReflectionProperty::i_setvalue, (void*)&c_ReflectionProperty::ifa_setvalue, 2, 4, 0x0000000000000000LL);
1441 CallInfo c_ReflectionProperty::ci_ispublic((void*)&c_ReflectionProperty::i_ispublic, (void*)&c_ReflectionProperty::ifa_ispublic, 0, 4, 0x0000000000000000LL);
1442 CallInfo c_ReflectionProperty::ci___construct((void*)&c_ReflectionProperty::i___construct, (void*)&c_ReflectionProperty::ifa___construct, 2, 4, 0x0000000000000000LL);
1443 Variant c_ReflectionProperty::i___construct(MethodCallPackage &mcp, CArrRef params) {
1444   return invoke_meth_few_handler(mcp, params, &ifa___construct);
1445 }
1446 Variant c_ReflectionProperty::i___tostring(MethodCallPackage &mcp, CArrRef params) {
1447   return invoke_meth_few_handler(mcp, params, &ifa___tostring);
1448 }
1449 Variant c_ReflectionProperty::i_export(MethodCallPackage &mcp, CArrRef params) {
1450   return invoke_meth_few_handler(mcp, params, &ifa_export);
1451 }
1452 Variant c_ReflectionProperty::i_getname(MethodCallPackage &mcp, CArrRef params) {
1453   return invoke_meth_few_handler(mcp, params, &ifa_getname);
1454 }
1455 Variant c_ReflectionProperty::i_ispublic(MethodCallPackage &mcp, CArrRef params) {
1456   return invoke_meth_few_handler(mcp, params, &ifa_ispublic);
1457 }
1458 Variant c_ReflectionProperty::i_isprivate(MethodCallPackage &mcp, CArrRef params) {
1459   return invoke_meth_few_handler(mcp, params, &ifa_isprivate);
1460 }
1461 Variant c_ReflectionProperty::i_isprotected(MethodCallPackage &mcp, CArrRef params) {
1462   return invoke_meth_few_handler(mcp, params, &ifa_isprotected);
1463 }
1464 Variant c_ReflectionProperty::i_isstatic(MethodCallPackage &mcp, CArrRef params) {
1465   return invoke_meth_few_handler(mcp, params, &ifa_isstatic);
1466 }
1467 Variant c_ReflectionProperty::i_isdefault(MethodCallPackage &mcp, CArrRef params) {
1468   return invoke_meth_few_handler(mcp, params, &ifa_isdefault);
1469 }
1470 Variant c_ReflectionProperty::i_setaccessible(MethodCallPackage &mcp, CArrRef params) {
1471   return invoke_meth_few_handler(mcp, params, &ifa_setaccessible);
1472 }
1473 Variant c_ReflectionProperty::i_getmodifiers(MethodCallPackage &mcp, CArrRef params) {
1474   return invoke_meth_few_handler(mcp, params, &ifa_getmodifiers);
1475 }
1476 Variant c_ReflectionProperty::i_getvalue(MethodCallPackage &mcp, CArrRef params) {
1477   return invoke_meth_few_handler(mcp, params, &ifa_getvalue);
1478 }
1479 Variant c_ReflectionProperty::i_setvalue(MethodCallPackage &mcp, CArrRef params) {
1480   return invoke_meth_few_handler(mcp, params, &ifa_setvalue);
1481 }
1482 Variant c_ReflectionProperty::i_getdeclaringclass(MethodCallPackage &mcp, CArrRef params) {
1483   return invoke_meth_few_handler(mcp, params, &ifa_getdeclaringclass);
1484 }
1485 Variant c_ReflectionProperty::i_getdoccomment(MethodCallPackage &mcp, CArrRef params) {
1486   return invoke_meth_few_handler(mcp, params, &ifa_getdoccomment);
1487 }
1488 Variant c_ReflectionProperty::ifa___construct(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1489   if (UNLIKELY(mcp.obj == 0)) {
1490     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa___construct, coo_ReflectionProperty);
1491   }
1492   c_ReflectionProperty *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionProperty*>(mcp.obj));
1493   if (UNLIKELY(count != 2)) return throw_wrong_arguments("ReflectionProperty::__construct", count, 2, 2, 2);
1494   CVarRef arg0(a0);
1495   CVarRef arg1(a1);
1496   return (self->t___construct(arg0, arg1), null);
1497 }
1498 Variant c_ReflectionProperty::ifa___tostring(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1499   if (UNLIKELY(mcp.obj == 0)) {
1500     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa___tostring, coo_ReflectionProperty);
1501   }
1502   c_ReflectionProperty *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionProperty*>(mcp.obj));
1503   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionProperty::__toString", 0, 1);
1504   return (self->t___tostring());
1505 }
1506 Variant c_ReflectionProperty::ifa_export(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1507   if (UNLIKELY(count != 3)) return throw_wrong_arguments("ReflectionProperty::export", count, 3, 3, 1);
1508   CVarRef arg0(a0);
1509   CVarRef arg1(a1);
1510   CVarRef arg2(a2);
1511   return (c_ReflectionProperty::t_export(arg0, arg1, arg2));
1512 }
1513 Variant c_ReflectionProperty::ifa_getname(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1514   if (UNLIKELY(mcp.obj == 0)) {
1515     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getname, coo_ReflectionProperty);
1516   }
1517   c_ReflectionProperty *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionProperty*>(mcp.obj));
1518   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionProperty::getName", 0, 1);
1519   return (self->t_getname());
1520 }
1521 Variant c_ReflectionProperty::ifa_ispublic(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1522   if (UNLIKELY(mcp.obj == 0)) {
1523     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_ispublic, coo_ReflectionProperty);
1524   }
1525   c_ReflectionProperty *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionProperty*>(mcp.obj));
1526   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionProperty::isPublic", 0, 1);
1527   return (self->t_ispublic());
1528 }
1529 Variant c_ReflectionProperty::ifa_isprivate(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1530   if (UNLIKELY(mcp.obj == 0)) {
1531     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isprivate, coo_ReflectionProperty);
1532   }
1533   c_ReflectionProperty *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionProperty*>(mcp.obj));
1534   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionProperty::isPrivate", 0, 1);
1535   return (self->t_isprivate());
1536 }
1537 Variant c_ReflectionProperty::ifa_isprotected(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1538   if (UNLIKELY(mcp.obj == 0)) {
1539     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isprotected, coo_ReflectionProperty);
1540   }
1541   c_ReflectionProperty *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionProperty*>(mcp.obj));
1542   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionProperty::isProtected", 0, 1);
1543   return (self->t_isprotected());
1544 }
1545 Variant c_ReflectionProperty::ifa_isstatic(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1546   if (UNLIKELY(mcp.obj == 0)) {
1547     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isstatic, coo_ReflectionProperty);
1548   }
1549   c_ReflectionProperty *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionProperty*>(mcp.obj));
1550   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionProperty::isStatic", 0, 1);
1551   return (self->t_isstatic());
1552 }
1553 Variant c_ReflectionProperty::ifa_isdefault(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1554   if (UNLIKELY(mcp.obj == 0)) {
1555     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isdefault, coo_ReflectionProperty);
1556   }
1557   c_ReflectionProperty *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionProperty*>(mcp.obj));
1558   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionProperty::isDefault", 0, 1);
1559   return (self->t_isdefault());
1560 }
1561 Variant c_ReflectionProperty::ifa_setaccessible(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1562   if (UNLIKELY(mcp.obj == 0)) {
1563     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_setaccessible, coo_ReflectionProperty);
1564   }
1565   c_ReflectionProperty *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionProperty*>(mcp.obj));
1566   if (UNLIKELY(count != 1)) return throw_wrong_arguments("ReflectionProperty::setAccessible", count, 1, 1, 1);
1567   CVarRef arg0(a0);
1568   return (self->t_setaccessible(arg0), null);
1569 }
1570 Variant c_ReflectionProperty::ifa_getmodifiers(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1571   if (UNLIKELY(mcp.obj == 0)) {
1572     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getmodifiers, coo_ReflectionProperty);
1573   }
1574   c_ReflectionProperty *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionProperty*>(mcp.obj));
1575   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionProperty::getModifiers", 0, 1);
1576   return (self->t_getmodifiers());
1577 }
1578 Variant c_ReflectionProperty::ifa_getvalue(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1579   if (UNLIKELY(mcp.obj == 0)) {
1580     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getvalue, coo_ReflectionProperty);
1581   }
1582   c_ReflectionProperty *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionProperty*>(mcp.obj));
1583   if (UNLIKELY(count > 1)) return throw_toomany_arguments("ReflectionProperty::getValue", 1, 1);
1584   if (count <= 0) return (self->t_getvalue());
1585   CVarRef arg0(a0);
1586   return (self->t_getvalue(arg0));
1587 }
1588 Variant c_ReflectionProperty::ifa_setvalue(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1589   if (UNLIKELY(mcp.obj == 0)) {
1590     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_setvalue, coo_ReflectionProperty);
1591   }
1592   c_ReflectionProperty *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionProperty*>(mcp.obj));
1593   if (UNLIKELY(count != 2)) return throw_wrong_arguments("ReflectionProperty::setValue", count, 2, 2, 1);
1594   CVarRef arg0(a0);
1595   CVarRef arg1(a1);
1596   return (self->t_setvalue(arg0, arg1), null);
1597 }
1598 Variant c_ReflectionProperty::ifa_getdeclaringclass(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1599   if (UNLIKELY(mcp.obj == 0)) {
1600     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getdeclaringclass, coo_ReflectionProperty);
1601   }
1602   c_ReflectionProperty *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionProperty*>(mcp.obj));
1603   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionProperty::getDeclaringClass", 0, 1);
1604   return (self->t_getdeclaringclass());
1605 }
1606 Variant c_ReflectionProperty::ifa_getdoccomment(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1607   if (UNLIKELY(mcp.obj == 0)) {
1608     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getdoccomment, coo_ReflectionProperty);
1609   }
1610   c_ReflectionProperty *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionProperty*>(mcp.obj));
1611   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionProperty::getDocComment", 0, 1);
1612   return (self->t_getdoccomment());
1613 }
1614 const MethodCallInfoTable c_ReflectionProperty::s_call_info_table[] = {
1615   { 0x791E9751F5B8C5A2LL, 1, 13, "setAccessible", &c_ReflectionProperty::ci_setaccessible },
1616   { 0x56879BCEB40997E3LL, 1, 8, "getValue", &c_ReflectionProperty::ci_getvalue },
1617   { 0x6ED51288559D6063LL, 0, 17, "getDeclaringClass", &c_ReflectionProperty::ci_getdeclaringclass },
1618   { 0x23F51CDECC198965LL, 1, 7, "getName", &c_ReflectionProperty::ci_getname },
1619   { 0x0B5ABC58C98E70E8LL, 1, 6, "export", &c_ReflectionProperty::ci_export },
1620   { 0x2D7209A590477CEALL, 1, 11, "isProtected", &c_ReflectionProperty::ci_isprotected },
1621   { 0x37AAE0845E2F636FLL, 1, 9, "isPrivate", &c_ReflectionProperty::ci_isprivate },
1622   { 0x642C2D2994B34A13LL, 1, 10, "__toString", &c_ReflectionProperty::ci___tostring },
1623   { 0x24253EBA491D6014LL, 1, 12, "getModifiers", &c_ReflectionProperty::ci_getmodifiers },
1624   { 0x384A52597AB11F15LL, 1, 9, "isDefault", &c_ReflectionProperty::ci_isdefault },
1625   { 0x36FBED35008C8DB5LL, 0, 8, "setValue", &c_ReflectionProperty::ci_setvalue },
1626   { 0x7C4F424FDA56ADF8LL, 1, 13, "getDocComment", &c_ReflectionProperty::ci_getdoccomment },
1627   { 0x7A15DC56E8CC0B19LL, 1, 8, "isStatic", &c_ReflectionProperty::ci_isstatic },
1628   { 0x2820F10358723B7CLL, 1, 8, "isPublic", &c_ReflectionProperty::ci_ispublic },
1629   { 0x0D31D0AC229C615FLL, 1, 11, "__construct", &c_ReflectionProperty::ci___construct },
1630   { 0, 1, 0, 0 }
1631 };
1632 const int c_ReflectionProperty::s_call_info_index[] = {
1633   31,
1634   -1,-1,0,1,-1,3,-1,-1,
1635   4,-1,5,-1,-1,-1,-1,6,
1636   -1,-1,-1,7,8,9,-1,-1,
1637   11,12,-1,-1,13,-1,-1,14,
1638
1639 };
1640 c_ReflectionProperty *c_ReflectionProperty::create(CVarRef v_cls, CVarRef v_name) {
1641   CountableHelper h(this);
1642   init();
1643   t___construct(v_cls, v_name);
1644   return this;
1645 }
1646 const ObjectStaticCallbacks cw_ReflectionProperty = {
1647   (ObjectData*(*)(ObjectData*))coo_ReflectionProperty,
1648   c_ReflectionProperty::s_call_info_table,c_ReflectionProperty::s_call_info_index,
1649   c_ReflectionProperty::s_instanceof_table,c_ReflectionProperty::s_instanceof_index,
1650   &c_ReflectionProperty::s_class_name,
1651   &c_ReflectionProperty::os_prop_table,&c_ReflectionProperty::ci___construct,0,0
1652 };
1653 /* SRC: classes/reflection.php line 1365 */
1654 void c_ReflectionProperty::t___construct(Variant v_cls, Variant v_name) {
1655   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionProperty, ReflectionProperty::__construct);
1656   bool oldInCtor = gasInCtor(true);
1657   Variant v_prop;
1658
1659   if ((toBoolean(v_cls) && toBoolean(v_name))) {
1660     {
1661       if (!(x_is_object(v_cls))) {
1662         {
1663           {
1664             p_ReflectionClass tmp0 = coo_ReflectionClass();
1665             ((c_ReflectionClass*)tmp0.get()->create(v_cls));
1666             v_cls = tmp0;
1667           }
1668         }
1669       }
1670       else {
1671         {
1672           {
1673             p_ReflectionClass tmp0 = coo_ReflectionClass();
1674             const Variant &tmp1((x_get_class(v_cls)));
1675             ((c_ReflectionClass*)tmp0.get()->create(tmp1));
1676             v_cls = tmp0;
1677           }
1678         }
1679       }
1680       {
1681         MethodCallPackage mcp0;
1682         CVarRef obj0 = v_cls;
1683         mcp0.methodCall((obj0), NAMSTR(s_sys_ssd029c1ac, "getProperty"), 0x0FD73627FB023047LL);
1684         const CallInfo *cit0 ATTRIBUTE_UNUSED = mcp0.ci;
1685         Variant tmp1(((mcp0.bindClass(fi)->getMeth1Args())(mcp0, 1, v_name)));
1686         v_prop.assignVal(tmp1);
1687       }
1688       if (toBoolean(v_prop)) {
1689         {
1690           {
1691             const Variant &tmp0((v_prop.o_getPublic(NAMSTR(s_sys_ss33988b3e, "info"), true)));
1692             m_info.assignVal(tmp0);
1693           }
1694           {
1695             const Variant &tmp0((v_prop.o_getPublic(NAMSTR(s_sys_ssdc3cbddc, "name"), true)));
1696             m_name.assignVal(tmp0);
1697           }
1698           {
1699             const Variant &tmp0((v_prop.o_getPublic(NAMSTR(s_sys_ssc82dbd12, "class"), true)));
1700             m_class.assignVal(tmp0);
1701           }
1702         }
1703       }
1704     }
1705   }
1706   gasInCtor(oldInCtor);
1707 }
1708 namespace hphp_impl_splitter {}
1709 /* SRC: classes/reflection.php line 1381 */
1710 String c_ReflectionProperty::t___tostring() {
1711   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionProperty, ReflectionProperty::__toString);
1712   return toString(null);
1713 }
1714 namespace hphp_impl_splitter {}
1715 /* SRC: classes/reflection.php line 1397 */
1716 Variant c_ReflectionProperty::t_export(Variant v_cls, CVarRef v_name, CVarRef v_ret) {
1717   STATIC_METHOD_INJECTION_BUILTIN(ReflectionProperty, ReflectionProperty::export);
1718   Variant v_obj;
1719   String v_str;
1720
1721   if (!(x_is_object(v_cls))) {
1722     {
1723       {
1724         p_ReflectionClass tmp0 = coo_ReflectionClass();
1725         ((c_ReflectionClass*)tmp0.get()->create(v_cls));
1726         v_cls = tmp0;
1727       }
1728     }
1729   }
1730   else {
1731     {
1732       {
1733         p_ReflectionClass tmp0 = coo_ReflectionClass();
1734         const Variant &tmp1((x_get_class(v_cls)));
1735         ((c_ReflectionClass*)tmp0.get()->create(tmp1));
1736         v_cls = tmp0;
1737       }
1738     }
1739   }
1740   {
1741     MethodCallPackage mcp0;
1742     CVarRef obj0 = v_cls;
1743     mcp0.methodCall((obj0), NAMSTR(s_sys_ssd029c1ac, "getProperty"), 0x0FD73627FB023047LL);
1744     const CallInfo *cit0 ATTRIBUTE_UNUSED = mcp0.ci;
1745     Variant tmp1(((mcp0.bindClass(fi)->getMeth1Args())(mcp0, 1, v_name)));
1746     v_obj.assignVal(tmp1);
1747   }
1748   v_str = (toString(v_obj));
1749   if (toBoolean(v_ret)) {
1750     {
1751       return v_str;
1752     }
1753   }
1754   print(v_str);
1755   return null;
1756 }
1757 namespace hphp_impl_splitter {}
1758 /* SRC: classes/reflection.php line 1420 */
1759 Variant c_ReflectionProperty::t_getname() {
1760   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionProperty, ReflectionProperty::getName);
1761   return m_info.rvalAt(NAMSTR(s_sys_ssdc3cbddc, "name"), AccessFlags::Error_Key);
1762 }
1763 namespace hphp_impl_splitter {}
1764 /* SRC: classes/reflection.php line 1433 */
1765 bool c_ReflectionProperty::t_ispublic() {
1766   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionProperty, ReflectionProperty::isPublic);
1767   {
1768     const Variant &tmp0((m_info.rvalAt(NAMSTR(s_sys_ss750cda3b, "access"), AccessFlags::Error_Key)));
1769     return equal(tmp0, NAMSTR(s_sys_ss4ce85288, "public"));
1770   }
1771 }
1772 namespace hphp_impl_splitter {}
1773 /* SRC: classes/reflection.php line 1446 */
1774 bool c_ReflectionProperty::t_isprivate() {
1775   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionProperty, ReflectionProperty::isPrivate);
1776   {
1777     const Variant &tmp0((m_info.rvalAt(NAMSTR(s_sys_ss750cda3b, "access"), AccessFlags::Error_Key)));
1778     return equal(tmp0, NAMSTR(s_sys_sse781f7da, "private"));
1779   }
1780 }
1781 namespace hphp_impl_splitter {}
1782 /* SRC: classes/reflection.php line 1459 */
1783 bool c_ReflectionProperty::t_isprotected() {
1784   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionProperty, ReflectionProperty::isProtected);
1785   {
1786     const Variant &tmp0((m_info.rvalAt(NAMSTR(s_sys_ss750cda3b, "access"), AccessFlags::Error_Key)));
1787     return equal(tmp0, NAMSTR(s_sys_ss9fb56979, "protected"));
1788   }
1789 }
1790 namespace hphp_impl_splitter {}
1791 /* SRC: classes/reflection.php line 1472 */
1792 Variant c_ReflectionProperty::t_isstatic() {
1793   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionProperty, ReflectionProperty::isStatic);
1794   return m_info.rvalAt(NAMSTR(s_sys_ssf08d205d, "static"), AccessFlags::Error_Key);
1795 }
1796 namespace hphp_impl_splitter {}
1797 /* SRC: classes/reflection.php line 1486 */
1798 Variant c_ReflectionProperty::t_isdefault() {
1799   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionProperty, ReflectionProperty::isDefault);
1800   return m_info.rvalAt(NAMSTR(s_sys_ss570270cc, "default"), AccessFlags::Error_Key);
1801 }
1802 namespace hphp_impl_splitter {}
1803 /* SRC: classes/reflection.php line 1500 */
1804 void c_ReflectionProperty::t_setaccessible(CVarRef v_accessible) {
1805   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionProperty, ReflectionProperty::setAccessible);
1806   throw_exception(p_ReflectionException(((c_ReflectionException*)coo_ReflectionException())->create(NAMSTR(s_sys_ssf82f565f, "ReflectionProperty::setAccessible is not supported"))));
1807 }
1808 namespace hphp_impl_splitter {}
1809 /* SRC: classes/reflection.php line 1514 */
1810 Variant c_ReflectionProperty::t_getmodifiers() {
1811   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionProperty, ReflectionProperty::getModifiers);
1812   return m_info.rvalAt(NAMSTR(s_sys_ss9f244c80, "modifiers"), AccessFlags::Error_Key);
1813 }
1814 namespace hphp_impl_splitter {}
1815 /* SRC: classes/reflection.php line 1530 */
1816 Variant c_ReflectionProperty::t_getvalue(CVarRef v_obj //  = null_variant
1817 ) {
1818   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionProperty, ReflectionProperty::getValue);
1819   if (toBoolean(t_isstatic())) {
1820     {
1821       {
1822         const String &tmp0((toString(m_info.rvalAt(NAMSTR(s_sys_ssc82dbd12, "class"), AccessFlags::Error_Key))));
1823         const String &tmp1((toString(m_info.rvalAt(NAMSTR(s_sys_ssdc3cbddc, "name"), AccessFlags::Error_Key))));
1824         return x_hphp_get_static_property(tmp0, tmp1);
1825       }
1826     }
1827   }
1828   if (toBoolean(v_obj)) {
1829     {
1830       {
1831         const Object &tmp0((toObject(v_obj)));
1832         const String &tmp1((toString(m_info.rvalAt(NAMSTR(s_sys_ssc82dbd12, "class"), AccessFlags::Error_Key))));
1833         const String &tmp2((toString(m_info.rvalAt(NAMSTR(s_sys_ssdc3cbddc, "name"), AccessFlags::Error_Key))));
1834         return x_hphp_get_property(tmp0, tmp1, tmp2);
1835       }
1836     }
1837   }
1838   return null;
1839 }
1840 namespace hphp_impl_splitter {}
1841 /* SRC: classes/reflection.php line 1555 */
1842 void c_ReflectionProperty::t_setvalue(CVarRef v_obj, CVarRef v_value) {
1843   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionProperty, ReflectionProperty::setValue);
1844   if (toBoolean(t_isstatic())) {
1845     {
1846       {
1847         const String &tmp0((toString(m_info.rvalAt(NAMSTR(s_sys_ssc82dbd12, "class"), AccessFlags::Error_Key))));
1848         const String &tmp1((toString(m_info.rvalAt(NAMSTR(s_sys_ssdc3cbddc, "name"), AccessFlags::Error_Key))));
1849         x_hphp_set_static_property(tmp0, tmp1, v_value);
1850       }
1851     }
1852   }
1853   else {
1854     {
1855       {
1856         const Object &tmp0((toObject(v_obj)));
1857         const String &tmp1((toString(m_info.rvalAt(NAMSTR(s_sys_ssc82dbd12, "class"), AccessFlags::Error_Key))));
1858         const String &tmp2((toString(m_info.rvalAt(NAMSTR(s_sys_ssdc3cbddc, "name"), AccessFlags::Error_Key))));
1859         x_hphp_set_property(tmp0, tmp1, tmp2, v_value);
1860       }
1861     }
1862   }
1863 }
1864 namespace hphp_impl_splitter {}
1865 /* SRC: classes/reflection.php line 1575 */
1866 Variant c_ReflectionProperty::t_getdeclaringclass() {
1867   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionProperty, ReflectionProperty::getDeclaringClass);
1868   {
1869     bool tmp0;
1870     {
1871       tmp0 = (empty(m_info, NAMSTR(s_sys_ssc82dbd12, "class"), true));
1872     }
1873     if (tmp0) {
1874       {
1875         return null;
1876       }
1877     }
1878   }
1879   {
1880     p_ReflectionClass tmp0 = coo_ReflectionClass();
1881     const Variant &tmp1((m_info.rvalAt(NAMSTR(s_sys_ssc82dbd12, "class"), AccessFlags::Error_Key)));
1882     return ((c_ReflectionClass*)tmp0.get()->create(tmp1), tmp0);
1883   }
1884 }
1885 namespace hphp_impl_splitter {}
1886 /* SRC: classes/reflection.php line 1592 */
1887 Variant c_ReflectionProperty::t_getdoccomment() {
1888   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionProperty, ReflectionProperty::getDocComment);
1889   return m_info.rvalAt(NAMSTR(s_sys_ss9cfa17a6, "doc"), AccessFlags::Error_Key);
1890 }
1891 namespace hphp_impl_splitter {}
1892 /* SRC: classes/reflection.php line 248 */
1893 IMPLEMENT_CLASS_NO_DEFAULT_SWEEP(ReflectionFunctionAbstract)
1894 const InstanceOfInfo c_ReflectionFunctionAbstract::s_instanceof_table[] = {
1895   {0x33BD46E935281082LL,1,"ReflectionFunctionAbstract",&cw_ReflectionFunctionAbstract},
1896 };
1897 const int c_ReflectionFunctionAbstract::s_instanceof_index[] = {
1898   1,
1899   0,-1,
1900 };
1901 CallInfo c_ReflectionFunctionAbstract::ci_getnumberofrequiredparameters((void*)&c_ReflectionFunctionAbstract::i_getnumberofrequiredparameters, (void*)&c_ReflectionFunctionAbstract::ifa_getnumberofrequiredparameters, 0, 4, 0x0000000000000000LL);
1902 CallInfo c_ReflectionFunctionAbstract::ci_returnsreference((void*)&c_ReflectionFunctionAbstract::i_returnsreference, (void*)&c_ReflectionFunctionAbstract::ifa_returnsreference, 0, 4, 0x0000000000000000LL);
1903 CallInfo c_ReflectionFunctionAbstract::ci_getstartline((void*)&c_ReflectionFunctionAbstract::i_getstartline, (void*)&c_ReflectionFunctionAbstract::ifa_getstartline, 0, 4, 0x0000000000000000LL);
1904 CallInfo c_ReflectionFunctionAbstract::ci_getclosure((void*)&c_ReflectionFunctionAbstract::i_getclosure, (void*)&c_ReflectionFunctionAbstract::ifa_getclosure, 0, 4, 0x0000000000000000LL);
1905 CallInfo c_ReflectionFunctionAbstract::ci_getparameters((void*)&c_ReflectionFunctionAbstract::i_getparameters, (void*)&c_ReflectionFunctionAbstract::ifa_getparameters, 0, 4, 0x0000000000000000LL);
1906 CallInfo c_ReflectionFunctionAbstract::ci_getstaticvariables((void*)&c_ReflectionFunctionAbstract::i_getstaticvariables, (void*)&c_ReflectionFunctionAbstract::ifa_getstaticvariables, 0, 4, 0x0000000000000000LL);
1907 CallInfo c_ReflectionFunctionAbstract::ci_getnumberofparameters((void*)&c_ReflectionFunctionAbstract::i_getnumberofparameters, (void*)&c_ReflectionFunctionAbstract::ifa_getnumberofparameters, 0, 4, 0x0000000000000000LL);
1908 CallInfo c_ReflectionFunctionAbstract::ci_isuserdefined((void*)&c_ReflectionFunctionAbstract::i_isuserdefined, (void*)&c_ReflectionFunctionAbstract::ifa_isuserdefined, 0, 4, 0x0000000000000000LL);
1909 CallInfo c_ReflectionFunctionAbstract::ci_getdoccomment((void*)&c_ReflectionFunctionAbstract::i_getdoccomment, (void*)&c_ReflectionFunctionAbstract::ifa_getdoccomment, 0, 4, 0x0000000000000000LL);
1910 CallInfo c_ReflectionFunctionAbstract::ci_getfilename((void*)&c_ReflectionFunctionAbstract::i_getfilename, (void*)&c_ReflectionFunctionAbstract::ifa_getfilename, 0, 4, 0x0000000000000000LL);
1911 CallInfo c_ReflectionFunctionAbstract::ci_getname((void*)&c_ReflectionFunctionAbstract::i_getname, (void*)&c_ReflectionFunctionAbstract::ifa_getname, 0, 4, 0x0000000000000000LL);
1912 CallInfo c_ReflectionFunctionAbstract::ci_isinternal((void*)&c_ReflectionFunctionAbstract::i_isinternal, (void*)&c_ReflectionFunctionAbstract::ifa_isinternal, 0, 4, 0x0000000000000000LL);
1913 CallInfo c_ReflectionFunctionAbstract::ci_getendline((void*)&c_ReflectionFunctionAbstract::i_getendline, (void*)&c_ReflectionFunctionAbstract::ifa_getendline, 0, 4, 0x0000000000000000LL);
1914 Variant c_ReflectionFunctionAbstract::i_getname(MethodCallPackage &mcp, CArrRef params) {
1915   return invoke_meth_few_handler(mcp, params, &ifa_getname);
1916 }
1917 Variant c_ReflectionFunctionAbstract::i_isinternal(MethodCallPackage &mcp, CArrRef params) {
1918   return invoke_meth_few_handler(mcp, params, &ifa_isinternal);
1919 }
1920 Variant c_ReflectionFunctionAbstract::i_getclosure(MethodCallPackage &mcp, CArrRef params) {
1921   return invoke_meth_few_handler(mcp, params, &ifa_getclosure);
1922 }
1923 Variant c_ReflectionFunctionAbstract::i_isuserdefined(MethodCallPackage &mcp, CArrRef params) {
1924   return invoke_meth_few_handler(mcp, params, &ifa_isuserdefined);
1925 }
1926 Variant c_ReflectionFunctionAbstract::i_getfilename(MethodCallPackage &mcp, CArrRef params) {
1927   return invoke_meth_few_handler(mcp, params, &ifa_getfilename);
1928 }
1929 Variant c_ReflectionFunctionAbstract::i_getstartline(MethodCallPackage &mcp, CArrRef params) {
1930   return invoke_meth_few_handler(mcp, params, &ifa_getstartline);
1931 }
1932 Variant c_ReflectionFunctionAbstract::i_getendline(MethodCallPackage &mcp, CArrRef params) {
1933   return invoke_meth_few_handler(mcp, params, &ifa_getendline);
1934 }
1935 Variant c_ReflectionFunctionAbstract::i_getdoccomment(MethodCallPackage &mcp, CArrRef params) {
1936   return invoke_meth_few_handler(mcp, params, &ifa_getdoccomment);
1937 }
1938 Variant c_ReflectionFunctionAbstract::i_getstaticvariables(MethodCallPackage &mcp, CArrRef params) {
1939   return invoke_meth_few_handler(mcp, params, &ifa_getstaticvariables);
1940 }
1941 Variant c_ReflectionFunctionAbstract::i_returnsreference(MethodCallPackage &mcp, CArrRef params) {
1942   return invoke_meth_few_handler(mcp, params, &ifa_returnsreference);
1943 }
1944 Variant c_ReflectionFunctionAbstract::i_getparameters(MethodCallPackage &mcp, CArrRef params) {
1945   return invoke_meth_few_handler(mcp, params, &ifa_getparameters);
1946 }
1947 Variant c_ReflectionFunctionAbstract::i_getnumberofparameters(MethodCallPackage &mcp, CArrRef params) {
1948   return invoke_meth_few_handler(mcp, params, &ifa_getnumberofparameters);
1949 }
1950 Variant c_ReflectionFunctionAbstract::i_getnumberofrequiredparameters(MethodCallPackage &mcp, CArrRef params) {
1951   return invoke_meth_few_handler(mcp, params, &ifa_getnumberofrequiredparameters);
1952 }
1953 Variant c_ReflectionFunctionAbstract::ifa_getname(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1954   if (UNLIKELY(mcp.obj == 0)) {
1955     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getname, coo_ReflectionFunctionAbstract);
1956   }
1957   c_ReflectionFunctionAbstract *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunctionAbstract*>(mcp.obj));
1958   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionFunctionAbstract::getName", 0, 1);
1959   return (self->t_getname());
1960 }
1961 Variant c_ReflectionFunctionAbstract::ifa_isinternal(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1962   if (UNLIKELY(mcp.obj == 0)) {
1963     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isinternal, coo_ReflectionFunctionAbstract);
1964   }
1965   c_ReflectionFunctionAbstract *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunctionAbstract*>(mcp.obj));
1966   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionFunctionAbstract::isInternal", 0, 1);
1967   return (self->t_isinternal());
1968 }
1969 Variant c_ReflectionFunctionAbstract::ifa_getclosure(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1970   if (UNLIKELY(mcp.obj == 0)) {
1971     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getclosure, coo_ReflectionFunctionAbstract);
1972   }
1973   c_ReflectionFunctionAbstract *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunctionAbstract*>(mcp.obj));
1974   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionFunctionAbstract::getClosure", 0, 1);
1975   return (self->t_getclosure());
1976 }
1977 Variant c_ReflectionFunctionAbstract::ifa_isuserdefined(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1978   if (UNLIKELY(mcp.obj == 0)) {
1979     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isuserdefined, coo_ReflectionFunctionAbstract);
1980   }
1981   c_ReflectionFunctionAbstract *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunctionAbstract*>(mcp.obj));
1982   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionFunctionAbstract::isUserDefined", 0, 1);
1983   return (self->t_isuserdefined());
1984 }
1985 Variant c_ReflectionFunctionAbstract::ifa_getfilename(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1986   if (UNLIKELY(mcp.obj == 0)) {
1987     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getfilename, coo_ReflectionFunctionAbstract);
1988   }
1989   c_ReflectionFunctionAbstract *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunctionAbstract*>(mcp.obj));
1990   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionFunctionAbstract::getFileName", 0, 1);
1991   return (self->t_getfilename());
1992 }
1993 Variant c_ReflectionFunctionAbstract::ifa_getstartline(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
1994   if (UNLIKELY(mcp.obj == 0)) {
1995     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getstartline, coo_ReflectionFunctionAbstract);
1996   }
1997   c_ReflectionFunctionAbstract *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunctionAbstract*>(mcp.obj));
1998   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionFunctionAbstract::getStartLine", 0, 1);
1999   return (self->t_getstartline());
2000 }
2001 Variant c_ReflectionFunctionAbstract::ifa_getendline(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2002   if (UNLIKELY(mcp.obj == 0)) {
2003     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getendline, coo_ReflectionFunctionAbstract);
2004   }
2005   c_ReflectionFunctionAbstract *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunctionAbstract*>(mcp.obj));
2006   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionFunctionAbstract::getEndLine", 0, 1);
2007   return (self->t_getendline());
2008 }
2009 Variant c_ReflectionFunctionAbstract::ifa_getdoccomment(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2010   if (UNLIKELY(mcp.obj == 0)) {
2011     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getdoccomment, coo_ReflectionFunctionAbstract);
2012   }
2013   c_ReflectionFunctionAbstract *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunctionAbstract*>(mcp.obj));
2014   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionFunctionAbstract::getDocComment", 0, 1);
2015   return (self->t_getdoccomment());
2016 }
2017 Variant c_ReflectionFunctionAbstract::ifa_getstaticvariables(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2018   if (UNLIKELY(mcp.obj == 0)) {
2019     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getstaticvariables, coo_ReflectionFunctionAbstract);
2020   }
2021   c_ReflectionFunctionAbstract *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunctionAbstract*>(mcp.obj));
2022   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionFunctionAbstract::getStaticVariables", 0, 1);
2023   return (self->t_getstaticvariables());
2024 }
2025 Variant c_ReflectionFunctionAbstract::ifa_returnsreference(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2026   if (UNLIKELY(mcp.obj == 0)) {
2027     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_returnsreference, coo_ReflectionFunctionAbstract);
2028   }
2029   c_ReflectionFunctionAbstract *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunctionAbstract*>(mcp.obj));
2030   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionFunctionAbstract::returnsReference", 0, 1);
2031   return (self->t_returnsreference());
2032 }
2033 Variant c_ReflectionFunctionAbstract::ifa_getparameters(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2034   if (UNLIKELY(mcp.obj == 0)) {
2035     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getparameters, coo_ReflectionFunctionAbstract);
2036   }
2037   c_ReflectionFunctionAbstract *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunctionAbstract*>(mcp.obj));
2038   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionFunctionAbstract::getParameters", 0, 1);
2039   return (self->t_getparameters());
2040 }
2041 Variant c_ReflectionFunctionAbstract::ifa_getnumberofparameters(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2042   if (UNLIKELY(mcp.obj == 0)) {
2043     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getnumberofparameters, coo_ReflectionFunctionAbstract);
2044   }
2045   c_ReflectionFunctionAbstract *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunctionAbstract*>(mcp.obj));
2046   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionFunctionAbstract::getNumberOfParameters", 0, 1);
2047   return (self->t_getnumberofparameters());
2048 }
2049 Variant c_ReflectionFunctionAbstract::ifa_getnumberofrequiredparameters(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2050   if (UNLIKELY(mcp.obj == 0)) {
2051     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getnumberofrequiredparameters, coo_ReflectionFunctionAbstract);
2052   }
2053   c_ReflectionFunctionAbstract *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionFunctionAbstract*>(mcp.obj));
2054   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionFunctionAbstract::getNumberOfRequiredParameters", 0, 1);
2055   return (self->t_getnumberofrequiredparameters());
2056 }
2057 const MethodCallInfoTable c_ReflectionFunctionAbstract::s_call_info_table[] = {
2058   { 0x57D8DC34C9A03560LL, 1, 21, "getNumberOfParameters", &c_ReflectionFunctionAbstract::ci_getnumberofparameters },
2059   { 0x4D637DECDBFA6221LL, 1, 29, "getNumberOfRequiredParameters", &c_ReflectionFunctionAbstract::ci_getnumberofrequiredparameters },
2060   { 0x33A6C2CFBDB05EE2LL, 1, 10, "getClosure", &c_ReflectionFunctionAbstract::ci_getclosure },
2061   { 0x6A6B8BECAE7D4164LL, 1, 13, "isUserDefined", &c_ReflectionFunctionAbstract::ci_isuserdefined },
2062   { 0x39C1BB731CB1CB04LL, 0, 12, "getStartLine", &c_ReflectionFunctionAbstract::ci_getstartline },
2063   { 0x23F51CDECC198965LL, 1, 7, "getName", &c_ReflectionFunctionAbstract::ci_getname },
2064   { 0x37FFB8F44A3329A8LL, 1, 18, "getStaticVariables", &c_ReflectionFunctionAbstract::ci_getstaticvariables },
2065   { 0x1A3AB3B0276D2668LL, 0, 16, "returnsReference", &c_ReflectionFunctionAbstract::ci_returnsreference },
2066   { 0x1930CE336D39474DLL, 1, 11, "getFileName", &c_ReflectionFunctionAbstract::ci_getfilename },
2067   { 0x3E62225132C2A32DLL, 0, 13, "getParameters", &c_ReflectionFunctionAbstract::ci_getparameters },
2068   { 0x48FDF6C5835C64CFLL, 1, 10, "isInternal", &c_ReflectionFunctionAbstract::ci_isinternal },
2069   { 0x6C19E85007BC4570LL, 1, 10, "getEndLine", &c_ReflectionFunctionAbstract::ci_getendline },
2070   { 0x7C4F424FDA56ADF8LL, 1, 13, "getDocComment", &c_ReflectionFunctionAbstract::ci_getdoccomment },
2071   { 0, 1, 0, 0 }
2072 };
2073 const int c_ReflectionFunctionAbstract::s_call_info_index[] = {
2074   31,
2075   0,1,2,-1,3,5,-1,-1,
2076   6,-1,-1,-1,-1,8,-1,10,
2077   11,-1,-1,-1,-1,-1,-1,-1,
2078   12,-1,-1,-1,-1,-1,-1,-1,
2079
2080 };
2081 const ObjectStaticCallbacks cw_ReflectionFunctionAbstract = {
2082   (ObjectData*(*)(ObjectData*))coo_ReflectionFunctionAbstract,
2083   c_ReflectionFunctionAbstract::s_call_info_table,c_ReflectionFunctionAbstract::s_call_info_index,
2084   c_ReflectionFunctionAbstract::s_instanceof_table,c_ReflectionFunctionAbstract::s_instanceof_index,
2085   &c_ReflectionFunctionAbstract::s_class_name,
2086   &c_ReflectionFunctionAbstract::os_prop_table,0,0,0
2087 };
2088 /* SRC: classes/reflection.php line 261 */
2089 Variant c_ReflectionFunctionAbstract::t_getname() {
2090   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionFunctionAbstract, ReflectionFunctionAbstract::getName);
2091   return m_info.rvalAt(NAMSTR(s_sys_ssdc3cbddc, "name"), AccessFlags::Error_Key);
2092 }
2093 namespace hphp_impl_splitter {}
2094 /* SRC: classes/reflection.php line 276 */
2095 Variant c_ReflectionFunctionAbstract::t_isinternal() {
2096   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionFunctionAbstract, ReflectionFunctionAbstract::isInternal);
2097   return m_info.rvalAt(NAMSTR(s_sys_ss9332a8ac, "internal"), AccessFlags::Error_Key);
2098 }
2099 namespace hphp_impl_splitter {}
2100 /* SRC: classes/reflection.php line 280 */
2101 Variant c_ReflectionFunctionAbstract::t_getclosure() {
2102   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionFunctionAbstract, ReflectionFunctionAbstract::getClosure);
2103   return m_info.rvalAt(NAMSTR(s_sys_ss4cd61020, "closure"), AccessFlags::Error_Key);
2104 }
2105 namespace hphp_impl_splitter {}
2106 /* SRC: classes/reflection.php line 295 */
2107 bool c_ReflectionFunctionAbstract::t_isuserdefined() {
2108   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionFunctionAbstract, ReflectionFunctionAbstract::isUserDefined);
2109   {
2110     bool tmp0((toBoolean(m_info.rvalAt(NAMSTR(s_sys_ss9332a8ac, "internal"), AccessFlags::Error_Key))));
2111     return !(tmp0);
2112   }
2113 }
2114 namespace hphp_impl_splitter {}
2115 /* SRC: classes/reflection.php line 309 */
2116 Variant c_ReflectionFunctionAbstract::t_getfilename() {
2117   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionFunctionAbstract, ReflectionFunctionAbstract::getFileName);
2118   return m_info.rvalAt(NAMSTR(s_sys_ss8ce7db5b, "file"), AccessFlags::Error_Key);
2119 }
2120 namespace hphp_impl_splitter {}
2121 /* SRC: classes/reflection.php line 323 */
2122 Variant c_ReflectionFunctionAbstract::t_getstartline() {
2123   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionFunctionAbstract, ReflectionFunctionAbstract::getStartLine);
2124   return m_info.rvalAt(NAMSTR(s_sys_ssd4c67725, "line1"), AccessFlags::Error_Key);
2125 }
2126 namespace hphp_impl_splitter {}
2127 /* SRC: classes/reflection.php line 338 */
2128 Variant c_ReflectionFunctionAbstract::t_getendline() {
2129   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionFunctionAbstract, ReflectionFunctionAbstract::getEndLine);
2130   return m_info.rvalAt(NAMSTR(s_sys_ssbefe32a8, "line2"), AccessFlags::Error_Key);
2131 }
2132 namespace hphp_impl_splitter {}
2133 /* SRC: classes/reflection.php line 352 */
2134 Variant c_ReflectionFunctionAbstract::t_getdoccomment() {
2135   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionFunctionAbstract, ReflectionFunctionAbstract::getDocComment);
2136   return m_info.rvalAt(NAMSTR(s_sys_ss9cfa17a6, "doc"), AccessFlags::Error_Key);
2137 }
2138 namespace hphp_impl_splitter {}
2139 /* SRC: classes/reflection.php line 367 */
2140 Variant c_ReflectionFunctionAbstract::t_getstaticvariables() {
2141   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionFunctionAbstract, ReflectionFunctionAbstract::getStaticVariables);
2142   return m_info.rvalAt(NAMSTR(s_sys_ss5be7a94a, "static_variables"), AccessFlags::Error_Key);
2143 }
2144 namespace hphp_impl_splitter {}
2145 /* SRC: classes/reflection.php line 382 */
2146 Variant c_ReflectionFunctionAbstract::t_returnsreference() {
2147   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionFunctionAbstract, ReflectionFunctionAbstract::returnsReference);
2148   return m_info.rvalAt(NAMSTR(s_sys_ss134fd5fa, "ref"), AccessFlags::Error_Key);
2149 }
2150 namespace hphp_impl_splitter {}
2151 /* SRC: classes/reflection.php line 397 */
2152 Array c_ReflectionFunctionAbstract::t_getparameters() {
2153   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionFunctionAbstract, ReflectionFunctionAbstract::getParameters);
2154   Array v_ret;
2155   Primitive v_name = 0;
2156   Variant v_info;
2157   p_ReflectionParameter v_param;
2158
2159   v_ret = s_sys_sa00000000;
2160   {
2161     LOOP_COUNTER(1);
2162     Variant map2 = m_info.rvalAt(NAMSTR(s_sys_ss1f20ac62, "params"), AccessFlags::Error_Key);
2163     for (ArrayIter iter3 = map2.begin(s_class_name, true); !iter3.end(); iter3.next()) {
2164       LOOP_COUNTER_CHECK(1);
2165       iter3.second(v_info);
2166       v_name.assignVal(iter3.first());
2167       {
2168         {
2169           const p_ReflectionParameter &tmp0((p_ReflectionParameter(((c_ReflectionParameter*)coo_ReflectionParameter())->create(null, null))));
2170           v_param = tmp0;
2171         }
2172         v_param->m_info.assignVal(v_info);
2173         v_ret.append((VarNR(v_param)));
2174       }
2175     }
2176   }
2177   return v_ret;
2178 }
2179 namespace hphp_impl_splitter {}
2180 /* SRC: classes/reflection.php line 419 */
2181 int c_ReflectionFunctionAbstract::t_getnumberofparameters() {
2182   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionFunctionAbstract, ReflectionFunctionAbstract::getNumberOfParameters);
2183   {
2184     const Variant &tmp0((m_info.rvalAt(NAMSTR(s_sys_ss1f20ac62, "params"), AccessFlags::Error_Key)));
2185     return x_count(tmp0);
2186   }
2187 }
2188 namespace hphp_impl_splitter {}
2189 /* SRC: classes/reflection.php line 435 */
2190 int64 c_ReflectionFunctionAbstract::t_getnumberofrequiredparameters() {
2191   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionFunctionAbstract, ReflectionFunctionAbstract::getNumberOfRequiredParameters);
2192   int64 v_count = 0;
2193   Array v_params;
2194   Primitive v_name = 0;
2195   Variant v_param;
2196
2197   v_count = 0LL;
2198   {
2199     const Array &tmp0((t_getparameters()));
2200     v_params = tmp0;
2201   }
2202   {
2203     LOOP_COUNTER(1);
2204     for (ArrayIter iter3 = v_params.begin(s_class_name, true); !iter3.end(); ++iter3) {
2205       LOOP_COUNTER_CHECK(1);
2206       iter3.second(v_param);
2207       v_name.assignVal(iter3.first());
2208       {
2209         {
2210           bool tmp0;
2211           {
2212             MethodCallPackage mcp1;
2213             CVarRef obj1 = v_param;
2214             mcp1.methodCall((obj1), NAMSTR(s_sys_ss6d9ef7e5, "isOptional"), 0x2D6EF48BBAB22735LL);
2215             const CallInfo *cit1 ATTRIBUTE_UNUSED = mcp1.ci;
2216             tmp0 = (toBoolean((mcp1.bindClass(fi)->getMeth0Args())(mcp1, 0)));
2217           }
2218           if (tmp0) {
2219             {
2220               break;
2221             }
2222           }
2223         }
2224         v_count++;
2225       }
2226     }
2227   }
2228   return v_count;
2229 }
2230 namespace hphp_impl_splitter {}
2231 /* SRC: classes/reflection.php line 27 */
2232 IMPLEMENT_CLASS_NO_DEFAULT_SWEEP(ReflectionException)
2233 const InstanceOfInfo c_ReflectionException::s_instanceof_table[] = {
2234   {0x672AD818DDE95538LL,0,"ReflectionException",&cw_ReflectionException},
2235   {0x47D93E6F80B66A94LL,1,"Exception",&cw_Exception},
2236 };
2237 const int c_ReflectionException::s_instanceof_index[] = {
2238   3,
2239   0,-1,-1,-1,
2240 };
2241 const ObjectStaticCallbacks cw_ReflectionException = {
2242   (ObjectData*(*)(ObjectData*))coo_ReflectionException,
2243   c_ReflectionException::s_call_info_table,c_ReflectionException::s_call_info_index,
2244   c_ReflectionException::s_instanceof_table,c_ReflectionException::s_instanceof_index,
2245   &c_ReflectionException::s_class_name,
2246   &c_Exception::os_prop_table,&c_Exception::ci___construct,0,&cw_Exception
2247 };
2248 /* SRC: classes/reflection.php line 1317 */
2249 IMPLEMENT_CLASS_NO_DEFAULT_SWEEP(ReflectionObject)
2250 const InstanceOfInfo c_ReflectionObject::s_instanceof_table[] = {
2251   {0x41A9F7D81254DD7ALL,1,"ReflectionObject",&cw_ReflectionObject},
2252   {0x35A44A5E6AE2E71DLL,0,"ReflectionClass",&cw_ReflectionClass},
2253   {0x62F7F85447C0A605LL,1,"Reflector",(const ObjectStaticCallbacks*)2},
2254 };
2255 const int c_ReflectionObject::s_instanceof_index[] = {
2256   7,
2257   -1,-1,0,-1,-1,1,-1,-1,
2258
2259 };
2260 CallInfo c_ReflectionObject::ci_export((void*)&c_ReflectionObject::i_export, (void*)&c_ReflectionObject::ifa_export, 2, 12, 0x0000000000000000LL);
2261 Variant c_ReflectionObject::i_export(MethodCallPackage &mcp, CArrRef params) {
2262   return invoke_meth_few_handler(mcp, params, &ifa_export);
2263 }
2264 Variant c_ReflectionObject::ifa_export(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2265   if (UNLIKELY(count != 2)) return throw_wrong_arguments("ReflectionObject::export", count, 2, 2, 1);
2266   CVarRef arg0(a0);
2267   CVarRef arg1(a1);
2268   return (c_ReflectionObject::t_export(arg0, arg1));
2269 }
2270 const MethodCallInfoTable c_ReflectionObject::s_call_info_table[] = {
2271   { 0x0B5ABC58C98E70E8LL, 1, 6, "export", &c_ReflectionObject::ci_export },
2272   { 0, 1, 0, 0 }
2273 };
2274 const int c_ReflectionObject::s_call_info_index[] = {
2275   1,
2276   0,-1,
2277 };
2278 const ObjectStaticCallbacks cw_ReflectionObject = {
2279   (ObjectData*(*)(ObjectData*))coo_ReflectionObject,
2280   c_ReflectionObject::s_call_info_table,c_ReflectionObject::s_call_info_index,
2281   c_ReflectionObject::s_instanceof_table,c_ReflectionObject::s_instanceof_index,
2282   &c_ReflectionObject::s_class_name,
2283   &c_ReflectionClass::os_prop_table,&c_ReflectionClass::ci___construct,0,&cw_ReflectionClass
2284 };
2285 /* SRC: classes/reflection.php line 1334 */
2286 Variant c_ReflectionObject::t_export(Variant v_obj, CVarRef v_ret) {
2287   STATIC_METHOD_INJECTION_BUILTIN(ReflectionObject, ReflectionObject::export);
2288   String v_str;
2289
2290   {
2291     p_ReflectionObject tmp0 = coo_ReflectionObject();
2292     ((c_ReflectionObject*)tmp0.get()->create(v_obj));
2293     v_obj = tmp0;
2294   }
2295   v_str = (toString(v_obj));
2296   if (toBoolean(v_ret)) {
2297     {
2298       return v_str;
2299     }
2300   }
2301   print(v_str);
2302   return null;
2303 }
2304 namespace hphp_impl_splitter {}
2305 /* SRC: classes/reflection.php line 538 */
2306 const int64 q_ReflectionClass$$IS_IMPLICIT_ABSTRACT = 16LL;
2307 const int64 q_ReflectionClass$$IS_EXPLICIT_ABSTRACT = 32LL;
2308 const int64 q_ReflectionClass$$IS_FINAL = 64LL;
2309 IMPLEMENT_CLASS_NO_DEFAULT_SWEEP(ReflectionClass)
2310 const InstanceOfInfo c_ReflectionClass::s_instanceof_table[] = {
2311   {0x35A44A5E6AE2E71DLL,0,"ReflectionClass",&cw_ReflectionClass},
2312   {0x62F7F85447C0A605LL,1,"Reflector",(const ObjectStaticCallbacks*)2},
2313 };
2314 const int c_ReflectionClass::s_instanceof_index[] = {
2315   3,
2316   -1,0,-1,-1,
2317 };
2318 CallInfo c_ReflectionClass::ci_getdefaultproperties((void*)&c_ReflectionClass::i_getdefaultproperties, (void*)&c_ReflectionClass::ifa_getdefaultproperties, 0, 4, 0x0000000000000000LL);
2319 CallInfo c_ReflectionClass::ci_getstaticpropertyvalue((void*)&c_ReflectionClass::i_getstaticpropertyvalue, (void*)&c_ReflectionClass::ifa_getstaticpropertyvalue, 2, 4, 0x0000000000000000LL);
2320 CallInfo c_ReflectionClass::ci_isabstract((void*)&c_ReflectionClass::i_isabstract, (void*)&c_ReflectionClass::ifa_isabstract, 0, 4, 0x0000000000000000LL);
2321 CallInfo c_ReflectionClass::ci_gettraitaliases((void*)&c_ReflectionClass::i_gettraitaliases, (void*)&c_ReflectionClass::ifa_gettraitaliases, 0, 4, 0x0000000000000000LL);
2322 CallInfo c_ReflectionClass::ci_fetch((void*)&c_ReflectionClass::i_fetch, (void*)&c_ReflectionClass::ifa_fetch, 1, 132, 0x0000000000000000LL);
2323 CallInfo c_ReflectionClass::ci_gettraitnames((void*)&c_ReflectionClass::i_gettraitnames, (void*)&c_ReflectionClass::ifa_gettraitnames, 0, 4, 0x0000000000000000LL);
2324 CallInfo c_ReflectionClass::ci_getinterfacenames((void*)&c_ReflectionClass::i_getinterfacenames, (void*)&c_ReflectionClass::ifa_getinterfacenames, 0, 4, 0x0000000000000000LL);
2325 CallInfo c_ReflectionClass::ci_isuserdefined((void*)&c_ReflectionClass::i_isuserdefined, (void*)&c_ReflectionClass::ifa_isuserdefined, 0, 4, 0x0000000000000000LL);
2326 CallInfo c_ReflectionClass::ci_getstartline((void*)&c_ReflectionClass::i_getstartline, (void*)&c_ReflectionClass::ifa_getstartline, 0, 4, 0x0000000000000000LL);
2327 CallInfo c_ReflectionClass::ci_getproperty((void*)&c_ReflectionClass::i_getproperty, (void*)&c_ReflectionClass::ifa_getproperty, 1, 4, 0x0000000000000000LL);
2328 CallInfo c_ReflectionClass::ci_getextensionname((void*)&c_ReflectionClass::i_getextensionname, (void*)&c_ReflectionClass::ifa_getextensionname, 0, 4, 0x0000000000000000LL);
2329 CallInfo c_ReflectionClass::ci_test((void*)&c_ReflectionClass::i_test, (void*)&c_ReflectionClass::ifa_test, 2, 132, 0x0000000000000000LL);
2330 CallInfo c_ReflectionClass::ci_gettraits((void*)&c_ReflectionClass::i_gettraits, (void*)&c_ReflectionClass::ifa_gettraits, 0, 4, 0x0000000000000000LL);
2331 CallInfo c_ReflectionClass::ci_getmethods((void*)&c_ReflectionClass::i_getmethods, (void*)&c_ReflectionClass::ifa_getmethods, 1, 4, 0x0000000000000000LL);
2332 CallInfo c_ReflectionClass::ci_getconstants((void*)&c_ReflectionClass::i_getconstants, (void*)&c_ReflectionClass::ifa_getconstants, 0, 4, 0x0000000000000000LL);
2333 CallInfo c_ReflectionClass::ci_isfinal((void*)&c_ReflectionClass::i_isfinal, (void*)&c_ReflectionClass::ifa_isfinal, 0, 4, 0x0000000000000000LL);
2334 CallInfo c_ReflectionClass::ci_getname((void*)&c_ReflectionClass::i_getname, (void*)&c_ReflectionClass::ifa_getname, 0, 4, 0x0000000000000000LL);
2335 CallInfo c_ReflectionClass::ci_getmethod((void*)&c_ReflectionClass::i_getmethod, (void*)&c_ReflectionClass::ifa_getmethod, 1, 4, 0x0000000000000000LL);
2336 CallInfo c_ReflectionClass::ci_getinterfaces((void*)&c_ReflectionClass::i_getinterfaces, (void*)&c_ReflectionClass::ifa_getinterfaces, 0, 4, 0x0000000000000000LL);
2337 CallInfo c_ReflectionClass::ci_getdoccomment((void*)&c_ReflectionClass::i_getdoccomment, (void*)&c_ReflectionClass::ifa_getdoccomment, 0, 4, 0x0000000000000000LL);
2338 CallInfo c_ReflectionClass::ci_isiterateable((void*)&c_ReflectionClass::i_isiterateable, (void*)&c_ReflectionClass::ifa_isiterateable, 0, 4, 0x0000000000000000LL);
2339 CallInfo c_ReflectionClass::ci_newinstanceargs((void*)&c_ReflectionClass::i_newinstanceargs, (void*)&c_ReflectionClass::ifa_newinstanceargs, 1, 4, 0x0000000000000000LL);
2340 CallInfo c_ReflectionClass::ci_isinternal((void*)&c_ReflectionClass::i_isinternal, (void*)&c_ReflectionClass::ifa_isinternal, 0, 4, 0x0000000000000000LL);
2341 CallInfo c_ReflectionClass::ci_export((void*)&c_ReflectionClass::i_export, (void*)&c_ReflectionClass::ifa_export, 2, 12, 0x0000000000000000LL);
2342 CallInfo c_ReflectionClass::ci_isinstantiable((void*)&c_ReflectionClass::i_isinstantiable, (void*)&c_ReflectionClass::ifa_isinstantiable, 0, 4, 0x0000000000000000LL);
2343 CallInfo c_ReflectionClass::ci_hasmethod((void*)&c_ReflectionClass::i_hasmethod, (void*)&c_ReflectionClass::ifa_hasmethod, 1, 4, 0x0000000000000000LL);
2344 CallInfo c_ReflectionClass::ci_hasproperty((void*)&c_ReflectionClass::i_hasproperty, (void*)&c_ReflectionClass::ifa_hasproperty, 1, 4, 0x0000000000000000LL);
2345 CallInfo c_ReflectionClass::ci_isinterface((void*)&c_ReflectionClass::i_isinterface, (void*)&c_ReflectionClass::ifa_isinterface, 0, 4, 0x0000000000000000LL);
2346 CallInfo c_ReflectionClass::ci_getconstant((void*)&c_ReflectionClass::i_getconstant, (void*)&c_ReflectionClass::ifa_getconstant, 1, 4, 0x0000000000000000LL);
2347 CallInfo c_ReflectionClass::ci_getextension((void*)&c_ReflectionClass::i_getextension, (void*)&c_ReflectionClass::ifa_getextension, 0, 4, 0x0000000000000000LL);
2348 CallInfo c_ReflectionClass::ci___tostring((void*)&c_ReflectionClass::i___tostring, (void*)&c_ReflectionClass::ifa___tostring, 0, 4, 0x0000000000000000LL);
2349 CallInfo c_ReflectionClass::ci_setstaticpropertyvalue((void*)&c_ReflectionClass::i_setstaticpropertyvalue, (void*)&c_ReflectionClass::ifa_setstaticpropertyvalue, 2, 4, 0x0000000000000000LL);
2350 CallInfo c_ReflectionClass::ci_newinstance((void*)&c_ReflectionClass::i_newinstance, (void*)&c_ReflectionClass::ifa_newinstance, 0, 5, 0x0000000000000000LL);
2351 CallInfo c_ReflectionClass::ci_istrait((void*)&c_ReflectionClass::i_istrait, (void*)&c_ReflectionClass::ifa_istrait, 0, 4, 0x0000000000000000LL);
2352 CallInfo c_ReflectionClass::ci_getfilename((void*)&c_ReflectionClass::i_getfilename, (void*)&c_ReflectionClass::ifa_getfilename, 0, 4, 0x0000000000000000LL);
2353 CallInfo c_ReflectionClass::ci_getproperties((void*)&c_ReflectionClass::i_getproperties, (void*)&c_ReflectionClass::ifa_getproperties, 1, 4, 0x0000000000000000LL);
2354 CallInfo c_ReflectionClass::ci_implementsinterface((void*)&c_ReflectionClass::i_implementsinterface, (void*)&c_ReflectionClass::ifa_implementsinterface, 1, 4, 0x0000000000000000LL);
2355 CallInfo c_ReflectionClass::ci_isinstance((void*)&c_ReflectionClass::i_isinstance, (void*)&c_ReflectionClass::ifa_isinstance, 1, 4, 0x0000000000000000LL);
2356 CallInfo c_ReflectionClass::ci_getmodifiers((void*)&c_ReflectionClass::i_getmodifiers, (void*)&c_ReflectionClass::ifa_getmodifiers, 0, 4, 0x0000000000000000LL);
2357 CallInfo c_ReflectionClass::ci_getparentclass((void*)&c_ReflectionClass::i_getparentclass, (void*)&c_ReflectionClass::ifa_getparentclass, 0, 4, 0x0000000000000000LL);
2358 CallInfo c_ReflectionClass::ci_getconstructor((void*)&c_ReflectionClass::i_getconstructor, (void*)&c_ReflectionClass::ifa_getconstructor, 0, 4, 0x0000000000000000LL);
2359 CallInfo c_ReflectionClass::ci_getendline((void*)&c_ReflectionClass::i_getendline, (void*)&c_ReflectionClass::ifa_getendline, 0, 4, 0x0000000000000000LL);
2360 CallInfo c_ReflectionClass::ci_hasconstant((void*)&c_ReflectionClass::i_hasconstant, (void*)&c_ReflectionClass::ifa_hasconstant, 1, 4, 0x0000000000000000LL);
2361 CallInfo c_ReflectionClass::ci_issubclassof((void*)&c_ReflectionClass::i_issubclassof, (void*)&c_ReflectionClass::ifa_issubclassof, 1, 4, 0x0000000000000000LL);
2362 CallInfo c_ReflectionClass::ci___construct((void*)&c_ReflectionClass::i___construct, (void*)&c_ReflectionClass::ifa___construct, 1, 4, 0x0000000000000000LL);
2363 CallInfo c_ReflectionClass::ci_getstaticproperties((void*)&c_ReflectionClass::i_getstaticproperties, (void*)&c_ReflectionClass::ifa_getstaticproperties, 0, 4, 0x0000000000000000LL);
2364 Variant c_ReflectionClass::i___construct(MethodCallPackage &mcp, CArrRef params) {
2365   return invoke_meth_few_handler(mcp, params, &ifa___construct);
2366 }
2367 Variant c_ReflectionClass::i_fetch(MethodCallPackage &mcp, CArrRef params) {
2368   return invoke_meth_few_handler(mcp, params, &ifa_fetch);
2369 }
2370 Variant c_ReflectionClass::i_test(MethodCallPackage &mcp, CArrRef params) {
2371   return invoke_meth_few_handler(mcp, params, &ifa_test);
2372 }
2373 Variant c_ReflectionClass::i___tostring(MethodCallPackage &mcp, CArrRef params) {
2374   return invoke_meth_few_handler(mcp, params, &ifa___tostring);
2375 }
2376 Variant c_ReflectionClass::i_export(MethodCallPackage &mcp, CArrRef params) {
2377   return invoke_meth_few_handler(mcp, params, &ifa_export);
2378 }
2379 Variant c_ReflectionClass::i_getname(MethodCallPackage &mcp, CArrRef params) {
2380   return invoke_meth_few_handler(mcp, params, &ifa_getname);
2381 }
2382 Variant c_ReflectionClass::i_isinternal(MethodCallPackage &mcp, CArrRef params) {
2383   return invoke_meth_few_handler(mcp, params, &ifa_isinternal);
2384 }
2385 Variant c_ReflectionClass::i_isuserdefined(MethodCallPackage &mcp, CArrRef params) {
2386   return invoke_meth_few_handler(mcp, params, &ifa_isuserdefined);
2387 }
2388 Variant c_ReflectionClass::i_isinstantiable(MethodCallPackage &mcp, CArrRef params) {
2389   return invoke_meth_few_handler(mcp, params, &ifa_isinstantiable);
2390 }
2391 Variant c_ReflectionClass::i_hasconstant(MethodCallPackage &mcp, CArrRef params) {
2392   return invoke_meth_few_handler(mcp, params, &ifa_hasconstant);
2393 }
2394 Variant c_ReflectionClass::i_hasmethod(MethodCallPackage &mcp, CArrRef params) {
2395   return invoke_meth_few_handler(mcp, params, &ifa_hasmethod);
2396 }
2397 Variant c_ReflectionClass::i_hasproperty(MethodCallPackage &mcp, CArrRef params) {
2398   return invoke_meth_few_handler(mcp, params, &ifa_hasproperty);
2399 }
2400 Variant c_ReflectionClass::i_getfilename(MethodCallPackage &mcp, CArrRef params) {
2401   return invoke_meth_few_handler(mcp, params, &ifa_getfilename);
2402 }
2403 Variant c_ReflectionClass::i_getstartline(MethodCallPackage &mcp, CArrRef params) {
2404   return invoke_meth_few_handler(mcp, params, &ifa_getstartline);
2405 }
2406 Variant c_ReflectionClass::i_getendline(MethodCallPackage &mcp, CArrRef params) {
2407   return invoke_meth_few_handler(mcp, params, &ifa_getendline);
2408 }
2409 Variant c_ReflectionClass::i_getdoccomment(MethodCallPackage &mcp, CArrRef params) {
2410   return invoke_meth_few_handler(mcp, params, &ifa_getdoccomment);
2411 }
2412 Variant c_ReflectionClass::i_getconstructor(MethodCallPackage &mcp, CArrRef params) {
2413   return invoke_meth_few_handler(mcp, params, &ifa_getconstructor);
2414 }
2415 Variant c_ReflectionClass::i_getmethod(MethodCallPackage &mcp, CArrRef params) {
2416   return invoke_meth_few_handler(mcp, params, &ifa_getmethod);
2417 }
2418 Variant c_ReflectionClass::i_getmethods(MethodCallPackage &mcp, CArrRef params) {
2419   return invoke_meth_few_handler(mcp, params, &ifa_getmethods);
2420 }
2421 Variant c_ReflectionClass::i_getproperty(MethodCallPackage &mcp, CArrRef params) {
2422   return invoke_meth_few_handler(mcp, params, &ifa_getproperty);
2423 }
2424 Variant c_ReflectionClass::i_getproperties(MethodCallPackage &mcp, CArrRef params) {
2425   return invoke_meth_few_handler(mcp, params, &ifa_getproperties);
2426 }
2427 Variant c_ReflectionClass::i_getconstants(MethodCallPackage &mcp, CArrRef params) {
2428   return invoke_meth_few_handler(mcp, params, &ifa_getconstants);
2429 }
2430 Variant c_ReflectionClass::i_getconstant(MethodCallPackage &mcp, CArrRef params) {
2431   return invoke_meth_few_handler(mcp, params, &ifa_getconstant);
2432 }
2433 Variant c_ReflectionClass::i_getinterfaces(MethodCallPackage &mcp, CArrRef params) {
2434   return invoke_meth_few_handler(mcp, params, &ifa_getinterfaces);
2435 }
2436 Variant c_ReflectionClass::i_gettraits(MethodCallPackage &mcp, CArrRef params) {
2437   return invoke_meth_few_handler(mcp, params, &ifa_gettraits);
2438 }
2439 Variant c_ReflectionClass::i_getinterfacenames(MethodCallPackage &mcp, CArrRef params) {
2440   return invoke_meth_few_handler(mcp, params, &ifa_getinterfacenames);
2441 }
2442 Variant c_ReflectionClass::i_gettraitnames(MethodCallPackage &mcp, CArrRef params) {
2443   return invoke_meth_few_handler(mcp, params, &ifa_gettraitnames);
2444 }
2445 Variant c_ReflectionClass::i_gettraitaliases(MethodCallPackage &mcp, CArrRef params) {
2446   return invoke_meth_few_handler(mcp, params, &ifa_gettraitaliases);
2447 }
2448 Variant c_ReflectionClass::i_isinterface(MethodCallPackage &mcp, CArrRef params) {
2449   return invoke_meth_few_handler(mcp, params, &ifa_isinterface);
2450 }
2451 Variant c_ReflectionClass::i_isabstract(MethodCallPackage &mcp, CArrRef params) {
2452   return invoke_meth_few_handler(mcp, params, &ifa_isabstract);
2453 }
2454 Variant c_ReflectionClass::i_isfinal(MethodCallPackage &mcp, CArrRef params) {
2455   return invoke_meth_few_handler(mcp, params, &ifa_isfinal);
2456 }
2457 Variant c_ReflectionClass::i_istrait(MethodCallPackage &mcp, CArrRef params) {
2458   return invoke_meth_few_handler(mcp, params, &ifa_istrait);
2459 }
2460 Variant c_ReflectionClass::i_getmodifiers(MethodCallPackage &mcp, CArrRef params) {
2461   return invoke_meth_few_handler(mcp, params, &ifa_getmodifiers);
2462 }
2463 Variant c_ReflectionClass::i_isinstance(MethodCallPackage &mcp, CArrRef params) {
2464   return invoke_meth_few_handler(mcp, params, &ifa_isinstance);
2465 }
2466 Variant c_ReflectionClass::i_newinstance(MethodCallPackage &mcp, CArrRef params) {
2467   if (UNLIKELY(mcp.obj == 0)) {
2468     return ObjectData::i_dummy(mcp, params, i_newinstance, coo_ReflectionClass);
2469   }
2470   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2471   int count ATTRIBUTE_UNUSED = params.size();
2472   const Array &p(count > 0 ? ArrayUtil::EnsureIntKeys(params) : Array());
2473   return (self->t_newinstance(count, p));
2474 }
2475 Variant c_ReflectionClass::i_newinstanceargs(MethodCallPackage &mcp, CArrRef params) {
2476   return invoke_meth_few_handler(mcp, params, &ifa_newinstanceargs);
2477 }
2478 Variant c_ReflectionClass::i_getparentclass(MethodCallPackage &mcp, CArrRef params) {
2479   return invoke_meth_few_handler(mcp, params, &ifa_getparentclass);
2480 }
2481 Variant c_ReflectionClass::i_issubclassof(MethodCallPackage &mcp, CArrRef params) {
2482   return invoke_meth_few_handler(mcp, params, &ifa_issubclassof);
2483 }
2484 Variant c_ReflectionClass::i_getstaticproperties(MethodCallPackage &mcp, CArrRef params) {
2485   return invoke_meth_few_handler(mcp, params, &ifa_getstaticproperties);
2486 }
2487 Variant c_ReflectionClass::i_getstaticpropertyvalue(MethodCallPackage &mcp, CArrRef params) {
2488   return invoke_meth_few_handler(mcp, params, &ifa_getstaticpropertyvalue);
2489 }
2490 Variant c_ReflectionClass::i_setstaticpropertyvalue(MethodCallPackage &mcp, CArrRef params) {
2491   return invoke_meth_few_handler(mcp, params, &ifa_setstaticpropertyvalue);
2492 }
2493 Variant c_ReflectionClass::i_getdefaultproperties(MethodCallPackage &mcp, CArrRef params) {
2494   return invoke_meth_few_handler(mcp, params, &ifa_getdefaultproperties);
2495 }
2496 Variant c_ReflectionClass::i_isiterateable(MethodCallPackage &mcp, CArrRef params) {
2497   return invoke_meth_few_handler(mcp, params, &ifa_isiterateable);
2498 }
2499 Variant c_ReflectionClass::i_implementsinterface(MethodCallPackage &mcp, CArrRef params) {
2500   return invoke_meth_few_handler(mcp, params, &ifa_implementsinterface);
2501 }
2502 Variant c_ReflectionClass::i_getextension(MethodCallPackage &mcp, CArrRef params) {
2503   return invoke_meth_few_handler(mcp, params, &ifa_getextension);
2504 }
2505 Variant c_ReflectionClass::i_getextensionname(MethodCallPackage &mcp, CArrRef params) {
2506   return invoke_meth_few_handler(mcp, params, &ifa_getextensionname);
2507 }
2508 Variant c_ReflectionClass::ifa___construct(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2509   if (UNLIKELY(mcp.obj == 0)) {
2510     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa___construct, coo_ReflectionClass);
2511   }
2512   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2513   if (UNLIKELY(count != 1)) return throw_wrong_arguments("ReflectionClass::__construct", count, 1, 1, 2);
2514   CVarRef arg0(a0);
2515   return (self->t___construct(arg0), null);
2516 }
2517 Variant c_ReflectionClass::ifa_fetch(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2518   if (UNLIKELY(mcp.obj == 0)) {
2519     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_fetch, coo_ReflectionClass);
2520   }
2521   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2522   if (UNLIKELY(count != 1)) return throw_wrong_arguments("ReflectionClass::fetch", count, 1, 1, 1);
2523   CVarRef arg0(a0);
2524   return (self->t_fetch(arg0));
2525 }
2526 Variant c_ReflectionClass::ifa_test(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2527   if (UNLIKELY(mcp.obj == 0)) {
2528     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_test, coo_ReflectionClass);
2529   }
2530   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2531   if (UNLIKELY(count != 2)) return throw_wrong_arguments("ReflectionClass::test", count, 2, 2, 1);
2532   CVarRef arg0(a0);
2533   CVarRef arg1(a1);
2534   return (self->t_test(arg0, arg1));
2535 }
2536 Variant c_ReflectionClass::ifa___tostring(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2537   if (UNLIKELY(mcp.obj == 0)) {
2538     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa___tostring, coo_ReflectionClass);
2539   }
2540   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2541   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::__toString", 0, 1);
2542   return (self->t___tostring());
2543 }
2544 Variant c_ReflectionClass::ifa_export(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2545   if (UNLIKELY(count != 2)) return throw_wrong_arguments("ReflectionClass::export", count, 2, 2, 1);
2546   CVarRef arg0(a0);
2547   CVarRef arg1(a1);
2548   return (c_ReflectionClass::t_export(arg0, arg1));
2549 }
2550 Variant c_ReflectionClass::ifa_getname(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2551   if (UNLIKELY(mcp.obj == 0)) {
2552     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getname, coo_ReflectionClass);
2553   }
2554   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2555   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getName", 0, 1);
2556   return (self->t_getname());
2557 }
2558 Variant c_ReflectionClass::ifa_isinternal(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2559   if (UNLIKELY(mcp.obj == 0)) {
2560     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isinternal, coo_ReflectionClass);
2561   }
2562   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2563   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::isInternal", 0, 1);
2564   return (self->t_isinternal());
2565 }
2566 Variant c_ReflectionClass::ifa_isuserdefined(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2567   if (UNLIKELY(mcp.obj == 0)) {
2568     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isuserdefined, coo_ReflectionClass);
2569   }
2570   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2571   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::isUserDefined", 0, 1);
2572   return (self->t_isuserdefined());
2573 }
2574 Variant c_ReflectionClass::ifa_isinstantiable(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2575   if (UNLIKELY(mcp.obj == 0)) {
2576     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isinstantiable, coo_ReflectionClass);
2577   }
2578   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2579   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::isInstantiable", 0, 1);
2580   return (self->t_isinstantiable());
2581 }
2582 Variant c_ReflectionClass::ifa_hasconstant(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2583   if (UNLIKELY(mcp.obj == 0)) {
2584     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_hasconstant, coo_ReflectionClass);
2585   }
2586   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2587   if (UNLIKELY(count != 1)) return throw_wrong_arguments("ReflectionClass::hasConstant", count, 1, 1, 1);
2588   CVarRef arg0(a0);
2589   return (self->t_hasconstant(arg0));
2590 }
2591 Variant c_ReflectionClass::ifa_hasmethod(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2592   if (UNLIKELY(mcp.obj == 0)) {
2593     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_hasmethod, coo_ReflectionClass);
2594   }
2595   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2596   if (UNLIKELY(count != 1)) return throw_wrong_arguments("ReflectionClass::hasMethod", count, 1, 1, 1);
2597   CVarRef arg0(a0);
2598   return (self->t_hasmethod(arg0));
2599 }
2600 Variant c_ReflectionClass::ifa_hasproperty(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2601   if (UNLIKELY(mcp.obj == 0)) {
2602     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_hasproperty, coo_ReflectionClass);
2603   }
2604   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2605   if (UNLIKELY(count != 1)) return throw_wrong_arguments("ReflectionClass::hasProperty", count, 1, 1, 1);
2606   CVarRef arg0(a0);
2607   return (self->t_hasproperty(arg0));
2608 }
2609 Variant c_ReflectionClass::ifa_getfilename(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2610   if (UNLIKELY(mcp.obj == 0)) {
2611     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getfilename, coo_ReflectionClass);
2612   }
2613   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2614   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getFileName", 0, 1);
2615   return (self->t_getfilename());
2616 }
2617 Variant c_ReflectionClass::ifa_getstartline(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2618   if (UNLIKELY(mcp.obj == 0)) {
2619     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getstartline, coo_ReflectionClass);
2620   }
2621   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2622   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getStartLine", 0, 1);
2623   return (self->t_getstartline());
2624 }
2625 Variant c_ReflectionClass::ifa_getendline(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2626   if (UNLIKELY(mcp.obj == 0)) {
2627     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getendline, coo_ReflectionClass);
2628   }
2629   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2630   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getEndLine", 0, 1);
2631   return (self->t_getendline());
2632 }
2633 Variant c_ReflectionClass::ifa_getdoccomment(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2634   if (UNLIKELY(mcp.obj == 0)) {
2635     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getdoccomment, coo_ReflectionClass);
2636   }
2637   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2638   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getDocComment", 0, 1);
2639   return (self->t_getdoccomment());
2640 }
2641 Variant c_ReflectionClass::ifa_getconstructor(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2642   if (UNLIKELY(mcp.obj == 0)) {
2643     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getconstructor, coo_ReflectionClass);
2644   }
2645   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2646   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getConstructor", 0, 1);
2647   return (self->t_getconstructor());
2648 }
2649 Variant c_ReflectionClass::ifa_getmethod(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2650   if (UNLIKELY(mcp.obj == 0)) {
2651     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getmethod, coo_ReflectionClass);
2652   }
2653   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2654   if (UNLIKELY(count != 1)) return throw_wrong_arguments("ReflectionClass::getMethod", count, 1, 1, 1);
2655   CVarRef arg0(a0);
2656   return (self->t_getmethod(arg0));
2657 }
2658 Variant c_ReflectionClass::ifa_getmethods(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2659   if (UNLIKELY(mcp.obj == 0)) {
2660     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getmethods, coo_ReflectionClass);
2661   }
2662   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2663   if (UNLIKELY(count > 1)) return throw_toomany_arguments("ReflectionClass::getMethods", 1, 1);
2664   if (count <= 0) return (self->t_getmethods());
2665   CVarRef arg0(a0);
2666   return (self->t_getmethods(arg0));
2667 }
2668 Variant c_ReflectionClass::ifa_getproperty(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2669   if (UNLIKELY(mcp.obj == 0)) {
2670     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getproperty, coo_ReflectionClass);
2671   }
2672   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2673   if (UNLIKELY(count != 1)) return throw_wrong_arguments("ReflectionClass::getProperty", count, 1, 1, 1);
2674   CVarRef arg0(a0);
2675   return (self->t_getproperty(arg0));
2676 }
2677 Variant c_ReflectionClass::ifa_getproperties(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2678   if (UNLIKELY(mcp.obj == 0)) {
2679     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getproperties, coo_ReflectionClass);
2680   }
2681   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2682   if (UNLIKELY(count > 1)) return throw_toomany_arguments("ReflectionClass::getProperties", 1, 1);
2683   if (count <= 0) return (self->t_getproperties());
2684   CVarRef arg0(a0);
2685   return (self->t_getproperties(arg0));
2686 }
2687 Variant c_ReflectionClass::ifa_getconstants(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2688   if (UNLIKELY(mcp.obj == 0)) {
2689     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getconstants, coo_ReflectionClass);
2690   }
2691   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2692   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getConstants", 0, 1);
2693   return (self->t_getconstants());
2694 }
2695 Variant c_ReflectionClass::ifa_getconstant(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2696   if (UNLIKELY(mcp.obj == 0)) {
2697     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getconstant, coo_ReflectionClass);
2698   }
2699   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2700   if (UNLIKELY(count != 1)) return throw_wrong_arguments("ReflectionClass::getConstant", count, 1, 1, 1);
2701   CVarRef arg0(a0);
2702   return (self->t_getconstant(arg0));
2703 }
2704 Variant c_ReflectionClass::ifa_getinterfaces(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2705   if (UNLIKELY(mcp.obj == 0)) {
2706     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getinterfaces, coo_ReflectionClass);
2707   }
2708   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2709   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getInterfaces", 0, 1);
2710   return (self->t_getinterfaces());
2711 }
2712 Variant c_ReflectionClass::ifa_gettraits(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2713   if (UNLIKELY(mcp.obj == 0)) {
2714     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_gettraits, coo_ReflectionClass);
2715   }
2716   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2717   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getTraits", 0, 1);
2718   return (self->t_gettraits());
2719 }
2720 Variant c_ReflectionClass::ifa_getinterfacenames(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2721   if (UNLIKELY(mcp.obj == 0)) {
2722     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getinterfacenames, coo_ReflectionClass);
2723   }
2724   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2725   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getInterfaceNames", 0, 1);
2726   return (self->t_getinterfacenames());
2727 }
2728 Variant c_ReflectionClass::ifa_gettraitnames(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2729   if (UNLIKELY(mcp.obj == 0)) {
2730     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_gettraitnames, coo_ReflectionClass);
2731   }
2732   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2733   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getTraitNames", 0, 1);
2734   return (self->t_gettraitnames());
2735 }
2736 Variant c_ReflectionClass::ifa_gettraitaliases(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2737   if (UNLIKELY(mcp.obj == 0)) {
2738     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_gettraitaliases, coo_ReflectionClass);
2739   }
2740   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2741   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getTraitAliases", 0, 1);
2742   return (self->t_gettraitaliases());
2743 }
2744 Variant c_ReflectionClass::ifa_isinterface(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2745   if (UNLIKELY(mcp.obj == 0)) {
2746     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isinterface, coo_ReflectionClass);
2747   }
2748   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2749   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::isInterface", 0, 1);
2750   return (self->t_isinterface());
2751 }
2752 Variant c_ReflectionClass::ifa_isabstract(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2753   if (UNLIKELY(mcp.obj == 0)) {
2754     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isabstract, coo_ReflectionClass);
2755   }
2756   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2757   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::isAbstract", 0, 1);
2758   return (self->t_isabstract());
2759 }
2760 Variant c_ReflectionClass::ifa_isfinal(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2761   if (UNLIKELY(mcp.obj == 0)) {
2762     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isfinal, coo_ReflectionClass);
2763   }
2764   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2765   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::isFinal", 0, 1);
2766   return (self->t_isfinal());
2767 }
2768 Variant c_ReflectionClass::ifa_istrait(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2769   if (UNLIKELY(mcp.obj == 0)) {
2770     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_istrait, coo_ReflectionClass);
2771   }
2772   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2773   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::isTrait", 0, 1);
2774   return (self->t_istrait());
2775 }
2776 Variant c_ReflectionClass::ifa_getmodifiers(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2777   if (UNLIKELY(mcp.obj == 0)) {
2778     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getmodifiers, coo_ReflectionClass);
2779   }
2780   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2781   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getModifiers", 0, 1);
2782   return (self->t_getmodifiers());
2783 }
2784 Variant c_ReflectionClass::ifa_isinstance(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2785   if (UNLIKELY(mcp.obj == 0)) {
2786     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isinstance, coo_ReflectionClass);
2787   }
2788   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2789   if (UNLIKELY(count != 1)) return throw_wrong_arguments("ReflectionClass::isInstance", count, 1, 1, 1);
2790   CVarRef arg0(a0);
2791   return (self->t_isinstance(arg0));
2792 }
2793 Variant c_ReflectionClass::ifa_newinstance(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2794   if (UNLIKELY(mcp.obj == 0)) {
2795     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_newinstance, coo_ReflectionClass);
2796   }
2797   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2798   Array p;
2799   if (count >= 1) p.append(a0);
2800   if (count >= 2) p.append(a1);
2801   if (count >= 3) p.append(a2);
2802   if (count >= 4) p.append(a3);
2803   if (count >= 5) p.append(a4);
2804   if (count >= 6) p.append(a5);
2805   return (self->t_newinstance(count, p));
2806 }
2807 Variant c_ReflectionClass::ifa_newinstanceargs(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2808   if (UNLIKELY(mcp.obj == 0)) {
2809     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_newinstanceargs, coo_ReflectionClass);
2810   }
2811   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2812   if (UNLIKELY(count != 1)) return throw_wrong_arguments("ReflectionClass::newInstanceArgs", count, 1, 1, 1);
2813   CVarRef arg0(a0);
2814   return (self->t_newinstanceargs(arg0));
2815 }
2816 Variant c_ReflectionClass::ifa_getparentclass(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2817   if (UNLIKELY(mcp.obj == 0)) {
2818     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getparentclass, coo_ReflectionClass);
2819   }
2820   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2821   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getParentClass", 0, 1);
2822   return (self->t_getparentclass());
2823 }
2824 Variant c_ReflectionClass::ifa_issubclassof(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2825   if (UNLIKELY(mcp.obj == 0)) {
2826     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_issubclassof, coo_ReflectionClass);
2827   }
2828   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2829   if (UNLIKELY(count != 1)) return throw_wrong_arguments("ReflectionClass::isSubclassOf", count, 1, 1, 1);
2830   CVarRef arg0(a0);
2831   return (self->t_issubclassof(arg0));
2832 }
2833 Variant c_ReflectionClass::ifa_getstaticproperties(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2834   if (UNLIKELY(mcp.obj == 0)) {
2835     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getstaticproperties, coo_ReflectionClass);
2836   }
2837   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2838   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getStaticProperties", 0, 1);
2839   return (self->t_getstaticproperties());
2840 }
2841 Variant c_ReflectionClass::ifa_getstaticpropertyvalue(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2842   if (UNLIKELY(mcp.obj == 0)) {
2843     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getstaticpropertyvalue, coo_ReflectionClass);
2844   }
2845   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2846   if (UNLIKELY(count < 1 || count > 2)) return throw_wrong_arguments("ReflectionClass::getStaticPropertyValue", count, 1, 2, 1);
2847   CVarRef arg0(a0);
2848   if (count <= 1) return (self->t_getstaticpropertyvalue(arg0));
2849   CVarRef arg1(a1);
2850   return (self->t_getstaticpropertyvalue(arg0, arg1));
2851 }
2852 Variant c_ReflectionClass::ifa_setstaticpropertyvalue(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2853   if (UNLIKELY(mcp.obj == 0)) {
2854     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_setstaticpropertyvalue, coo_ReflectionClass);
2855   }
2856   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2857   if (UNLIKELY(count != 2)) return throw_wrong_arguments("ReflectionClass::setStaticPropertyValue", count, 2, 2, 1);
2858   CVarRef arg0(a0);
2859   CVarRef arg1(a1);
2860   return (self->t_setstaticpropertyvalue(arg0, arg1), null);
2861 }
2862 Variant c_ReflectionClass::ifa_getdefaultproperties(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2863   if (UNLIKELY(mcp.obj == 0)) {
2864     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getdefaultproperties, coo_ReflectionClass);
2865   }
2866   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2867   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getDefaultProperties", 0, 1);
2868   return (self->t_getdefaultproperties());
2869 }
2870 Variant c_ReflectionClass::ifa_isiterateable(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2871   if (UNLIKELY(mcp.obj == 0)) {
2872     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_isiterateable, coo_ReflectionClass);
2873   }
2874   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2875   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::isIterateable", 0, 1);
2876   return (self->t_isiterateable());
2877 }
2878 Variant c_ReflectionClass::ifa_implementsinterface(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2879   if (UNLIKELY(mcp.obj == 0)) {
2880     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_implementsinterface, coo_ReflectionClass);
2881   }
2882   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2883   if (UNLIKELY(count != 1)) return throw_wrong_arguments("ReflectionClass::implementsInterface", count, 1, 1, 1);
2884   CVarRef arg0(a0);
2885   return (self->t_implementsinterface(arg0));
2886 }
2887 Variant c_ReflectionClass::ifa_getextension(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2888   if (UNLIKELY(mcp.obj == 0)) {
2889     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getextension, coo_ReflectionClass);
2890   }
2891   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2892   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getExtension", 0, 1);
2893   return (self->t_getextension());
2894 }
2895 Variant c_ReflectionClass::ifa_getextensionname(MethodCallPackage &mcp, int count, INVOKE_FEW_ARGS_IMPL_ARGS) {
2896   if (UNLIKELY(mcp.obj == 0)) {
2897     return ObjectData::ifa_dummy(mcp, count, INVOKE_FEW_ARGS_PASS_ARGS, ifa_getextensionname, coo_ReflectionClass);
2898   }
2899   c_ReflectionClass *self ATTRIBUTE_UNUSED (static_cast<c_ReflectionClass*>(mcp.obj));
2900   if (UNLIKELY(count > 0)) return throw_toomany_arguments("ReflectionClass::getExtensionName", 0, 1);
2901   return (self->t_getextensionname());
2902 }
2903 const MethodCallInfoTable c_ReflectionClass::s_call_info_table[] = {
2904   { 0x39C1BB731CB1CB04LL, 1, 12, "getStartLine", &c_ReflectionClass::ci_getstartline },
2905   { 0x4C40EED171E86607LL, 1, 9, "getTraits", &c_ReflectionClass::ci_gettraits },
2906   { 0x40C7B30DCB439C8FLL, 1, 11, "hasProperty", &c_ReflectionClass::ci_hasproperty },
2907   { 0x642C2D2994B34A13LL, 1, 10, "__toString", &c_ReflectionClass::ci___tostring },
2908   { 0x24253EBA491D6014LL, 1, 12, "getModifiers", &c_ReflectionClass::ci_getmodifiers },
2909   { 0x196F2AC52B12BF16LL, 1, 15, "getTraitAliases", &c_ReflectionClass::ci_gettraitaliases },
2910   { 0x21820E7AA4733998LL, 1, 9, "hasMethod", &c_ReflectionClass::ci_hasmethod },
2911   { 0x0F1AD0A8EC4C229BLL, 1, 20, "getDefaultProperties", &c_ReflectionClass::ci_getdefaultproperties },
2912   { 0x1BC5F3D87676509ELL, 1, 11, "isInterface", &c_ReflectionClass::ci_isinterface },
2913   { 0x323D9BCB05797B22LL, 1, 19, "getStaticProperties", &c_ReflectionClass::ci_getstaticproperties },
2914   { 0x779C6BB1877464A7LL, 1, 13, "getTraitNames", &c_ReflectionClass::ci_gettraitnames },
2915   { 0x030CE1D6142F8C29LL, 1, 10, "isInstance", &c_ReflectionClass::ci_isinstance },
2916   { 0x1D6B8CA358B49929LL, 0, 16, "getExtensionName", &c_ReflectionClass::ci_getextensionname },
2917   { 0x226F6E80CECD3CAALL, 1, 14, "getConstructor", &c_ReflectionClass::ci_getconstructor },
2918   { 0x16BA16CE6488AAAALL, 0, 10, "getMethods", &c_ReflectionClass::ci_getmethods },
2919   { 0x24596BE6D21F7CAALL, 0, 17, "getInterfaceNames", &c_ReflectionClass::ci_getinterfacenames },
2920   { 0x06FB6A7DC3D795AELL, 1, 7, "isFinal", &c_ReflectionClass::ci_isfinal },
2921   { 0x3C882D4A895F612ELL, 0, 22, "getStaticPropertyValue", &c_ReflectionClass::ci_getstaticpropertyvalue },
2922   { 0x30A86FCA01FE7030LL, 1, 11, "newInstance", &c_ReflectionClass::ci_newinstance },
2923   { 0x3DB53E1FBD3C0734LL, 1, 11, "getConstant", &c_ReflectionClass::ci_getconstant },
2924   { 0x0D81ECE253A3B5B6LL, 1, 9, "getMethod", &c_ReflectionClass::ci_getmethod },
2925   { 0x7460D945DA32FDB7LL, 1, 10, "isAbstract", &c_ReflectionClass::ci_isabstract },
2926   { 0x638089893524223BLL, 1, 7, "isTrait", &c_ReflectionClass::ci_istrait },
2927   { 0x25D24435915E6E3BLL, 0, 12, "getExtension", &c_ReflectionClass::ci_getextension },
2928   { 0x0D8AAD6BA2BBCD3CLL, 1, 14, "isInstantiable", &c_ReflectionClass::ci_isinstantiable },
2929   { 0x54C2DC04C4A62B3FLL, 1, 11, "hasConstant", &c_ReflectionClass::ci_hasconstant },
2930   { 0x67C15E3D98C00B43LL, 1, 13, "getInterfaces", &c_ReflectionClass::ci_getinterfaces },
2931   { 0x1EB679C3602F4B44LL, 1, 13, "getProperties", &c_ReflectionClass::ci_getproperties },
2932   { 0x0FD73627FB023047LL, 1, 11, "getProperty", &c_ReflectionClass::ci_getproperty },
2933   { 0x1930CE336D39474DLL, 1, 11, "getFileName", &c_ReflectionClass::ci_getfilename },
2934   { 0x7D5A57B5370B68CELL, 1, 13, "isIterateable", &c_ReflectionClass::ci_isiterateable },
2935   { 0x48FDF6C5835C64CFLL, 1, 10, "isInternal", &c_ReflectionClass::ci_isinternal },
2936   { 0x1CC71CB013143955LL, 1, 12, "getConstants", &c_ReflectionClass::ci_getconstants },
2937   { 0x0D31D0AC229C615FLL, 1, 11, "__construct", &c_ReflectionClass::ci___construct },
2938   { 0x6A6B8BECAE7D4164LL, 1, 13, "isUserDefined", &c_ReflectionClass::ci_isuserdefined },
2939   { 0x23F51CDECC198965LL, 1, 7, "getName", &c_ReflectionClass::ci_getname },
2940   { 0x2735DCC254EE5C66LL, 1, 15, "newInstanceArgs", &c_ReflectionClass::ci_newinstanceargs },
2941   { 0x37349B25A0ED29E7LL, 1, 4, "test", &c_ReflectionClass::ci_test },
2942   { 0x0B5ABC58C98E70E8LL, 1, 6, "export", &c_ReflectionClass::ci_export },
2943   { 0x6C19E85007BC4570LL, 1, 10, "getEndLine", &c_ReflectionClass::ci_getendline },
2944   { 0x07ECA928E37717F1LL, 1, 22, "setStaticPropertyValue", &c_ReflectionClass::ci_setstaticpropertyvalue },
2945   { 0x74F7FEDE16957472LL, 1, 14, "getParentClass", &c_ReflectionClass::ci_getparentclass },
2946   { 0x7C4F424FDA56ADF8LL, 1, 13, "getDocComment", &c_ReflectionClass::ci_getdoccomment },
2947   { 0x5E82B850BB90B0FBLL, 1, 5, "fetch", &c_ReflectionClass::ci_fetch },
2948   { 0x28DC702215C7D6FBLL, 0, 19, "implementsInterface", &c_ReflectionClass::ci_implementsinterface },
2949   { 0x373333991926C97ELL, 1, 12, "isSubclassOf", &c_ReflectionClass::ci_issubclassof },
2950   { 0, 1, 0, 0 }
2951 };
2952 const int c_ReflectionClass::s_call_info_index[] = {
2953   127,
2954   -1,-1,-1,-1,0,-1,-1,1,
2955   -1,-1,-1,-1,-1,-1,-1,2,
2956   -1,-1,-1,3,4,-1,5,-1,
2957   6,-1,-1,7,-1,-1,8,-1,
2958   -1,-1,9,-1,-1,-1,-1,10,
2959   -1,11,13,-1,-1,-1,16,-1,
2960   18,-1,-1,-1,19,-1,20,21,
2961   -1,-1,-1,22,24,-1,-1,25,
2962   -1,-1,-1,26,27,-1,-1,28,
2963   -1,-1,-1,-1,-1,29,30,31,
2964   -1,-1,-1,-1,-1,32,-1,-1,
2965   -1,-1,-1,-1,-1,-1,-1,33,
2966   -1,-1,-1,-1,34,35,36,37,
2967   38,-1,-1,-1,-1,-1,-1,-1,
2968   39,40,41,-1,-1,-1,-1,-1,
2969   42,-1,-1,43,-1,-1,45,-1,
2970
2971 };
2972 c_ReflectionClass *c_ReflectionClass::create(CVarRef v_name) {
2973   CountableHelper h(this);
2974   init();
2975   t___construct(v_name);
2976   return this;
2977 }
2978 const ObjectStaticCallbacks cw_ReflectionClass = {
2979   (ObjectData*(*)(ObjectData*))coo_ReflectionClass,
2980   c_ReflectionClass::s_call_info_table,c_ReflectionClass::s_call_info_index,
2981   c_ReflectionClass::s_instanceof_table,c_ReflectionClass::s_instanceof_index,
2982   &c_ReflectionClass::s_class_name,
2983   &c_ReflectionClass::os_prop_table,&c_ReflectionClass::ci___construct,0,0
2984 };
2985 /* SRC: classes/reflection.php line 546 */
2986 void c_ReflectionClass::t___construct(Variant v_name) {
2987   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::__construct);
2988   bool oldInCtor = gasInCtor(true);
2989   if (x_is_object(v_name)) {
2990     {
2991       {
2992         const Variant &tmp0((x_get_class(v_name)));
2993         v_name.assignVal(tmp0);
2994       }
2995     }
2996   }
2997   else {
2998     {
2999       {
3000         bool tmp0;
3001         {
3002           bool tmp1((x_class_exists(toString(v_name))));
3003           bool tmp2 = (!(tmp1));
3004           if (tmp2) {
3005             bool tmp3((x_interface_exists(toString(v_name))));
3006             tmp2 = (!(tmp3));
3007           }
3008           bool tmp4 = (tmp2);
3009           if (tmp4) {
3010             bool tmp5((x_trait_exists(toString(v_name))));
3011             tmp4 = (!(tmp5));
3012           }
3013           tmp0 = (tmp4);
3014         }
3015         if (tmp0) {
3016           {
3017             {
3018               p_ReflectionException tmp0 = coo_ReflectionException();
3019               throw_exception(((c_ReflectionException*)tmp0.get()->create(concat3(NAMSTR(s_sys_ssa78ef7eb, "Class "), toString(v_name), NAMSTR(s_sys_ss5784ed2b, " does not exist"))), tmp0));
3020             }
3021           }
3022         }
3023       }
3024     }
3025   }
3026   {
3027     const String &tmp0((x_hphp_get_original_class_name(toString(v_name))));
3028     m_name = tmp0;
3029   }
3030   gasInCtor(oldInCtor);
3031 }
3032 namespace hphp_impl_splitter {}
3033 /* SRC: classes/reflection.php line 560 */
3034 Variant c_ReflectionClass::t_fetch(CVarRef v_what) {
3035   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::fetch);
3036   Primitive v_interface = 0;
3037   Variant v__;
3038   p_ReflectionClass v_p;
3039
3040   if (!(toBoolean(m_info))) {
3041     {
3042       {
3043         const Variant &tmp0((call_user_func1(NAMVAR(s_sys_svs7732a9a6, "hphp_get_class_info"), m_name)));
3044         m_info.assignVal(tmp0);
3045       }
3046       if (empty(m_info)) {
3047         {
3048           {
3049             p_ReflectionException tmp0 = coo_ReflectionException();
3050             throw_exception(((c_ReflectionException*)tmp0.get()->create(concat3(NAMSTR(s_sys_ssa78ef7eb, "Class "), toString(m_name), NAMSTR(s_sys_ss5784ed2b, " does not exist"))), tmp0));
3051           }
3052         }
3053       }
3054       {
3055         LOOP_COUNTER(1);
3056         Variant map2 = m_info.rvalAt(NAMSTR(s_sys_sscfb8e254, "interfaces"), AccessFlags::Error_Key);
3057         for (ArrayIter iter3 = map2.begin(s_class_name, true); !iter3.end(); iter3.next()) {
3058           LOOP_COUNTER_CHECK(1);
3059           iter3.second(v__);
3060           v_interface.assignVal(iter3.first());
3061           {
3062             {
3063               p_ReflectionClass tmp0 = coo_ReflectionClass();
3064               ((c_ReflectionClass*)tmp0.get()->create(v_interface));
3065               v_p = tmp0;
3066             }
3067             {
3068               const Variant &tmp0((v_p->t_fetch(NAMVAR(s_sys_svs5b229ad5, "methods"))));
3069               m_info.setOpEqual(277, NAMSTR(s_sys_ss5b229ad5, "methods"), (tmp0), true);
3070             }
3071             {
3072               const Variant &tmp0((v_p->m_info.rvalAt(NAMSTR(s_sys_ss623ae369, "constants"), AccessFlags::Error_Key)));
3073               m_info.setOpEqual(277, NAMSTR(s_sys_ss623ae369, "constants"), (tmp0), true);
3074             }
3075             {
3076               const Variant &tmp0((v_p->m_info.rvalAt(NAMSTR(s_sys_sscfb8e254, "interfaces"), AccessFlags::Error_Key)));
3077               m_info.setOpEqual(277, NAMSTR(s_sys_sscfb8e254, "interfaces"), (tmp0), true);
3078             }
3079           }
3080         }
3081       }
3082       {
3083         bool tmp0;
3084         {
3085           tmp0 = (!(empty(m_info, NAMSTR(s_sys_ssfb10fd8c, "parent"), true)));
3086         }
3087         if (tmp0) {
3088           {
3089             {
3090               p_ReflectionClass tmp0 = coo_ReflectionClass();
3091               const Variant &tmp1((m_info.rvalAt(NAMSTR(s_sys_ssfb10fd8c, "parent"), AccessFlags::Error_Key)));
3092               ((c_ReflectionClass*)tmp0.get()->create(tmp1));
3093               v_p = tmp0;
3094             }
3095             if (toBoolean(t_isinterface())) {
3096               {
3097                 {
3098                   const Variant &tmp0((m_info.rvalAt(NAMSTR(s_sys_ssfb10fd8c, "parent"), AccessFlags::Error_Key)));
3099                   lval(m_info.lvalAt(NAMSTR(s_sys_sscfb8e254, "interfaces"), AccessFlags::CheckExist_Key)).append((tmp0));
3100                 }
3101               }
3102             }
3103             {
3104               const Variant &tmp0((v_p->t_fetch(NAMVAR(s_sys_svscfb8e254, "interfaces"))));
3105               m_info.setOpEqual(277, NAMSTR(s_sys_sscfb8e254, "interfaces"), (tmp0), true);
3106             }
3107             {
3108               const Variant &tmp0((v_p->m_info.rvalAt(NAMSTR(s_sys_ss90269404, "properties"), AccessFlags::Error_Key)));
3109               m_info.setOpEqual(277, NAMSTR(s_sys_ss90269404, "properties"), (tmp0), true);
3110             }
3111             {
3112               const Variant &tmp0((v_p->m_info.rvalAt(NAMSTR(s_sys_ss5b229ad5, "methods"), AccessFlags::Error_Key)));
3113               m_info.setOpEqual(277, NAMSTR(s_sys_ss5b229ad5, "methods"), (tmp0), true);
3114             }
3115             {
3116               const Variant &tmp0((v_p->m_info.rvalAt(NAMSTR(s_sys_ss623ae369, "constants"), AccessFlags::Error_Key)));
3117               m_info.setOpEqual(277, NAMSTR(s_sys_ss623ae369, "constants"), (tmp0), true);
3118             }
3119           }
3120         }
3121       }
3122     }
3123   }
3124   return m_info.rvalAt(v_what, AccessFlags::Error);
3125 }
3126 namespace hphp_impl_splitter {}
3127 /* SRC: classes/reflection.php line 587 */
3128 bool c_ReflectionClass::t_test(CVarRef v_what, CVarRef v_name) {
3129   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::test);
3130   Variant v_v;
3131
3132   {
3133     const Variant &tmp0((t_fetch(v_what)));
3134     v_v.assignVal(tmp0);
3135   }
3136   {
3137     bool tmp0 = (toBoolean(v_v));
3138     if (tmp0) {
3139       tmp0 = (isset(v_v, v_name));
3140     }
3141     return tmp0;
3142   }
3143 }
3144 namespace hphp_impl_splitter {}
3145 /* SRC: classes/reflection.php line 592 */
3146 String c_ReflectionClass::t___tostring() {
3147   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::__toString);
3148   return toString(null);
3149 }
3150 namespace hphp_impl_splitter {}
3151 /* SRC: classes/reflection.php line 611 */
3152 Variant c_ReflectionClass::t_export(CVarRef v_name, CVarRef v_ret) {
3153   STATIC_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::export);
3154   p_ReflectionClass v_obj;
3155   String v_str;
3156
3157   {
3158     p_ReflectionClass tmp0 = coo_ReflectionClass();
3159     ((c_ReflectionClass*)tmp0.get()->create(v_name));
3160     v_obj = tmp0;
3161   }
3162   v_str = (toString(v_obj));
3163   if (toBoolean(v_ret)) {
3164     {
3165       return v_str;
3166     }
3167   }
3168   print(v_str);
3169   return null;
3170 }
3171 namespace hphp_impl_splitter {}
3172 /* SRC: classes/reflection.php line 629 */
3173 Variant c_ReflectionClass::t_getname() {
3174   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getName);
3175   return m_name;
3176 }
3177 namespace hphp_impl_splitter {}
3178 /* SRC: classes/reflection.php line 643 */
3179 Variant c_ReflectionClass::t_isinternal() {
3180   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::isInternal);
3181   return t_fetch(NAMVAR(s_sys_svs9332a8ac, "internal"));
3182 }
3183 namespace hphp_impl_splitter {}
3184 /* SRC: classes/reflection.php line 656 */
3185 bool c_ReflectionClass::t_isuserdefined() {
3186   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::isUserDefined);
3187   {
3188     bool tmp0((toBoolean(t_fetch(NAMVAR(s_sys_svs9332a8ac, "internal")))));
3189     return !(tmp0);
3190   }
3191 }
3192 namespace hphp_impl_splitter {}
3193 /* SRC: classes/reflection.php line 670 */
3194 bool c_ReflectionClass::t_isinstantiable() {
3195   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::isInstantiable);
3196   {
3197     bool tmp0((toBoolean(t_fetch(NAMVAR(s_sys_svs12c8a8a6, "abstract")))));
3198     return !(tmp0);
3199   }
3200 }
3201 namespace hphp_impl_splitter {}
3202 /* SRC: classes/reflection.php line 685 */
3203 bool c_ReflectionClass::t_hasconstant(CVarRef v_name) {
3204   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::hasConstant);
3205   return t_test(NAMVAR(s_sys_svs623ae369, "constants"), v_name);
3206 }
3207 namespace hphp_impl_splitter {}
3208 /* SRC: classes/reflection.php line 699 */
3209 bool c_ReflectionClass::t_hasmethod(CVarRef v_name) {
3210   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::hasMethod);
3211   {
3212     const String &tmp0((x_strtolower(toString(v_name))));
3213     return t_test(NAMVAR(s_sys_svs5b229ad5, "methods"), VarNR(tmp0));
3214   }
3215 }
3216 namespace hphp_impl_splitter {}
3217 /* SRC: classes/reflection.php line 714 */
3218 bool c_ReflectionClass::t_hasproperty(CVarRef v_name) {
3219   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::hasProperty);
3220   return t_test(NAMVAR(s_sys_svs90269404, "properties"), v_name);
3221 }
3222 namespace hphp_impl_splitter {}
3223 /* SRC: classes/reflection.php line 729 */
3224 Variant c_ReflectionClass::t_getfilename() {
3225   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getFileName);
3226   return t_fetch(NAMVAR(s_sys_svs8ce7db5b, "file"));
3227 }
3228 namespace hphp_impl_splitter {}
3229 /* SRC: classes/reflection.php line 743 */
3230 Variant c_ReflectionClass::t_getstartline() {
3231   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getStartLine);
3232   return t_fetch(NAMVAR(s_sys_svsd4c67725, "line1"));
3233 }
3234 namespace hphp_impl_splitter {}
3235 /* SRC: classes/reflection.php line 756 */
3236 Variant c_ReflectionClass::t_getendline() {
3237   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getEndLine);
3238   return t_fetch(NAMVAR(s_sys_svsbefe32a8, "line2"));
3239 }
3240 namespace hphp_impl_splitter {}
3241 /* SRC: classes/reflection.php line 770 */
3242 Variant c_ReflectionClass::t_getdoccomment() {
3243   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getDocComment);
3244   return t_fetch(NAMVAR(s_sys_svs9cfa17a6, "doc"));
3245 }
3246 namespace hphp_impl_splitter {}
3247 /* SRC: classes/reflection.php line 784 */
3248 Variant c_ReflectionClass::t_getconstructor() {
3249   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getConstructor);
3250   Variant v_name;
3251
3252   if (t_hasmethod(NAMVAR(s_sys_svsa1b87da7, "__construct"))) {
3253     {
3254       return t_getmethod(NAMVAR(s_sys_svsa1b87da7, "__construct"));
3255     }
3256   }
3257   {
3258     bool tmp0;
3259     {
3260       bool tmp1((toBoolean(t_istrait())));
3261       bool tmp2 = (!(tmp1));
3262       if (tmp2) {
3263         tmp2 = (t_hasmethod(v_name.assignVal(m_name)));
3264       }
3265       tmp0 = (tmp2);
3266     }
3267     if (tmp0) {
3268       {
3269         return t_getmethod(v_name);
3270       }
3271     }
3272   }
3273   return null;
3274 }
3275 namespace hphp_impl_splitter {}
3276 /* SRC: classes/reflection.php line 805 */
3277 p_ReflectionMethod c_ReflectionClass::t_getmethod(CVarRef v_name) {
3278   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getMethod);
3279   String v_lname;
3280   Variant v_methods;
3281   Variant v_class;
3282   p_ReflectionMethod v_ret;
3283
3284   {
3285     const String &tmp0((x_strtolower(toString(v_name))));
3286     v_lname = tmp0;
3287   }
3288   {
3289     const Variant &tmp0((t_fetch(NAMVAR(s_sys_svs5b229ad5, "methods"))));
3290     v_methods.assignVal(tmp0);
3291   }
3292   {
3293     bool tmp0;
3294     {
3295       tmp0 = (!(isset(v_methods, v_lname)));
3296     }
3297     if (tmp0) {
3298       {
3299         {
3300           const Variant &tmp0((m_info.rvalAt(NAMSTR(s_sys_ssdc3cbddc, "name"), AccessFlags::Error_Key)));
3301           v_class.assignVal(tmp0);
3302         }
3303         {
3304           p_ReflectionException tmp0 = coo_ReflectionException();
3305           throw_exception(((c_ReflectionException*)tmp0.get()->create(concat5(NAMSTR(s_sys_ssdc6e02c2, "Method "), toString(v_class), NAMSTR(s_sys_ss819481f3, "::"), toString(v_name), NAMSTR(s_sys_ss5784ed2b, " does not exist"))), tmp0));
3306         }
3307       }
3308     }
3309   }
3310   {
3311     const p_ReflectionMethod &tmp0((p_ReflectionMethod(((c_ReflectionMethod*)coo_ReflectionMethod())->create(null, null))));
3312     v_ret = tmp0;
3313   }
3314   {
3315     const Variant &tmp0((v_methods.rvalAt(v_lname, AccessFlags::Error)));
3316     v_ret->m_info.assignVal(tmp0);
3317   }
3318   v_ret->m_name = v_lname;
3319   {
3320     const Variant &tmp0((m_info.rvalAt(NAMSTR(s_sys_ssdc3cbddc, "name"), AccessFlags::Error_Key)));
3321     v_ret->m_class.assignVal(tmp0);
3322   }
3323   {
3324     bool tmp0;
3325     {
3326       bool tmp1 = (equal(v_lname, NAMSTR(s_sys_ssa1b87da7, "__construct")));
3327       if (!tmp1) {
3328         bool tmp2((toBoolean(x_strcasecmp(v_lname, toString(v_ret->m_class)))));
3329         bool tmp3 = (!(tmp2));
3330         if (tmp3) {
3331           bool tmp4((t_hasmethod(NAMVAR(s_sys_svsa1b87da7, "__construct"))));
3332           tmp3 = (!(tmp4));
3333         }
3334         bool tmp5 = (tmp3);
3335         if (tmp5) {
3336           bool tmp6((toBoolean(t_istrait())));
3337           tmp5 = (!(tmp6));
3338         }
3339         tmp1 = (tmp5);
3340       }
3341       tmp0 = (tmp1);
3342     }
3343     if (tmp0) {
3344       {
3345         v_ret->m_info.set(NAMSTR(s_sys_ssefecb9dd, "constructor"), (true_varNR), true);
3346       }
3347     }
3348   }
3349   return v_ret;
3350 }
3351 namespace hphp_impl_splitter {}
3352 /* SRC: classes/reflection.php line 842 */
3353 Array c_ReflectionClass::t_getmethods(CVarRef v_filter //  = NAMVAR(s_sys_svi5830e7c6, 65535LL)
3354 ) {
3355   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getMethods);
3356   Array v_ret;
3357   Variant v_methods;
3358   Primitive v_name = 0;
3359   Variant v__;
3360   p_ReflectionMethod v_m;
3361
3362   v_ret = s_sys_sa00000000;
3363   {
3364     const Variant &tmp0((t_fetch(NAMVAR(s_sys_svs5b229ad5, "methods"))));
3365     v_methods.assignVal(tmp0);
3366   }
3367   {
3368     LOOP_COUNTER(1);
3369     for (ArrayIter iter3 = v_methods.begin(s_class_name, true); !iter3.end(); ++iter3) {
3370       LOOP_COUNTER_CHECK(1);
3371       iter3.second(v__);
3372       v_name.assignVal(iter3.first());
3373       {
3374         {
3375           const p_ReflectionMethod &tmp0((t_getmethod(v_name)));
3376           v_m = tmp0;
3377         }
3378         if (((((((toBoolean(bitwise_and(v_filter, 256LL /* ReflectionMethod::IS_PUBLIC */)) && v_m->t_ispublic()) || (toBoolean(bitwise_and(v_filter, 512LL /* ReflectionMethod::IS_PROTECTED */)) && v_m->t_isprotected())) || (toBoolean(bitwise_and(v_filter, 1024LL /* ReflectionMethod::IS_PRIVATE */)) && v_m->t_isprivate())) || (toBoolean(bitwise_and(v_filter, 1LL /* ReflectionMethod::IS_STATIC */)) && toBoolean(v_m->t_isstatic()))) || (toBoolean(bitwise_and(v_filter, 4LL /* ReflectionMethod::IS_FINAL */)) && toBoolean(v_m->t_isfinal()))) || (toBoolean(bitwise_and(v_filter, 2LL /* ReflectionMethod::IS_ABSTRACT */)) && toBoolean(v_m->t_isabstract())))) {
3379           {
3380             v_ret.append((VarNR(v_m)));
3381           }
3382         }
3383       }
3384     }
3385   }
3386   return v_ret;
3387 }
3388 namespace hphp_impl_splitter {}
3389 /* SRC: classes/reflection.php line 871 */
3390 p_ReflectionProperty c_ReflectionClass::t_getproperty(CVarRef v_name) {
3391   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getProperty);
3392   Variant v_properties;
3393   Variant v_class;
3394   p_ReflectionProperty v_ret;
3395
3396   {
3397     const Variant &tmp0((t_fetch(NAMVAR(s_sys_svs90269404, "properties"))));
3398     v_properties.assignVal(tmp0);
3399   }
3400   {
3401     bool tmp0;
3402     {
3403       tmp0 = (!(isset(v_properties, v_name)));
3404     }
3405     if (tmp0) {
3406       {
3407         {
3408           const Variant &tmp0((m_info.rvalAt(NAMSTR(s_sys_ssdc3cbddc, "name"), AccessFlags::Error_Key)));
3409           v_class.assignVal(tmp0);
3410         }
3411         {
3412           p_ReflectionException tmp0 = coo_ReflectionException();
3413           throw_exception(((c_ReflectionException*)tmp0.get()->create(concat5(NAMSTR(s_sys_ss9795dfc8, "Property "), toString(v_class), NAMSTR(s_sys_ss819481f3, "::"), toString(v_name), NAMSTR(s_sys_ss5784ed2b, " does not exist"))), tmp0));
3414         }
3415       }
3416     }
3417   }
3418   {
3419     const p_ReflectionProperty &tmp0((p_ReflectionProperty(((c_ReflectionProperty*)coo_ReflectionProperty())->create(null, null))));
3420     v_ret = tmp0;
3421   }
3422   {
3423     const Variant &tmp0((v_properties.rvalAt(v_name, AccessFlags::Error)));
3424     v_ret->m_info.assignVal(tmp0);
3425   }
3426   v_ret->m_name.assignVal(v_name);
3427   {
3428     const Variant &tmp0((m_info.rvalAt(NAMSTR(s_sys_ssdc3cbddc, "name"), AccessFlags::Error_Key)));
3429     v_ret->m_class.assignVal(tmp0);
3430   }
3431   return v_ret;
3432 }
3433 namespace hphp_impl_splitter {}
3434 /* SRC: classes/reflection.php line 894 */
3435 Array c_ReflectionClass::t_getproperties(CVarRef v_filter //  = NAMVAR(s_sys_svi5830e7c6, 65535LL)
3436 ) {
3437   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getProperties);
3438   Array v_ret;
3439   Primitive v_name = 0;
3440   Variant v__;
3441   p_ReflectionProperty v_p;
3442
3443   v_ret = s_sys_sa00000000;
3444   {
3445     LOOP_COUNTER(1);
3446     Variant map2 = t_fetch(NAMVAR(s_sys_svs90269404, "properties"));
3447     for (ArrayIter iter3 = map2.begin(s_class_name, true); !iter3.end(); iter3.next()) {
3448       LOOP_COUNTER_CHECK(1);
3449       iter3.second(v__);
3450       v_name.assignVal(iter3.first());
3451       {
3452         {
3453           const p_ReflectionProperty &tmp0((t_getproperty(v_name)));
3454           v_p = tmp0;
3455         }
3456         if (((((toBoolean(bitwise_and(v_filter, 256LL /* ReflectionProperty::IS_PUBLIC */)) && v_p->t_ispublic()) || (toBoolean(bitwise_and(v_filter, 512LL /* ReflectionProperty::IS_PROTECTED */)) && v_p->t_isprotected())) || (toBoolean(bitwise_and(v_filter, 1024LL /* ReflectionProperty::IS_PRIVATE */)) && v_p->t_isprivate())) || (toBoolean(bitwise_and(v_filter, 1LL /* ReflectionProperty::IS_STATIC */)) && toBoolean(v_p->t_isstatic())))) {
3457           {
3458             v_ret.append((VarNR(v_p)));
3459           }
3460         }
3461       }
3462     }
3463   }
3464   return v_ret;
3465 }
3466 namespace hphp_impl_splitter {}
3467 /* SRC: classes/reflection.php line 918 */
3468 Variant c_ReflectionClass::t_getconstants() {
3469   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getConstants);
3470   return t_fetch(NAMVAR(s_sys_svs623ae369, "constants"));
3471 }
3472 namespace hphp_impl_splitter {}
3473 /* SRC: classes/reflection.php line 932 */
3474 Variant c_ReflectionClass::t_getconstant(CVarRef v_name) {
3475   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getConstant);
3476   Variant v_constants;
3477   Variant v_class;
3478
3479   {
3480     const Variant &tmp0((t_fetch(NAMVAR(s_sys_svs623ae369, "constants"))));
3481     v_constants.assignVal(tmp0);
3482   }
3483   {
3484     bool tmp0;
3485     {
3486       tmp0 = (!(isset(v_constants, v_name)));
3487     }
3488     if (tmp0) {
3489       {
3490         {
3491           const Variant &tmp0((m_info.rvalAt(NAMSTR(s_sys_ssdc3cbddc, "name"), AccessFlags::Error_Key)));
3492           v_class.assignVal(tmp0);
3493         }
3494         {
3495           p_ReflectionException tmp0 = coo_ReflectionException();
3496           throw_exception(((c_ReflectionException*)tmp0.get()->create(concat5(NAMSTR(s_sys_ssd816f860, "Class constant "), toString(v_class), NAMSTR(s_sys_ss819481f3, "::"), toString(v_name), NAMSTR(s_sys_ss5784ed2b, " does not exist"))), tmp0));
3497         }
3498       }
3499     }
3500   }
3501   return v_constants.rvalAt(v_name, AccessFlags::Error);
3502 }
3503 namespace hphp_impl_splitter {}
3504 /* SRC: classes/reflection.php line 952 */
3505 Array c_ReflectionClass::t_getinterfaces() {
3506   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getInterfaces);
3507   Array v_ret;
3508   Primitive v_name = 0;
3509   Variant v__;
3510   p_ReflectionClass v_cls;
3511
3512   v_ret = s_sys_sa00000000;
3513   {
3514     LOOP_COUNTER(1);
3515     Variant map2 = t_fetch(NAMVAR(s_sys_svscfb8e254, "interfaces"));
3516     for (ArrayIter iter3 = map2.begin(s_class_name, true); !iter3.end(); iter3.next()) {
3517       LOOP_COUNTER_CHECK(1);
3518       iter3.second(v__);
3519       v_name.assignVal(iter3.first());
3520       {
3521         {
3522           p_ReflectionClass tmp0 = coo_ReflectionClass();
3523           ((c_ReflectionClass*)tmp0.get()->create(v_name));
3524           v_cls = tmp0;
3525         }
3526         if (toBoolean(v_cls->t_isinterface())) {
3527           {
3528             {
3529               const Variant &tmp0((v_cls->t_getname()));
3530               v_ret.set(tmp0, (VarNR(v_cls)));
3531             }
3532           }
3533         }
3534       }
3535     }
3536   }
3537   return v_ret;
3538 }
3539 namespace hphp_impl_splitter {}
3540 /* SRC: classes/reflection.php line 963 */
3541 Array c_ReflectionClass::t_gettraits() {
3542   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getTraits);
3543   Array v_ret;
3544   Primitive v_name = 0;
3545   Variant v__;
3546   p_ReflectionClass v_cls;
3547
3548   v_ret = s_sys_sa00000000;
3549   {
3550     LOOP_COUNTER(1);
3551     Variant map2 = t_fetch(NAMVAR(s_sys_svs77820fcc, "traits"));
3552     for (ArrayIter iter3 = map2.begin(s_class_name, true); !iter3.end(); iter3.next()) {
3553       LOOP_COUNTER_CHECK(1);
3554       iter3.second(v__);
3555       v_name.assignVal(iter3.first());
3556       {
3557         {
3558           p_ReflectionClass tmp0 = coo_ReflectionClass();
3559           ((c_ReflectionClass*)tmp0.get()->create(v_name));
3560           v_cls = tmp0;
3561         }
3562         if (toBoolean(v_cls->t_istrait())) {
3563           {
3564             {
3565               const Variant &tmp0((v_cls->t_getname()));
3566               v_ret.set(tmp0, (VarNR(v_cls)));
3567             }
3568           }
3569         }
3570       }
3571     }
3572   }
3573   return v_ret;
3574 }
3575 namespace hphp_impl_splitter {}
3576 /* SRC: classes/reflection.php line 984 */
3577 Array c_ReflectionClass::t_getinterfacenames() {
3578   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getInterfaceNames);
3579   Array v_ret;
3580   Primitive v_name = 0;
3581   Variant v__;
3582   p_ReflectionClass v_cls;
3583
3584   v_ret = s_sys_sa00000000;
3585   {
3586     LOOP_COUNTER(1);
3587     Variant map2 = t_fetch(NAMVAR(s_sys_svscfb8e254, "interfaces"));
3588     for (ArrayIter iter3 = map2.begin(s_class_name, true); !iter3.end(); iter3.next()) {
3589       LOOP_COUNTER_CHECK(1);
3590       iter3.second(v__);
3591       v_name.assignVal(iter3.first());
3592       {
3593         {
3594           p_ReflectionClass tmp0 = coo_ReflectionClass();
3595           ((c_ReflectionClass*)tmp0.get()->create(v_name));
3596           v_cls = tmp0;
3597         }
3598         if (toBoolean(v_cls->t_isinterface())) {
3599           {
3600             {
3601               const Variant &tmp0((v_cls->t_getname()));
3602               v_ret.append((tmp0));
3603             }
3604           }
3605         }
3606       }
3607     }
3608   }
3609   return v_ret;
3610 }
3611 namespace hphp_impl_splitter {}
3612 /* SRC: classes/reflection.php line 995 */
3613 Array c_ReflectionClass::t_gettraitnames() {
3614   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getTraitNames);
3615   Array v_ret;
3616   Primitive v_name = 0;
3617   Variant v__;
3618   p_ReflectionClass v_cls;
3619
3620   v_ret = s_sys_sa00000000;
3621   {
3622     LOOP_COUNTER(1);
3623     Variant map2 = t_fetch(NAMVAR(s_sys_svs77820fcc, "traits"));
3624     for (ArrayIter iter3 = map2.begin(s_class_name, true); !iter3.end(); iter3.next()) {
3625       LOOP_COUNTER_CHECK(1);
3626       iter3.second(v__);
3627       v_name.assignVal(iter3.first());
3628       {
3629         {
3630           p_ReflectionClass tmp0 = coo_ReflectionClass();
3631           ((c_ReflectionClass*)tmp0.get()->create(v_name));
3632           v_cls = tmp0;
3633         }
3634         if (toBoolean(v_cls->t_istrait())) {
3635           {
3636             {
3637               const Variant &tmp0((v_cls->t_getname()));
3638               v_ret.append((tmp0));
3639             }
3640           }
3641         }
3642       }
3643     }
3644   }
3645   return v_ret;
3646 }
3647 namespace hphp_impl_splitter {}
3648 /* SRC: classes/reflection.php line 1006 */
3649 Array c_ReflectionClass::t_gettraitaliases() {
3650   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getTraitAliases);
3651   Array v_ret;
3652   Primitive v_old_name = 0;
3653   Variant v_new_name;
3654
3655   v_ret = s_sys_sa00000000;
3656   {
3657     LOOP_COUNTER(1);
3658     Variant map2 = t_fetch(NAMVAR(s_sys_svsf65d4a13, "trait_aliases"));
3659     for (ArrayIter iter3 = map2.begin(s_class_name, true); !iter3.end(); iter3.next()) {
3660       LOOP_COUNTER_CHECK(1);
3661       iter3.second(v_new_name);
3662       v_old_name.assignVal(iter3.first());
3663       {
3664         v_ret.set(v_old_name, (v_new_name));
3665       }
3666     }
3667   }
3668   return v_ret;
3669 }
3670 namespace hphp_impl_splitter {}
3671 /* SRC: classes/reflection.php line 1024 */
3672 Variant c_ReflectionClass::t_isinterface() {
3673   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::isInterface);
3674   return t_fetch(NAMVAR(s_sys_svs7228e959, "interface"));
3675 }
3676 namespace hphp_impl_splitter {}
3677 /* SRC: classes/reflection.php line 1036 */
3678 Variant c_ReflectionClass::t_isabstract() {
3679   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::isAbstract);
3680   return t_fetch(NAMVAR(s_sys_svs12c8a8a6, "abstract"));
3681 }
3682 namespace hphp_impl_splitter {}
3683 /* SRC: classes/reflection.php line 1048 */
3684 Variant c_ReflectionClass::t_isfinal() {
3685   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::isFinal);
3686   return t_fetch(NAMVAR(s_sys_svs2145036e, "final"));
3687 }
3688 namespace hphp_impl_splitter {}
3689 /* SRC: classes/reflection.php line 1052 */
3690 Variant c_ReflectionClass::t_istrait() {
3691   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::isTrait);
3692   return t_fetch(NAMVAR(s_sys_svs22824d6b, "trait"));
3693 }
3694 namespace hphp_impl_splitter {}
3695 /* SRC: classes/reflection.php line 1065 */
3696 Variant c_ReflectionClass::t_getmodifiers() {
3697   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getModifiers);
3698   return t_fetch(NAMVAR(s_sys_svs9f244c80, "modifiers"));
3699 }
3700 namespace hphp_impl_splitter {}
3701 /* SRC: classes/reflection.php line 1079 */
3702 bool c_ReflectionClass::t_isinstance(CVarRef v_obj) {
3703   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::isInstance);
3704   return x_hphp_instanceof(toObject(v_obj), toString(m_name));
3705 }
3706 namespace hphp_impl_splitter {}
3707 /* SRC: classes/reflection.php line 1092 */
3708 Object c_ReflectionClass::t_newinstance(int num_args, Array args /* = Array() */) {
3709   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::newInstance);
3710   Array v_args;
3711
3712   {
3713     const Array &tmp0(((args.isNull() ? Array::Create() : args)));
3714     v_args = tmp0;
3715   }
3716   return x_hphp_create_object(toString(m_name), v_args);
3717 }
3718 namespace hphp_impl_splitter {}
3719 /* SRC: classes/reflection.php line 1111 */
3720 Object c_ReflectionClass::t_newinstanceargs(CVarRef v_args) {
3721   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::newInstanceArgs);
3722   {
3723     const String &tmp0((toString(m_name)));
3724     const Array &tmp1((toArray(x_array_values(v_args))));
3725     return x_hphp_create_object(tmp0, tmp1);
3726   }
3727 }
3728 namespace hphp_impl_splitter {}
3729 /* SRC: classes/reflection.php line 1125 */
3730 Variant c_ReflectionClass::t_getparentclass() {
3731   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getParentClass);
3732   Variant v_parent;
3733
3734   {
3735     const Variant &tmp0((t_fetch(NAMVAR(s_sys_svsfb10fd8c, "parent"))));
3736     v_parent.assignVal(tmp0);
3737   }
3738   if (empty(v_parent)) {
3739     {
3740       return false;
3741     }
3742   }
3743   {
3744     p_ReflectionClass tmp0 = coo_ReflectionClass();
3745     return ((c_ReflectionClass*)tmp0.get()->create(v_parent), tmp0);
3746   }
3747 }
3748 namespace hphp_impl_splitter {}
3749 /* SRC: classes/reflection.php line 1144 */
3750 Variant c_ReflectionClass::t_issubclassof(Variant v_cls) {
3751   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::isSubclassOf);
3752   Primitive v_name = 0;
3753   Variant v__;
3754   Variant v_parent;
3755
3756   if (instanceOf(v_cls, NAMSTR(s_sys_ssfc63c2bb, "ReflectionClass"))) {
3757     {
3758       {
3759         const Variant &tmp0((v_cls.o_getPublic(NAMSTR(s_sys_ssdc3cbddc, "name"), true)));
3760         v_cls.assignVal(tmp0);
3761       }
3762     }
3763   }
3764   {
3765     LOOP_COUNTER(1);
3766     Variant map2 = t_fetch(NAMVAR(s_sys_svscfb8e254, "interfaces"));
3767     for (ArrayIter iter3 = map2.begin(s_class_name, true); !iter3.end(); iter3.next()) {
3768       LOOP_COUNTER_CHECK(1);
3769       iter3.second(v__);
3770       v_name.assignVal(iter3.first());
3771       {
3772         {
3773           bool tmp0;
3774           {
3775             int tmp1((x_strcasecmp(toString(v_cls), toString(v_name))));
3776             tmp0 = (equal(tmp1, 0LL));
3777           }
3778           if (tmp0) {
3779             {
3780               return true;
3781             }
3782           }
3783         }
3784       }
3785     }
3786   }
3787   {
3788     const Variant &tmp0((t_fetch(NAMVAR(s_sys_svsfb10fd8c, "parent"))));
3789     v_parent.assignVal(tmp0);
3790   }
3791   if (empty(v_parent)) {
3792     {
3793       return false;
3794     }
3795   }
3796   {
3797     bool tmp0;
3798     {
3799       int tmp1((x_strcasecmp(toString(v_cls), toString(v_parent))));
3800       tmp0 = (equal(tmp1, 0LL));
3801     }
3802     if (tmp0) {
3803       {
3804         return true;
3805       }
3806     }
3807   }
3808   {
3809     MethodCallPackage mcp0;
3810     CVarRef obj0 = t_getparentclass();
3811     mcp0.methodCall((obj0), NAMSTR(s_sys_ssdd355b2b, "isSubclassOf"), 0x373333991926C97ELL);
3812     const CallInfo *cit0 ATTRIBUTE_UNUSED = mcp0.ci;
3813     return wrap_variant((mcp0.bindClass(fi)->getMeth1Args())(mcp0, 1, v_cls));
3814   }
3815 }
3816 namespace hphp_impl_splitter {}
3817 /* SRC: classes/reflection.php line 1173 */
3818 Array c_ReflectionClass::t_getstaticproperties() {
3819   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getStaticProperties);
3820   Array v_ret;
3821   Variant v_prop;
3822
3823   v_ret = s_sys_sa00000000;
3824   {
3825     LOOP_COUNTER(1);
3826     Variant map2 = t_getproperties();
3827     for (ArrayIter iter3 = map2.begin(s_class_name, true); !iter3.end(); iter3.next()) {
3828       LOOP_COUNTER_CHECK(1);
3829       iter3.second(v_prop);
3830       {
3831         {
3832           bool tmp0;
3833           {
3834             MethodCallPackage mcp1;
3835             CVarRef obj1 = v_prop;
3836             mcp1.methodCall((obj1), NAMSTR(s_sys_ss404bf1b4, "isStatic"), 0x7A15DC56E8CC0B19LL);
3837             const CallInfo *cit1 ATTRIBUTE_UNUSED = mcp1.ci;
3838             tmp0 = (toBoolean((mcp1.bindClass(fi)->getMeth0Args())(mcp1, 0)));
3839           }
3840           if (tmp0) {
3841             {
3842               {
3843                 const Variant &tmp0((v_prop.o_getPublic(NAMSTR(s_sys_ssdc3cbddc, "name"), true)));
3844                 v_ret.set(tmp0, (v_prop));
3845               }
3846             }
3847           }
3848         }
3849       }
3850     }
3851   }
3852   return v_ret;
3853 }
3854 namespace hphp_impl_splitter {}
3855 /* SRC: classes/reflection.php line 1194 */
3856 Variant c_ReflectionClass::t_getstaticpropertyvalue(CVarRef v_name, CVarRef v_default //  = null_variant
3857 ) {
3858   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getStaticPropertyValue);
3859   {
3860     bool tmp0;
3861     {
3862       bool tmp1 = (t_hasproperty(v_name));
3863       if (tmp1) {
3864         const p_ReflectionProperty &tmp2((t_getproperty(v_name)));
3865         tmp1 = (toBoolean(tmp2->t_isstatic()));
3866       }
3867       tmp0 = (tmp1);
3868     }
3869     if (tmp0) {
3870       {
3871         return x_hphp_get_static_property(toString(m_name), toString(v_name));
3872       }
3873     }
3874   }
3875   return v_default;
3876 }
3877 namespace hphp_impl_splitter {}
3878 /* SRC: classes/reflection.php line 1215 */
3879 void c_ReflectionClass::t_setstaticpropertyvalue(CVarRef v_name, CVarRef v_value) {
3880   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::setStaticPropertyValue);
3881   x_hphp_set_static_property(toString(m_name), toString(v_name), v_value);
3882 }
3883 namespace hphp_impl_splitter {}
3884 /* SRC: classes/reflection.php line 1229 */
3885 Array c_ReflectionClass::t_getdefaultproperties() {
3886   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getDefaultProperties);
3887   Array v_ret;
3888   Variant v_prop;
3889
3890   v_ret = s_sys_sa00000000;
3891   {
3892     LOOP_COUNTER(1);
3893     Variant map2 = t_getproperties();
3894     for (ArrayIter iter3 = map2.begin(s_class_name, true); !iter3.end(); iter3.next()) {
3895       LOOP_COUNTER_CHECK(1);
3896       iter3.second(v_prop);
3897       {
3898         {
3899           bool tmp0;
3900           {
3901             MethodCallPackage mcp1;
3902             CVarRef obj1 = v_prop;
3903             mcp1.methodCall((obj1), NAMSTR(s_sys_ss9dad4367, "isDefault"), 0x384A52597AB11F15LL);
3904             const CallInfo *cit1 ATTRIBUTE_UNUSED = mcp1.ci;
3905             tmp0 = (toBoolean((mcp1.bindClass(fi)->getMeth0Args())(mcp1, 0)));
3906           }
3907           if (tmp0) {
3908             {
3909               {
3910                 const Variant &tmp0((v_prop.o_getPublic(NAMSTR(s_sys_ssdc3cbddc, "name"), true)));
3911                 v_ret.set(tmp0, (v_prop));
3912               }
3913             }
3914           }
3915         }
3916       }
3917     }
3918   }
3919   return v_ret;
3920 }
3921 namespace hphp_impl_splitter {}
3922 /* SRC: classes/reflection.php line 1248 */
3923 Variant c_ReflectionClass::t_isiterateable() {
3924   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::isIterateable);
3925   return t_issubclassof(NAMSTR(s_sys_ss92306c9b, "ArrayAccess"));
3926 }
3927 namespace hphp_impl_splitter {}
3928 /* SRC: classes/reflection.php line 1263 */
3929 bool c_ReflectionClass::t_implementsinterface(Variant v_cls) {
3930   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::implementsInterface);
3931   Primitive v_name = 0;
3932   Variant v__;
3933
3934   if (instanceOf(v_cls, NAMSTR(s_sys_ssfc63c2bb, "ReflectionClass"))) {
3935     {
3936       {
3937         const Variant &tmp0((v_cls.o_getPublic(NAMSTR(s_sys_ssdc3cbddc, "name"), true)));
3938         v_cls.assignVal(tmp0);
3939       }
3940     }
3941   }
3942   {
3943     bool tmp0;
3944     {
3945       bool tmp1((x_interface_exists(toString(v_cls))));
3946       tmp0 = (!(tmp1));
3947     }
3948     if (tmp0) {
3949       {
3950         {
3951           p_ReflectionException tmp0 = coo_ReflectionException();
3952           throw_exception(((c_ReflectionException*)tmp0.get()->create(concat(toString(v_cls), NAMSTR(s_sys_ssda497f2a, " is not an Interface"))), tmp0));
3953         }
3954       }
3955     }
3956   }
3957   {
3958     LOOP_COUNTER(1);
3959     Variant map2 = t_fetch(NAMVAR(s_sys_svscfb8e254, "interfaces"));
3960     for (ArrayIter iter3 = map2.begin(s_class_name, true); !iter3.end(); iter3.next()) {
3961       LOOP_COUNTER_CHECK(1);
3962       iter3.second(v__);
3963       v_name.assignVal(iter3.first());
3964       {
3965         {
3966           bool tmp0;
3967           {
3968             int tmp1((x_strcasecmp(toString(v_cls), toString(v_name))));
3969             tmp0 = (equal(tmp1, 0LL));
3970           }
3971           if (tmp0) {
3972             {
3973               return true;
3974             }
3975           }
3976         }
3977       }
3978     }
3979   }
3980   return false;
3981 }
3982 namespace hphp_impl_splitter {}
3983 /* SRC: classes/reflection.php line 1288 */
3984 Variant c_ReflectionClass::t_getextension() {
3985   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getExtension);
3986   return t_fetch(NAMVAR(s_sys_svse9bf4500, "extension"));
3987 }
3988 namespace hphp_impl_splitter {}
3989 /* SRC: classes/reflection.php line 1302 */
3990 Variant c_ReflectionClass::t_getextensionname() {
3991   INSTANCE_METHOD_INJECTION_BUILTIN(ReflectionClass, ReflectionClass::getExtensionName);
3992   {
3993     MethodCallPackage mcp0;
3994     CVarRef obj0 = t_fetch(NAMVAR(s_sys_svse9bf4500, "extension"));
3995     mcp0.methodCall((obj0), NAMSTR(s_sys_ssc2df217e, "getName"), 0x23F51CDECC198965LL);
3996     const CallInfo *cit0 ATTRIBUTE_UNUSED = mcp0.ci;
3997     return wrap_variant((mcp0.bindClass(fi)->getMeth0Args())(mcp0, 0));
3998   }
3999 }
4000 namespace hphp_impl_splitter {}
4001 ObjectData *coo_ReflectionParameter() {
4002   return NEWOBJ(c_ReflectionParameter)();
4003 }
4004 ObjectData *coo_ReflectionMethod() {
4005   return NEWOBJ(c_ReflectionMethod)();
4006 }
4007 ObjectData *coo_ReflectionExtension() {
4008   return NEWOBJ(c_ReflectionExtension)();
4009 }
4010 ObjectData *coo_ReflectionFunction() {
4011   return NEWOBJ(c_ReflectionFunction)();
4012 }
4013 ObjectData *coo_ReflectionProperty() {
4014   return NEWOBJ(c_ReflectionProperty)();
4015 }
4016 ObjectData *coo_ReflectionFunctionAbstract() {
4017   return NEWOBJ(c_ReflectionFunctionAbstract)();
4018 }
4019 ObjectData *coo_ReflectionException() {
4020   return NEWOBJ(c_ReflectionException)();
4021 }
4022 ObjectData *coo_ReflectionObject() {
4023   return NEWOBJ(c_ReflectionObject)();
4024 }
4025 ObjectData *coo_ReflectionClass() {
4026   return NEWOBJ(c_ReflectionClass)();
4027 }
4028
4029 // Class tables
4030 static const int64 cpt_static_inits[] = {
4031   (int64)&NAMVAR(s_sys_svi86af027e, 16LL),
4032   (int64)&NAMVAR(s_sys_svif2a1fb10, 32LL),
4033   (int64)&NAMVAR(s_sys_svi1abc09e0, 64LL),
4034   (int64)&null_variant,
4035   (int64)&NAMVAR(s_sys_svibf7d1df5, 262144LL),
4036   (int64)&NAMVAR(s_sys_svib794f8ce, 1LL),
4037   (int64)&NAMVAR(s_sys_svi543f7d14, 1024LL),
4038   (int64)&NAMVAR(s_sys_svi6af020b2, 256LL),
4039   (int64)&NAMVAR(s_sys_svi90d5f98c, 2LL),
4040   (int64)&NAMVAR(s_sys_svi5e544a31, 4LL),
4041   (int64)&NAMVAR(s_sys_svid5e04164, 512LL),
4042 };
4043 static const ClassPropTableEntry cpt_table_entries[] = {
4044   {0x042E299D3BE2773ALL,1,0,0,100,4,0,&NAMSTR(s_sys_ss3be2773a, "IS_IMPLICIT_ABSTRACT") },
4045   {0x468EF528A19B529ELL,1,1,0,36,4,0,&NAMSTR(s_sys_ssa19b529e, "IS_EXPLICIT_ABSTRACT") },
4046   {0x47AAFAC74A58AD66LL,0,2,0,100,4,0,&NAMSTR(s_sys_ss4a58ad66, "IS_FINAL") },
4047
4048   {0x5655B4FF77E35232LL,1,3,0,68,10,GET_PROPERTY_OFFSET(c_ReflectionClass, m_name),&NAMSTR(s_sys_ssdc3cbddc, "name") },
4049   {0x0F2EF58F157D479FLL,0,3,17,65,10,GET_PROPERTY_OFFSET(c_ReflectionClass, m_info),&NAMSTR(s_sys_ss84e1d89d, "\000ReflectionClass\000info") },
4050
4051   {0x5655B4FF77E35232LL,1,3,21,65,10,GET_PROPERTY_OFFSET(c_ReflectionExtension, m_name),&NAMSTR(s_sys_ss8bbc8ede, "\000ReflectionExtension\000name") },
4052   {0x0F2EF58F157D479FLL,0,3,21,65,10,GET_PROPERTY_OFFSET(c_ReflectionExtension, m_info),&NAMSTR(s_sys_ss5596f6c8, "\000ReflectionExtension\000info") },
4053
4054   {0x25C5A7C72E7B0EF6LL,0,4,0,100,4,0,&NAMSTR(s_sys_ss2e7b0ef6, "IS_DEPRECATED") },
4055
4056   {0x0F2EF58F157D479FLL,0,3,0,66,10,GET_PROPERTY_OFFSET(c_ReflectionFunctionAbstract, m_info),&NAMSTR(s_sys_ss33988b3e, "info") },
4057
4058   {0x7DA78A433EE05120LL,2,5,0,100,4,0,&NAMSTR(s_sys_ss3ee05120, "IS_STATIC") },
4059   {0x163BE642CB04C741LL,2,6,0,100,4,0,&NAMSTR(s_sys_sscb04c741, "IS_PRIVATE") },
4060   {0x3784532769C1EF03LL,3,7,0,36,4,0,&NAMSTR(s_sys_ss69c1ef03, "IS_PUBLIC") },
4061   {0x6572B785E302A373LL,1,8,0,100,4,0,&NAMSTR(s_sys_sse302a373, "IS_ABSTRACT") },
4062   {0x47AAFAC74A58AD66LL,0,9,0,100,4,0,&NAMSTR(s_sys_ss4a58ad66, "IS_FINAL") },
4063   {0x10A614A8C272DC9ELL,-4,10,0,100,4,0,&NAMSTR(s_sys_ssc272dc9e, "IS_PROTECTED") },
4064
4065   {0x2E3A246D1F74C210LL,0,3,0,68,10,GET_PROPERTY_OFFSET(c_ReflectionMethod, m_class),&NAMSTR(s_sys_ssc82dbd12, "class") },
4066   {0x5655B4FF77E35232LL,-1,3,0,68,10,GET_PROPERTY_OFFSET(c_ReflectionMethod, m_name),&NAMSTR(s_sys_ssdc3cbddc, "name") },
4067
4068   {0x0F2EF58F157D479FLL,0,3,0,68,10,GET_PROPERTY_OFFSET(c_ReflectionParameter, m_info),&NAMSTR(s_sys_ss33988b3e, "info") },
4069
4070   {0x7DA78A433EE05120LL,2,5,0,100,4,0,&NAMSTR(s_sys_ss3ee05120, "IS_STATIC") },
4071   {0x163BE642CB04C741LL,0,6,0,100,4,0,&NAMSTR(s_sys_sscb04c741, "IS_PRIVATE") },
4072   {0x3784532769C1EF03LL,1,7,0,100,4,0,&NAMSTR(s_sys_ss69c1ef03, "IS_PUBLIC") },
4073   {0x10A614A8C272DC9ELL,-2,10,0,100,4,0,&NAMSTR(s_sys_ssc272dc9e, "IS_PROTECTED") },
4074
4075   {0x2E3A246D1F74C210LL,0,3,0,68,10,GET_PROPERTY_OFFSET(c_ReflectionProperty, m_class),&NAMSTR(s_sys_ssc82dbd12, "class") },
4076   {0x5655B4FF77E35232LL,-1,3,0,68,10,GET_PROPERTY_OFFSET(c_ReflectionProperty, m_name),&NAMSTR(s_sys_ssdc3cbddc, "name") },
4077   {0x0F2EF58F157D479FLL,-1,3,0,68,10,GET_PROPERTY_OFFSET(c_ReflectionProperty, m_info),&NAMSTR(s_sys_ss33988b3e, "info") },
4078
4079 };
4080 static const int cpt_hash_entries[] = {
4081   // ReflectionClass hash
4082   -1,1,-1,-1,-1,0,-1,-1,
4083   -1,-1,3,-1,-1,-1,-1,4,
4084   // ReflectionClass lists
4085   4,-1,
4086   -1,
4087   -1,
4088   // ReflectionExtension hash
4089   -1,-1,0,-1,-1,-1,-1,1,
4090   // ReflectionExtension lists
4091   0,1,-1,
4092   -1,
4093   -1,
4094   // ReflectionFunction hash
4095   -1,0,-1,-1,-1,-1,-1,-1,
4096   // ReflectionFunction lists
4097   -1,
4098   -1,
4099   -1,
4100   // ReflectionFunctionAbstract hash
4101   -1,-1,-1,-1,-1,-1,-1,0,
4102   // ReflectionFunctionAbstract lists
4103   -1,
4104   -1,
4105   -1,
4106   // ReflectionMethod hash
4107   -1,5,-1,-1,-1,-1,-1,-1,-1,4,-1,-1,2,-1,1,0,
4108   6,-1,7,-1,-1,-1,-1,-1,
4109   // ReflectionMethod lists
4110   -1,
4111   -1,
4112   -1,
4113   // ReflectionParameter hash
4114   -1,-1,-1,-1,-1,-1,-1,0,
4115   // ReflectionParameter lists
4116   -1,
4117   -1,
4118   -1,
4119   // ReflectionProperty hash
4120   -1,3,-1,-1,2,-1,1,0,
4121   4,-1,5,-1,-1,-1,-1,6,
4122   // ReflectionProperty lists
4123   -1,
4124   -1,
4125   -1,
4126 };
4127 const ClassPropTable c_ReflectionClass::os_prop_table = {
4128   7,3,-1,-1,7,0,10,0,
4129   cpt_hash_entries+8,0,cpt_table_entries+0,cpt_static_inits
4130 };
4131 const ClassPropTable c_ReflectionExtension::os_prop_table = {
4132   7,0,-1,-1,-1,-1,11,0,
4133   cpt_hash_entries+20,0,cpt_table_entries+5,cpt_static_inits
4134 };
4135 const ClassPropTable c_ReflectionFunction::os_prop_table = {
4136   -1,-1,-1,-1,7,0,1,0,
4137   cpt_hash_entries+41,&c_ReflectionFunctionAbstract::os_prop_table,cpt_table_entries+7,cpt_static_inits
4138 };
4139 const ClassPropTable c_ReflectionFunctionAbstract::os_prop_table = {
4140   7,0,-1,-1,-1,-1,9,0,
4141   cpt_hash_entries+44,0,cpt_table_entries+8,cpt_static_inits
4142 };
4143 const ClassPropTable c_ReflectionMethod::os_prop_table = {
4144   7,7,-1,-1,15,0,9,0,
4145   cpt_hash_entries+71,&c_ReflectionFunctionAbstract::os_prop_table,cpt_table_entries+9,cpt_static_inits
4146 };
4147 const ClassPropTable c_ReflectionParameter::os_prop_table = {
4148   7,0,-1,-1,-1,-1,9,0,
4149   cpt_hash_entries+82,0,cpt_table_entries+17,cpt_static_inits
4150 };
4151 const ClassPropTable c_ReflectionProperty::os_prop_table = {
4152   7,6,-1,-1,7,0,9,0,
4153   cpt_hash_entries+101,0,cpt_table_entries+18,cpt_static_inits
4154 };
4155
4156 ///////////////////////////////////////////////////////////////////////////////
4157 }