hphp/runtime/base/array-data-defs.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com)  |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15 */
  16
  17 #ifndef incl_HPHP_ARRAY_DATA_DEFS_H_
  18 #define incl_HPHP_ARRAY_DATA_DEFS_H_
  19
  20 #include "hphp/runtime/base/array-data.h"
  21
  22 #include "hphp/runtime/base/member-val.h"
  23 #include "hphp/runtime/base/string-data.h"
  24 #include "hphp/runtime/base/type-variant.h"
  25
  26 #include <algorithm>
  27
  28 namespace HPHP {
  29
  30 ///////////////////////////////////////////////////////////////////////////////
  31
  32 extern const StaticString s_InvalidKeysetOperationMsg;
  33 extern const StaticString s_VecUnsetMsg;
  34
  35 ///////////////////////////////////////////////////////////////////////////////
  36
  37 inline ArrayData* ArrayData::Create(const Variant& value) {
  38   return Create(*value.asTypedValue());
  39 }
  40
  41 inline ArrayData* ArrayData::Create(const Variant& name, TypedValue value) {
  42   return Create(*name.asTypedValue(), value);
  43 }
  44
  45 inline ArrayData* ArrayData::Create(const Variant& name, const Variant& value) {
  46   return Create(*name.asTypedValue(), *value.asTypedValue());
  47 }
  48
  49 inline ArrayData* ArrayData::CreateWithRef(const Variant& name,
  50                                            TypedValue value) {
  51   return CreateWithRef(*name.asTypedValue(), value);
  52 }
  53
  54 inline ArrayData* ArrayData::CreateRef(const Variant& name, Variant& value) {
  55   return CreateRef(*name.asTypedValue(), value);
  56 }
  57
  58 ///////////////////////////////////////////////////////////////////////////////
  59 // ArrayFunction dispatch.
  60
  61 inline ArrayData* ArrayData::copy() const {
  62   return g_array_funcs.copy[kind()](this);
  63 }
  64
  65 inline ArrayData* ArrayData::copyStatic() const {
  66   auto ret = g_array_funcs.copyStatic[kind()](this);
  67   assert(ret != this && ret->isStatic());
  68   return ret;
  69 }
  70
  71 inline ArrayData* ArrayData::toPHPArray(bool copy) {
  72   return g_array_funcs.toPHPArray[kind()](this, copy);
  73 }
  74
  75 inline ArrayData* ArrayData::toDict(bool copy) {
  76   return g_array_funcs.toDict[kind()](this, copy);
  77 }
  78
  79 inline ArrayData* ArrayData::toVec(bool copy) {
  80   return g_array_funcs.toVec[kind()](this, copy);
  81 }
  82
  83 inline ArrayData* ArrayData::toKeyset(bool copy) {
  84   return g_array_funcs.toKeyset[kind()](this, copy);
  85 }
  86
  87 inline ArrayData* ArrayData::toVArray(bool copy) {
  88   return g_array_funcs.toVArray[kind()](this, copy);
  89 }
  90
  91 inline ArrayData* ArrayData::toDArray(bool copy) {
  92   return g_array_funcs.toDArray[kind()](this, copy);
  93 }
  94
  95 inline ArrayData* ArrayData::escalate() const {
  96   return g_array_funcs.escalate[kind()](this);
  97 }
  98
  99 inline bool ArrayData::isVectorData() const {
 100   return g_array_funcs.isVectorData[kind()](this);
 101 }
 102
 103 inline void ArrayData::release() noexcept {
 104   assert(hasExactlyOneRef());
 105   g_array_funcs.release[kind()](this);
 106   AARCH64_WALKABLE_FRAME();
 107 }
 108
 109 inline bool ArrayData::exists(int64_t k) const {
 110   return g_array_funcs.existsInt[kind()](this, k);
 111 }
 112
 113 inline bool ArrayData::exists(const StringData* k) const {
 114   return g_array_funcs.existsStr[kind()](this, k);
 115 }
 116
 117 inline member_lval ArrayData::lval(int64_t k, bool copy) {
 118   return g_array_funcs.lvalInt[kind()](this, k, copy);
 119 }
 120
 121 inline member_lval ArrayData::lval(StringData* k, bool copy) {
 122   return g_array_funcs.lvalStr[kind()](this, k, copy);
 123 }
 124
 125 inline member_lval ArrayData::lvalRef(int64_t k, bool copy) {
 126   return g_array_funcs.lvalIntRef[kind()](this, k, copy);
 127 }
 128
 129 inline member_lval ArrayData::lvalRef(StringData* k, bool copy) {
 130   return g_array_funcs.lvalStrRef[kind()](this, k, copy);
 131 }
 132
 133 inline member_lval ArrayData::lvalNew(bool copy) {
 134   return g_array_funcs.lvalNew[kind()](this, copy);
 135 }
 136
 137 inline member_lval ArrayData::lvalNewRef(bool copy) {
 138   return g_array_funcs.lvalNewRef[kind()](this, copy);
 139 }
 140
 141 inline member_rval ArrayData::rval(int64_t k) const {
 142   return member_rval { this, g_array_funcs.nvGetInt[kind()](this, k) };
 143 }
 144
 145 inline member_rval ArrayData::rval(const StringData* k) const {
 146   return member_rval { this, g_array_funcs.nvGetStr[kind()](this, k) };
 147 }
 148
 149 inline member_rval ArrayData::rvalStrict(int64_t k) const {
 150   return member_rval { this, g_array_funcs.nvTryGetInt[kind()](this, k) };
 151 }
 152
 153 inline member_rval ArrayData::rvalStrict(const StringData* k) const {
 154   return member_rval { this, g_array_funcs.nvTryGetStr[kind()](this, k) };
 155 }
 156
 157 inline member_rval ArrayData::rvalPos(ssize_t pos) const {
 158   return member_rval { this, g_array_funcs.nvGetPos[kind()](this, pos) };
 159 }
 160
 161 inline Cell ArrayData::nvGetKey(ssize_t pos) const {
 162   return g_array_funcs.nvGetKey[kind()](this, pos);
 163 }
 164
 165 inline ArrayData* ArrayData::set(int64_t k, Cell v, bool copy) {
 166   assertx(cellIsPlausible(v));
 167   return g_array_funcs.setInt[kind()](this, k, v, copy);
 168 }
 169
 170 inline ArrayData* ArrayData::set(StringData* k, Cell v, bool copy) {
 171   assertx(cellIsPlausible(v));
 172   return g_array_funcs.setStr[kind()](this, k, v, copy);
 173 }
 174
 175 inline ArrayData* ArrayData::set(int64_t k, const Variant& v, bool copy) {
 176   return g_array_funcs.setInt[kind()](this, k, *v.asCell(), copy);
 177 }
 178
 179 inline ArrayData* ArrayData::set(StringData* k, const Variant& v, bool copy) {
 180   return g_array_funcs.setStr[kind()](this, k, *v.asCell(), copy);
 181 }
 182
 183 inline ArrayData* ArrayData::setWithRef(int64_t k, TypedValue v, bool copy) {
 184   assertx(tvIsPlausible(v));
 185   return g_array_funcs.setWithRefInt[kind()](this, k, v, copy);
 186 }
 187
 188 inline ArrayData* ArrayData::setWithRef(StringData* k,
 189                                         TypedValue v, bool copy) {
 190   assertx(tvIsPlausible(v));
 191   return g_array_funcs.setWithRefStr[kind()](this, k, v, copy);
 192 }
 193
 194 inline ArrayData* ArrayData::setRef(int64_t k, member_lval v, bool copy) {
 195   return g_array_funcs.setRefInt[kind()](this, k, v, copy);
 196 }
 197
 198 inline ArrayData* ArrayData::setRef(StringData* k, member_lval v, bool copy) {
 199   return g_array_funcs.setRefStr[kind()](this, k, v, copy);
 200 }
 201
 202 inline ArrayData* ArrayData::add(int64_t k, Cell v, bool copy) {
 203   assertx(cellIsPlausible(v));
 204   return g_array_funcs.addInt[kind()](this, k, v, copy);
 205 }
 206
 207 inline ArrayData* ArrayData::add(StringData* k, Cell v, bool copy) {
 208   assertx(cellIsPlausible(v));
 209   return g_array_funcs.addStr[kind()](this, k, v, copy);
 210 }
 211
 212 inline ArrayData* ArrayData::add(int64_t k, const Variant& v, bool copy) {
 213   return g_array_funcs.addInt[kind()](this, k, *v.asCell(), copy);
 214 }
 215
 216 inline ArrayData* ArrayData::add(StringData* k, const Variant& v, bool copy) {
 217   return g_array_funcs.addStr[kind()](this, k, *v.asCell(), copy);
 218 }
 219
 220 inline ArrayData* ArrayData::remove(int64_t k, bool copy) {
 221   return g_array_funcs.removeInt[kind()](this, k, copy);
 222 }
 223
 224 inline ArrayData* ArrayData::remove(const StringData* k, bool copy) {
 225   return g_array_funcs.removeStr[kind()](this, k, copy);
 226 }
 227
 228 inline ArrayData* ArrayData::append(Cell v, bool copy) {
 229   assertx(v.m_type != KindOfUninit);
 230   return g_array_funcs.append[kind()](this, v, copy);
 231 }
 232
 233 inline ArrayData* ArrayData::appendWithRef(TypedValue v, bool copy) {
 234   return g_array_funcs.appendWithRef[kind()](this, v, copy);
 235 }
 236
 237 inline ArrayData* ArrayData::appendWithRef(const Variant& v, bool copy) {
 238   return g_array_funcs.appendWithRef[kind()](this, *v.asTypedValue(), copy);
 239 }
 240
 241 inline ArrayData* ArrayData::appendRef(member_lval v, bool copy) {
 242   return g_array_funcs.appendRef[kind()](this, v, copy);
 243 }
 244
 245 inline ssize_t ArrayData::iter_begin() const {
 246   return g_array_funcs.iterBegin[kind()](this);
 247 }
 248
 249 inline ssize_t ArrayData::iter_last() const {
 250   return g_array_funcs.iterLast[kind()](this);
 251 }
 252
 253 inline ssize_t ArrayData::iter_end() const {
 254   return g_array_funcs.iterEnd[kind()](this);
 255 }
 256
 257 inline ssize_t ArrayData::iter_advance(ssize_t pos) const {
 258   return g_array_funcs.iterAdvance[kind()](this, pos);
 259 }
 260
 261 inline ssize_t ArrayData::iter_rewind(ssize_t pos) const {
 262   return g_array_funcs.iterRewind[kind()](this, pos);
 263 }
 264
 265 inline bool ArrayData::validMArrayIter(const MArrayIter& fp) const {
 266   return g_array_funcs.validMArrayIter[kind()](this, fp);
 267 }
 268
 269 inline bool ArrayData::advanceMArrayIter(MArrayIter& fp) {
 270   return g_array_funcs.advanceMArrayIter[kind()](this, fp);
 271 }
 272
 273 inline ArrayData* ArrayData::escalateForSort(SortFunction sf) {
 274   return g_array_funcs.escalateForSort[kind()](this, sf);
 275 }
 276
 277 inline void ArrayData::ksort(int sort_flags, bool ascending) {
 278   return g_array_funcs.ksort[kind()](this, sort_flags, ascending);
 279 }
 280
 281 inline void ArrayData::sort(int sort_flags, bool ascending) {
 282   return g_array_funcs.sort[kind()](this, sort_flags, ascending);
 283 }
 284
 285 inline void ArrayData::asort(int sort_flags, bool ascending) {
 286   return g_array_funcs.asort[kind()](this, sort_flags, ascending);
 287 }
 288
 289 inline bool ArrayData::uksort(const Variant& compare) {
 290   return g_array_funcs.uksort[kind()](this, compare);
 291 }
 292
 293 inline bool ArrayData::usort(const Variant& compare) {
 294   return g_array_funcs.usort[kind()](this, compare);
 295 }
 296
 297 inline bool ArrayData::uasort(const Variant& compare) {
 298   return g_array_funcs.uasort[kind()](this, compare);
 299 }
 300
 301 inline ArrayData* ArrayData::plusEq(const ArrayData* elms) {
 302   return g_array_funcs.plusEq[kind()](this, elms);
 303 }
 304
 305 inline ArrayData* ArrayData::merge(const ArrayData* elms) {
 306   auto ret = g_array_funcs.merge[kind()](this, elms);
 307   assertx(ret->isPHPArray());
 308   assertx(ret->isNotDVArray());
 309   return ret;
 310 }
 311
 312 inline ArrayData* ArrayData::pop(Variant& value) {
 313   return g_array_funcs.pop[kind()](this, value);
 314 }
 315
 316 inline ArrayData* ArrayData::dequeue(Variant& value) {
 317   return g_array_funcs.dequeue[kind()](this, value);
 318 }
 319
 320 inline ArrayData* ArrayData::prepend(Cell v, bool copy) {
 321   assertx(v.m_type != KindOfUninit);
 322   return g_array_funcs.prepend[kind()](this, v, copy);
 323 }
 324
 325 inline void ArrayData::onSetEvalScalar() {
 326   return g_array_funcs.onSetEvalScalar[kind()](this);
 327 }
 328
 329 inline void ArrayData::renumber() {
 330   return g_array_funcs.renumber[kind()](this);
 331 }
 332
 333 ///////////////////////////////////////////////////////////////////////////////
 334
 335 namespace detail {
 336
 337 inline bool isIntKey(Cell cell) {
 338   assert(isIntType(cell.m_type) || isStringType(cell.m_type));
 339   return isIntType(cell.m_type);
 340 }
 341
 342 inline int64_t getIntKey(Cell cell) {
 343   assert(isIntType(cell.m_type));
 344   return cell.m_data.num;
 345 }
 346
 347 inline StringData* getStringKey(Cell cell) {
 348   assert(isStringType(cell.m_type));
 349   return cell.m_data.pstr;
 350 }
 351
 352 }
 353
 354 ///////////////////////////////////////////////////////////////////////////////
 355 // Element manipulation.
 356
 357 inline bool ArrayData::exists(Cell k) const {
 358   assert(IsValidKey(k));
 359   return detail::isIntKey(k) ? exists(detail::getIntKey(k))
 360                              : exists(detail::getStringKey(k));
 361 }
 362
 363 inline member_lval ArrayData::lval(Cell k, bool copy) {
 364   assert(IsValidKey(k));
 365   return detail::isIntKey(k) ? lval(detail::getIntKey(k), copy)
 366                              : lval(detail::getStringKey(k), copy);
 367 }
 368
 369 inline member_lval ArrayData::lvalRef(Cell k, bool copy) {
 370   assert(IsValidKey(k));
 371   return detail::isIntKey(k) ? lvalRef(detail::getIntKey(k), copy)
 372                              : lvalRef(detail::getStringKey(k), copy);
 373 }
 374
 375 inline member_rval ArrayData::get(int64_t k, bool error) const {
 376   auto r = error ? rvalStrict(k) : rval(k);
 377   return r ? r : getNotFound(k, error);
 378 }
 379
 380 inline member_rval ArrayData::get(const StringData* k, bool error) const {
 381   auto r = error ? rvalStrict(k) : rval(k);
 382   return r ? r : getNotFound(k, error);
 383 }
 384
 385 inline member_rval ArrayData::get(Cell k, bool error) const {
 386   assert(IsValidKey(k));
 387   return detail::isIntKey(k) ? get(detail::getIntKey(k), error)
 388                              : get(detail::getStringKey(k), error);
 389 }
 390
 391 inline TypedValue ArrayData::at(int64_t k) const {
 392   return rval(k).tv();
 393 }
 394
 395 inline TypedValue ArrayData::at(const StringData* k) const {
 396   return rval(k).tv();
 397 }
 398
 399 inline TypedValue ArrayData::atPos(ssize_t pos) const {
 400   return rvalPos(pos).tv();
 401 }
 402
 403 inline ArrayData* ArrayData::set(Cell k, Cell v, bool copy) {
 404   assertx(cellIsPlausible(k));
 405   assertx(cellIsPlausible(v));
 406   assertx(IsValidKey(k));
 407
 408   return detail::isIntKey(k) ? set(detail::getIntKey(k), v, copy)
 409                              : set(detail::getStringKey(k), v, copy);
 410 }
 411
 412 inline ArrayData* ArrayData::setWithRef(Cell k, TypedValue v, bool copy) {
 413   assertx(cellIsPlausible(k));
 414   assertx(tvIsPlausible(v));
 415   assertx(IsValidKey(k));
 416
 417   return detail::isIntKey(k) ? setWithRef(detail::getIntKey(k), v, copy)
 418                              : setWithRef(detail::getStringKey(k), v, copy);
 419 }
 420
 421 inline ArrayData* ArrayData::setRef(Cell k, member_lval v, bool copy) {
 422   assert(IsValidKey(k));
 423   return detail::isIntKey(k) ? setRef(detail::getIntKey(k), v, copy)
 424                              : setRef(detail::getStringKey(k), v, copy);
 425 }
 426
 427 inline ArrayData* ArrayData::setRef(int64_t k, Variant& v, bool copy) {
 428   return setRef(k, member_lval::raw(v.asTypedValue()), copy);
 429 }
 430
 431 inline ArrayData* ArrayData::setRef(StringData* k, Variant& v, bool copy) {
 432   return setRef(k, member_lval::raw(v.asTypedValue()), copy);
 433 }
 434
 435 inline ArrayData* ArrayData::setRef(Cell k, Variant& v, bool copy) {
 436   return setRef(k, member_lval::raw(v.asTypedValue()), copy);
 437 }
 438
 439 inline ArrayData* ArrayData::add(Cell k, Cell v, bool copy) {
 440   assertx(cellIsPlausible(k));
 441   assertx(cellIsPlausible(v));
 442   assertx(IsValidKey(k));
 443
 444   return detail::isIntKey(k) ? add(detail::getIntKey(k), v, copy)
 445                              : add(detail::getStringKey(k), v, copy);
 446 }
 447
 448 inline ArrayData* ArrayData::remove(Cell k, bool copy) {
 449   assert(IsValidKey(k));
 450   return detail::isIntKey(k) ? remove(detail::getIntKey(k), copy)
 451                              : remove(detail::getStringKey(k), copy);
 452 }
 453
 454 ///////////////////////////////////////////////////////////////////////////////
 455
 456 inline bool ArrayData::exists(const String& k) const {
 457   assert(IsValidKey(k));
 458   return exists(k.get());
 459 }
 460
 461 inline bool ArrayData::exists(const Variant& k) const {
 462   return exists(*k.asCell());
 463 }
 464
 465 inline member_lval ArrayData::lval(const String& k, bool copy) {
 466   assert(IsValidKey(k));
 467   return lval(k.get(), copy);
 468 }
 469
 470 inline member_lval ArrayData::lval(const Variant& k, bool copy) {
 471   return lval(*k.asCell(), copy);
 472 }
 473
 474 inline member_lval ArrayData::lvalRef(const String& k, bool copy) {
 475   assert(IsValidKey(k));
 476   return lvalRef(k.get(), copy);
 477 }
 478
 479 inline member_lval ArrayData::lvalRef(const Variant& k, bool copy) {
 480   return lvalRef(*k.asCell(), copy);
 481 }
 482
 483 inline member_rval ArrayData::get(const String& k, bool error) const {
 484   assert(IsValidKey(k));
 485   return get(k.get(), error);
 486 }
 487
 488 inline member_rval ArrayData::get(const Variant& k, bool error) const {
 489   return get(*k.asCell(), error);
 490 }
 491
 492 inline ArrayData* ArrayData::set(const String& k, Cell v, bool copy) {
 493   assertx(cellIsPlausible(v));
 494   assertx(IsValidKey(k));
 495   return set(k.get(), v, copy);
 496 }
 497
 498 inline ArrayData* ArrayData::set(const String& k, const Variant& v,
 499                                  bool copy) {
 500   return set(k, *v.asCell(), copy);
 501 }
 502
 503 inline ArrayData* ArrayData::set(const Variant& k, const Variant& v,
 504                                  bool copy) {
 505   return set(*k.asCell(), *v.asCell(), copy);
 506 }
 507
 508 inline ArrayData* ArrayData::setWithRef(const String& k,
 509                                         TypedValue v, bool copy) {
 510   assertx(tvIsPlausible(v));
 511   assertx(IsValidKey(k));
 512   return setWithRef(k.get(), v, copy);
 513 }
 514
 515 inline ArrayData*
 516 ArrayData::setRef(const String& k, member_lval v, bool copy) {
 517   assert(IsValidKey(k));
 518   return setRef(k.get(), v, copy);
 519 }
 520
 521 inline ArrayData*
 522 ArrayData::setRef(const Variant& k, member_lval v, bool copy) {
 523   return setRef(*k.asCell(), v, copy);
 524 }
 525
 526 inline ArrayData* ArrayData::setRef(const String& k, Variant& v, bool copy) {
 527   return setRef(k, member_lval::raw(v.asTypedValue()), copy);
 528 }
 529
 530 inline ArrayData* ArrayData::setRef(const Variant& k, Variant& v, bool copy) {
 531   return setRef(k, member_lval::raw(v.asTypedValue()), copy);
 532 }
 533
 534 inline ArrayData* ArrayData::add(const String& k, Cell v, bool copy) {
 535   assertx(cellIsPlausible(v));
 536   assert(IsValidKey(k));
 537   return add(k.get(), v, copy);
 538 }
 539
 540 inline ArrayData* ArrayData::add(const String& k, const Variant& v,
 541                                  bool copy) {
 542   return add(k, *v.asCell(), copy);
 543 }
 544
 545 inline ArrayData* ArrayData::add(const Variant& k, const Variant& v,
 546                                  bool copy) {
 547   return add(*k.asCell(), *v.asCell(), copy);
 548 }
 549
 550 inline ArrayData* ArrayData::remove(const String& k, bool copy) {
 551   assert(IsValidKey(k));
 552   return remove(k.get(), copy);
 553 }
 554
 555 inline ArrayData* ArrayData::remove(const Variant& k, bool copy) {
 556   return remove(*k.asCell(), copy);
 557 }
 558
 559 inline ArrayData* ArrayData::appendRef(Variant& v, bool copy) {
 560   return appendRef(member_lval::raw(v.asTypedValue()), copy);
 561 }
 562
 563 inline Variant ArrayData::getValue(ssize_t pos) const {
 564   return tvAsCVarRef(rvalPos(pos).tv_ptr());
 565 }
 566
 567 inline Variant ArrayData::getKey(ssize_t pos) const {
 568   auto key = nvGetKey(pos);
 569   return std::move(cellAsVariant(key));
 570 }
 571
 572 ///////////////////////////////////////////////////////////////////////////////
 573
 574 ALWAYS_INLINE bool ArrayData::convertKey(const StringData* key,
 575                                          int64_t& i,
 576                                          bool notice) const {
 577   auto const result = key->isStrictlyInteger(i) && useWeakKeys();
 578   if (UNLIKELY(result && notice)) raise_intish_index_cast();
 579   return result;
 580 }
 581
 582 ///////////////////////////////////////////////////////////////////////////////
 583
 584 }
 585
 586 #endif