static int set_new_kern(fix fval) { unsigned index; av_list L1, L2; L1 = kern_list; if (L1 == NULL) { index = nk++; kern_list = av_list1(index, fval); } else { L2 = L1->ptr; while ((lval(L1) != fval) && (L2 != NULL)) { L1 = L2; L2 = L2->ptr; } if (fval == lval(L1)) { index = lattr(L1); } else { index = nk++; if (index == (ofm_level==OFM_TFM ? 0x8000 : 0x800000)) fatal_error_1("more than %d different kerns", index); L2 = av_list1(index, fval); L1->ptr = L2; } } return index; }
ArrayData *ZendArray::lval(CVarRef k, Variant *&ret, bool copy, bool checkExist /* = false */) { TypedValueAccessor tva = k.getTypedAccessor(); if (isIntKey(tva)) { return lval(getIntKey(tva), ret, copy, checkExist); } else { ASSERT(k.isString()); return lval(k.toStrNR(), ret, copy, checkExist); } }
int UserFile::statImpl(const String& path, struct stat* stat_sb, int flags /* = 0 */) { // array url_stat ( string $path , int $flags ) bool success = false; Variant ret = invoke(m_UrlStat, s_url_stat, make_packed_array(path, flags), success); if (!ret.isArray()) { return -1; } auto a = ret.toArray(); stat_sb->st_dev = a.lval(s_dev).toInt64(); stat_sb->st_ino = a.lval(s_ino).toInt64(); stat_sb->st_mode = a.lval(s_mode).toInt64(); stat_sb->st_nlink = a.lval(s_nlink).toInt64(); stat_sb->st_uid = a.lval(s_uid).toInt64(); stat_sb->st_gid = a.lval(s_gid).toInt64(); stat_sb->st_rdev = a.lval(s_rdev).toInt64(); stat_sb->st_size = a.lval(s_size).toInt64(); stat_sb->st_atime = a.lval(s_atime).toInt64(); stat_sb->st_mtime = a.lval(s_mtime).toInt64(); stat_sb->st_ctime = a.lval(s_ctime).toInt64(); stat_sb->st_blksize = a.lval(s_blksize).toInt64(); stat_sb->st_blocks = a.lval(s_blocks).toInt64(); return 0; }
/* Takes a tuple and binds the i'th element of it to the * i'th name on the rhs of the assignment. */ static Node *destructure(Simp *s, Node *lhs, Node *rhs) { Node *plv, *prv, *lv, *sz, *stor, **args; size_t off, i; args = lhs->expr.args; rhs = rval(s, rhs, NULL); off = 0; for (i = 0; i < lhs->expr.nargs; i++) { lv = lval(s, args[i]); off = tyalign(off, size(lv)); prv = add(addr(s, rhs, exprtype(args[i])), disp(rhs->line, off)); if (stacknode(args[i])) { sz = disp(lhs->line, size(lv)); plv = addr(s, lv, exprtype(lv)); stor = mkexpr(lhs->line, Oblit, plv, prv, sz, NULL); } else { stor = set(lv, load(prv)); } append(s, stor); off += size(lv); } return NULL; }
static Node *assign(Simp *s, Node *lhs, Node *rhs) { Node *t, *u, *v, *r; if (exprop(lhs) == Otup) { r = destructure(s, lhs, rhs); } else { t = lval(s, lhs); u = rval(s, rhs, t); /* if we stored the result into t, rval() should return that, * so we know our work is done. */ if (u == t) { r = t; } else if (stacknode(lhs)) { t = addr(s, t, exprtype(lhs)); u = addr(s, u, exprtype(lhs)); v = disp(lhs->line, size(lhs)); r = mkexpr(lhs->line, Oblit, t, u, v, NULL); } else { r = set(t, u); } } return r; }
/* simplest version */ static AST expr() { Token *t = &tok; switch (t->sym) { case ID: return lval(); case ILIT: return con(); default: return 0; } }
BOOST_FORCEINLINE result_type operator()( A0& a0, A1& a1 ) const { // Copy data in output first x_type x = boost::proto::child_c<0>(a0); y_type y = boost::proto::child_c<1>(a0); size_t l = lval(a0, N0()); polcoefs(a1, x, y, l, N1()); }
static Node *membaddr(Simp *s, Node *n) { Node *t, *u, *r; Node **args; Type *ty; args = n->expr.args; ty = tybase(exprtype(args[0])); if (ty->type == Typtr) { t = lval(s, args[0]); } else { t = addr(s, lval(s, args[0]), exprtype(n)); } u = disp(n->line, offset(args[0], args[1])); r = add(t, u); r->expr.type = mktyptr(n->line, n->expr.type); return r; }
Variant VariableExpression::set(VariableEnvironment &env, CVarRef val) const { Variant &lhs = lval(env); if (RuntimeOption::EnableStrict) { if (!checkCompatibleAssignment(lhs, val)) { throw_strict(TypeVariableChangeException(location_to_string(loc())), StrictMode::StrictHardCore); } } return lhs = val; }
Variant VariableExpression::setOp(VariableEnvironment &env, int op, CVarRef rhs) const { Variant &lhs = lval(env); if (RuntimeOption::EnableStrict) { if (!checkCompatibleAssignment(lhs, rhs)) { throw_strict(TypeVariableChangeException(this->loc()->toString()), StrictMode::StrictHardCore); } } return LvalExpression::setOpVariant(lhs, op, rhs); }
void build_kern_table(void) { av_list L1 = kern_list, L2; unsigned i = 0; kern_table = (fix *) xmalloc((nk+1)*sizeof(int)); while (L1 != NULL) { kern_table[i] = lval(L1); L2 = L1->ptr; free(L1); L1 = L2; i++; } }
void test_unary() { B lval(42); hpx::future<B> f1 = hpx::make_ready_future(B(42)); HPX_TEST(f1.is_ready()); HPX_TEST_EQ(f1.get().i_, 42); hpx::future<B> f2 = hpx::make_ready_future(lval); HPX_TEST(f2.is_ready()); HPX_TEST_EQ(f2.get().i_, 42); hpx::future<B> f3 = hpx::make_ready_future<B>(42); HPX_TEST(f3.is_ready()); HPX_TEST_EQ(f3.get().i_, 42); hpx::future<B&> f4 = hpx::make_ready_future(std::ref(lval)); HPX_TEST(f4.is_ready()); HPX_TEST_EQ(&f4.get().i_, &lval.i_); hpx::future<B&> f5 = hpx::make_ready_future<B&>(lval); HPX_TEST(f5.is_ready()); HPX_TEST_EQ(&f5.get().i_, &lval.i_); }
static Node * destructure(Flattenctx *s, Node *lhs, Node *rhs) { Node *lv, *rv, *idx; Node **args; size_t i; args = lhs->expr.args; rhs = rval(s, rhs); for (i = 0; i < lhs->expr.nargs; i++) { idx = mkintlit(rhs->loc, i); idx->expr.type = mktype(rhs->loc, Tyuint64); rv = mkexpr(rhs->loc, Otupget, rhs, idx, NULL); rv->expr.type = lhs->expr.type; if (exprop(args[i]) == Otup) { destructure(s, args[i], rv); } else { lv = lval(s, args[i]); append(s, assign(s, lv, rv)); } } return rhs; }
ArrayLval APCLocalArray::LvalStr(ArrayData* ad, StringData* k, bool copy) { auto const escalated = Escalate(ad); auto const r = escalated->lval(k, false); return {releaseIfCopied(escalated, r.array), r.val}; }
Variant LvalExpression::refval(VariableEnvironment &env, int strict /* = 2 */) const { return ref(lval(env)); }
void LvalExpression::unset(VariableEnvironment &env) const { lval(env).unset(); }
Variant LvalExpression::setOp(VariableEnvironment &env, int op, CVarRef rhs) const { Variant &lhs = lval(env); return setOpVariant(lhs, op, rhs); }
Variant LvalExpression::set(VariableEnvironment &env, CVarRef val) const { return lval(env) = val; }
bool TestCppBase::TestVariant() { // operators { Variant v(15); v += 20; VERIFY(v.isNumeric()); VERIFY(v.is(KindOfInt64)); VERIFY(v == Variant(35)); } // conversions { Variant v("123"); VERIFY(v.toInt32() == 123); } // offset { Variant v = "test"; VS(v.rvalAt(0), "t"); } { Variant v; v.lvalAt(0) = String("v0"); v.lvalAt(1) = String("v1"); VERIFY(v[0] == "v0"); VERIFY(v[1] == "v1"); } { Variant v; v.lvalAt() = String("test"); VS(v, CREATE_VECTOR1("test")); } { Variant v; v.lvalAt(1) = String("test"); VS(v[1], "test"); VS(v[1.5], "test"); VS(v[Variant(1.5)], "test"); VS(v[s_1], "test"); VS(v[Variant("1")], "test"); } { Variant v; v.lvalAt(Variant(1.5)) = String("test"); VS(v[1], "test"); VS(v[1.5], "test"); VS(v[Variant(1.5)], "test"); VS(v[s_1], "test"); VS(v[Variant("1")], "test"); } { Variant v; v.lvalAt(s_1) = String("test"); VS(v[1], "test"); VS(v[1.5], "test"); VS(v[Variant(1.5)], "test"); VS(v[s_1], "test"); VS(v[Variant("1")], "test"); } { Variant v; v.lvalAt(Variant("1")) = String("test"); VS(v[1], "test"); VS(v[1.5], "test"); VS(v[Variant(1.5)], "test"); VS(v[s_1], "test"); VS(v[Variant("1")], "test"); } // membership { Variant v; v.lvalAt(s_n0) = String("v0"); v.lvalAt(s_n1) = String("v1"); v.remove(s_n1); VS(v, CREATE_MAP1(s_n0, "v0")); v.append("v2"); VS(v, CREATE_MAP2(s_n0, "v0", 0, "v2")); } { Variant v; v.lvalAt(s_n0) = String("v0"); v.lvalAt(1) = String("v1"); v.remove(Variant(1.5)); VS(v, CREATE_MAP1("n0", "v0")); } { Variant v; v.lvalAt(s_n0) = String("v0"); v.lvalAt(1) = String("v1"); v.remove(Variant("1")); VS(v, CREATE_MAP1("n0", "v0")); } { Variant v; v.lvalAt(s_n0) = String("v0"); v.lvalAt(1) = String("v1"); v.remove(String("1")); VS(v, CREATE_MAP1("n0", "v0")); } { Variant v; v.lvalAt(s_n0) = String("v0"); v.lvalAt(empty_string) = String("v1"); v.remove(Variant()); VS(v, CREATE_MAP1("n0", "v0")); } // references { Variant v1("original"); Variant v2 = v1; v2 = String("changed"); VERIFY(v1 == "original"); } { Variant v1("original"); Variant v2 = strongBind(v1); v2 = String("changed"); VERIFY(v1 == "changed"); } { Variant v1 = 10; Variant v2 = Array(ArrayInit(1).setRef(v1).create()); v1 = 20; VS(v2[0], 20); } { Variant v1 = 10; Variant v2; v2.lvalAt() = ref(v1); v1 = 20; VS(v2[0], 20); } { Variant v1 = 10; Variant v2 = CREATE_VECTOR1(5); v2.lvalAt() = ref(v1); v1 = 20; VS(v2[1], 20); } { Variant v1 = 10; Variant v2 = strongBind(v1); v2++; VS(v2, 11); VS(v1, 11); } { Variant arr = CREATE_VECTOR2(1, 2); Variant v; for (MutableArrayIter iter = arr.begin(nullptr, v); iter.advance();) { v++; } VS(arr, CREATE_VECTOR2(2, 3)); } // array escalation { Variant arr; lval(arr.lvalAt(0)).lvalAt(0) = 1.2; VS(arr, CREATE_VECTOR1(CREATE_VECTOR1(1.2))); } { Variant arr; lval(arr.lvalAt(s_name)).lvalAt(0) = 1.2; VS(arr, CREATE_MAP1(s_name, CREATE_VECTOR1(1.2))); } { Variant arr = Array::Create(); lval(arr.lvalAt(0)).lvalAt(0) = 1.2; VS(arr, CREATE_VECTOR1(CREATE_VECTOR1(1.2))); } { Variant arr = Array::Create(); lval(arr.lvalAt(s_name)).lvalAt(0) = 1.2; VS(arr, CREATE_MAP1(s_name, CREATE_VECTOR1(1.2))); } { Variant arr = Array::Create("test"); arr.lvalAt(0) = CREATE_VECTOR1(1.2); VS(arr, CREATE_VECTOR1(CREATE_VECTOR1(1.2))); } { Variant arr = Array::Create("test"); lval(arr.lvalAt(s_name)).lvalAt(0) = 1.2; VS(arr, CREATE_MAP2(0, "test", s_name, CREATE_VECTOR1(1.2))); } return Count(true); }
Variant LvalExpression::setRef(VariableEnvironment &env, CVarRef val) const { return lval(env).assignRef(val); }
ArrayData* NameValueTableWrapper::lval(int64_t k, Variant*& ret, bool copy, bool checkExist) { return lval(String(k), ret, copy, checkExist); }
ArrayData *ArrayData::addLval(StringData* k, Variant *&ret, bool copy) { assert(!exists(k)); return lval(k, ret, copy); }
ArrayData *MapVariant::lval(CStrRef k, Variant *&ret, bool copy, int64 prehash /* = -1 */, bool checkExist /* = false */) { return lval(Variant(k), ret, copy, prehash, checkExist); }
ArrayData *MapVariant::lval(CStrRef k, Variant *&ret, bool copy, int64 prehash /* = -1 */) { return lval(Variant(k), ret, copy, prehash); }
bool LvalExpression::weakLval(VariableEnvironment &env, Variant* &v) const { v = &lval(env); return true; }
bool TestCppBase::TestArray() { // Array::Create(), Array constructors and informational { Array arr; VERIFY(arr.empty()); VERIFY(arr.size() == 0); VERIFY(arr.length() == 0); VERIFY(arr.isNull()); arr = Array::Create(); VERIFY(arr.empty()); VERIFY(arr.size() == 0); VERIFY(arr.length() == 0); VERIFY(!arr.isNull()); arr = Array::Create(0); VERIFY(!arr.empty()); VERIFY(arr.size() == 1); VERIFY(arr.length() == 1); VERIFY(!arr.isNull()); VERIFY((int)arr[0] == 0); VS(arr, Array(ArrayInit(1).set(0).create())); arr = Array::Create("test"); VERIFY(!arr.empty()); VERIFY(arr.size() == 1); VERIFY(arr.length() == 1); VERIFY(!arr.isNull()); VERIFY(arr[0] == "test"); VS(arr, Array(ArrayInit(1).set("test").create())); Array arrCopy = arr; arr = Array::Create(arr); VERIFY(!arr.empty()); VERIFY(arr.size() == 1); VERIFY(arr.length() == 1); VERIFY(!arr.isNull()); VERIFY(arr[0].toArray().size() == 1); VS(arr[0], arrCopy); VS(arr, Array(ArrayInit(1).set(arrCopy).create())); arr = Array::Create("name", 1); VERIFY(!arr.empty()); VERIFY(arr.size() == 1); VERIFY(arr.length() == 1); VERIFY(!arr.isNull()); VERIFY((int)arr[s_name] == 1); VS(arr, Array(ArrayInit(1).set(s_name, 1).create())); arr = Array::Create(s_name, "test"); VERIFY(!arr.empty()); VERIFY(arr.size() == 1); VERIFY(arr.length() == 1); VERIFY(!arr.isNull()); VERIFY(arr[s_name] == "test"); VS(arr, Array(ArrayInit(1).set(s_name, "test").create())); arrCopy = arr; arr = Array::Create(s_name, arr); VERIFY(!arr.empty()); VERIFY(arr.size() == 1); VERIFY(arr.length() == 1); VERIFY(!arr.isNull()); VS(arr[s_name], arrCopy); VERIFY(arr[s_name].toArray().size() == 1); VS(arr, Array(ArrayInit(1).set(s_name, arrCopy).create())); } // iteration { Array arr = CREATE_MAP2("n1", "v1", "n2", "v2"); int i = 0; for (ArrayIter iter = arr.begin(); iter; ++iter, ++i) { if (i == 0) { VERIFY(iter.first() == "n1"); VERIFY(iter.second() == "v1"); } else { VERIFY(iter.first() == "n2"); VERIFY(iter.second() == "v2"); } } VERIFY(i == 2); } /* TODO: fix this { Variant arr = CREATE_MAP2("n1", "v1", "n2", "v2"); arr.escalate(); for (ArrayIterPtr iter = arr.begin(arr, true); !iter->end(); iter->next()){ unset(arr.lvalAt(iter->first())); } VS(arr, Array::Create()); } */ // conversions { Array arr0; VERIFY(arr0.toBoolean() == false); VERIFY(arr0.toByte() == 0); VERIFY(arr0.toInt16() == 0); VERIFY(arr0.toInt32() == 0); VERIFY(arr0.toInt64() == 0); VERIFY(arr0.toDouble() == 0.0); VERIFY(arr0.toString() == ""); Array arr1 = Array::Create("test"); VERIFY(arr1.toBoolean() == true); VERIFY(arr1.toByte() == 1); VERIFY(arr1.toInt16() == 1); VERIFY(arr1.toInt32() == 1); VERIFY(arr1.toInt64() == 1); VERIFY(arr1.toDouble() == 1.0); VERIFY(arr1.toString() == "Array"); } // offset { Array arr; arr.set(0, "v1"); arr.set(1, "v2"); VS(arr, CREATE_VECTOR2("v1", "v2")); } { Array arr; arr.set(s_n1, "v1"); arr.set(s_n2, "v2"); VS(arr, CREATE_MAP2("n1", "v1", "n2", "v2")); } { Array arr; arr.lvalAt(0) = String("v1"); arr.lvalAt(1) = String("v2"); VS(arr, CREATE_VECTOR2("v1", "v2")); } { Array arr; arr.lvalAt(s_n1) = String("v1"); arr.lvalAt(s_n2) = String("v2"); VS(arr, CREATE_MAP2("n1", "v1", "n2", "v2")); } { Array arr; Variant name = "name"; arr.lvalAt(name) = String("value"); VS(arr, CREATE_MAP1("name", "value")); } { Array arr; arr.lvalAt(s_A) = 10; arr.lvalAt(s_A)++; VS(arr[s_A], 11); } { Array arr; arr.lvalAt(1) = 10; VS(arr[1], 10); VS(arr[1.5], 10); VS(arr[Variant(1.5)], 10); VS(arr[s_1], 10); VS(arr[Variant("1")], 10); } { Array arr; arr.lvalAt(Variant(1.5)) = 10; VS(arr[1], 10); VS(arr[1.5], 10); VS(arr[Variant(1.5)], 10); VS(arr[s_1], 10); VS(arr[Variant("1")], 10); } { Array arr; arr.lvalAt(s_1) = 10; VS(arr[1], 10); VS(arr[1.5], 10); VS(arr[Variant(1.5)], 10); VS(arr[s_1], 10); VS(arr[Variant("1")], 10); } { Array arr; arr.lvalAt(Variant("1")) = 10; VS(arr[1], 10); VS(arr[1.5], 10); VS(arr[Variant(1.5)], 10); VS(arr[s_1], 10); VS(arr[Variant("1")], 10); } // membership { Array arr; arr.lvalAt(0) = String("v1"); arr.lvalAt(1) = String("v2"); VERIFY(arr.exists(0)); arr.remove(0); VERIFY(!arr.exists(0)); VS(arr, Array::Create(1, "v2")); arr.append("v3"); VS(arr, CREATE_MAP2(1, "v2", 2, "v3")); } { static const StaticString s_0("0"); Array arr; arr.lvalAt(0) = String("v1"); VERIFY(arr.exists(0)); arr.remove(String(s_0)); VERIFY(!arr.exists(0)); } { Array arr; arr.lvalAt(0) = String("v1"); VERIFY(arr.exists(0)); arr.remove(Variant("0")); VERIFY(!arr.exists(0)); } { Array arr; arr.lvalAt(0) = String("v1"); VERIFY(arr.exists(0)); arr.remove(Variant(Variant("0"))); VERIFY(!arr.exists(0)); } { Array arr; arr.lvalAt(0) = String("v1"); VERIFY(arr.exists(0)); arr.remove(Variant(Variant(0.5))); VERIFY(!arr.exists(0)); } { Array arr; arr.lvalAt(Variant()) = 123; VERIFY(arr.exists(empty_string)); arr.remove(Variant()); VERIFY(!arr.exists(empty_string)); } { Array arr; arr.lvalAt(s_n1) = String("v1"); arr.lvalAt(s_n2) = String("v2"); VERIFY(arr.exists(s_n1)); arr.remove(s_n1); VERIFY(!arr.exists(s_n1)); VS(arr, Array::Create(s_n2, "v2")); arr.append("v3"); VS(arr, CREATE_MAP2("n2", "v2", 0, "v3")); } { Array arr; arr.lvalAt() = String("test"); VS(arr, CREATE_VECTOR1("test")); } { Array arr; arr.lvalAt(s_name) = String("value"); VERIFY(arr.exists(s_name)); } { Array arr; arr.lvalAt(1) = String("value"); VERIFY(arr.exists(1)); VERIFY(arr.exists(1.5)); VERIFY(arr.exists(s_1)); VERIFY(arr.exists(Variant("1"))); VERIFY(arr.exists(Variant(1))); VERIFY(arr.exists(Variant(1.5))); } { Array arr; arr.lvalAt(s_1) = String("value"); VERIFY(arr.exists(1)); VERIFY(arr.exists(1.5)); VERIFY(arr.exists(s_1)); VERIFY(arr.exists(Variant("1"))); VERIFY(arr.exists(Variant(1))); VERIFY(arr.exists(Variant(1.5))); } { Array arr; arr.lvalAt(1.5) = String("value"); VERIFY(arr.exists(1)); VERIFY(arr.exists(1.5)); VERIFY(arr.exists(s_1)); VERIFY(arr.exists(Variant("1"))); VERIFY(arr.exists(Variant(1))); VERIFY(arr.exists(Variant(1.5))); } { Array arr; arr.lvalAt(Variant(1.5)) = String("value"); VERIFY(arr.exists(1)); VERIFY(arr.exists(1.5)); VERIFY(arr.exists(s_1)); VERIFY(arr.exists(Variant("1"))); VERIFY(arr.exists(Variant(1))); VERIFY(arr.exists(Variant(1.5))); } { Array arr; arr.lvalAt(Variant("1")) = String("value"); VERIFY(arr.exists(1)); VERIFY(arr.exists(1.5)); VERIFY(arr.exists(s_1)); VERIFY(arr.exists(Variant("1"))); VERIFY(arr.exists(Variant(1))); VERIFY(arr.exists(Variant(1.5))); } // merge { Array arr = Array::Create(0) + Array::Create(1); VS(arr, Array::Create(0)); arr += CREATE_VECTOR2(0, 1); VS(arr, CREATE_VECTOR2(0, 1)); arr = Array::Create(0).merge(Array::Create(1)); VS(arr, CREATE_VECTOR2(0, 1)); arr = arr.merge(CREATE_VECTOR2(0, 1)); VS(arr, CREATE_VECTOR4(0, 1, 0, 1)); arr = Array::Create("s0").merge(Array::Create("s1")); VS(arr, CREATE_VECTOR2("s0", "s1")); arr = Array::Create("n0", "s0") + Array::Create("n1", "s1"); VS(arr, CREATE_MAP2("n0", "s0", "n1", "s1")); arr += CREATE_MAP2("n0", "s0", "n1", "s1"); VS(arr, CREATE_MAP2("n0", "s0", "n1", "s1")); arr = Array::Create("n0", "s0").merge(Array::Create("n1", "s1")); VS(arr, CREATE_MAP2("n0", "s0", "n1", "s1")); Array arrX = CREATE_MAP2("n0", "s2", "n1", "s3"); arr = arr.merge(arrX); VS(arr, CREATE_MAP2("n0", "s2", "n1", "s3")); } // slice { Array arr = CREATE_VECTOR2("test1", "test2"); Array sub = arr.slice(1, 1, true); VS(sub, CREATE_MAP1(1, "test2")); } { Array arr = CREATE_VECTOR2("test1", "test2"); Array sub = arr.slice(1, 1, false); VS(sub, CREATE_VECTOR1("test2")); } { Array arr = CREATE_MAP2("n1", "test1", "n2", "test2"); Array sub = arr.slice(1, 1, true); VS(sub, CREATE_MAP1("n2", "test2")); } { Array arr = CREATE_MAP2("n1", "test1", "n2", "test2"); Array sub = arr.slice(1, 1, false); VS(sub, CREATE_MAP1("n2", "test2")); } // escalation { Array arr; lval(arr.lvalAt(0)).lvalAt(0) = 1.2; VS(arr, CREATE_VECTOR1(CREATE_VECTOR1(1.2))); } { Array arr; lval(arr.lvalAt(s_name)).lvalAt(0) = 1.2; VS(arr, CREATE_MAP1(s_name, CREATE_VECTOR1(1.2))); } { Array arr = Array::Create(); lval(arr.lvalAt(0)).lvalAt(0) = 1.2; VS(arr, CREATE_VECTOR1(CREATE_VECTOR1(1.2))); } { Array arr = Array::Create(); lval(arr.lvalAt(s_name)).lvalAt(0) = 1.2; VS(arr, CREATE_MAP1(s_name, CREATE_VECTOR1(1.2))); } { Array arr = Array::Create("test"); arr.lvalAt(0) = CREATE_VECTOR1(1.2); VS(arr, CREATE_VECTOR1(CREATE_VECTOR1(1.2))); } { Array arr = Array::Create("test"); lval(arr.lvalAt(s_name)).lvalAt(0) = 1.2; VS(arr, CREATE_MAP2(0, "test", s_name, CREATE_VECTOR1(1.2))); } { Array arr = Array::Create(); arr.append("apple"); arr.set(2, "pear"); VS(arr[2], "pear"); } { Array arr = CREATE_MAP2(0, "a", 1, "b"); VERIFY(arr->isVectorData()); } { Array arr = CREATE_MAP2(1, "a", 0, "b"); VERIFY(!arr->isVectorData()); } { Array arr = CREATE_MAP2(1, "a", 2, "b"); VERIFY(!arr->isVectorData()); } { Array arr = CREATE_MAP1(1, "a"); arr.set(0, "b"); VERIFY(!arr->isVectorData()); } return Count(true); }
ArrayData *ZendArray::lval(litstr k, Variant *&ret, bool copy, bool checkExist /* = false */) { String s(k, AttachLiteral); return lval(s, ret, copy, checkExist); }
ArrayData *ArrayData::addLval(CVarRef k, Variant *&ret, bool copy) { ASSERT(!exists(k)); return lval(k, ret, copy); }
Variant invokeImpl(void *extra, CArrRef params) { const char *function = (const char*)extra; // for TestExtFunction if (strcasecmp(function, "test") == 0) { return params[0]; } // for TestExtPreg::test_preg_replace_callback if (strcasecmp(function, "next_year") == 0) { Array matches = params[0].toArray(); return matches[1].toString() + String(matches[2].toInt32() + 1); } // for TestExtArray::test_array_filter if (strcasecmp(function, "odd") == 0) { return params[0].toInt32() & 1; } if (strcasecmp(function, "even") == 0) { return !(params[0].toInt32() & 1); } // for TestExtArray::test_array_map if (strcasecmp(function, "cube") == 0) { int n = params[0].toInt32(); return n * n * n; } // for TestExtArray::test_array_multisort if (strcasecmp(function, "strtolower") == 0) { return f_strtolower(params[0]); } // for TestExtArray::test_array_reduce if (strcasecmp(function, "rsum") == 0) { int v = params[0].toInt32(); int w = params[1].toInt32(); v += w; return v; } if (strcasecmp(function, "rmul") == 0) { int v = params[0].toInt32(); int w = params[1].toInt32(); v *= w; return v; } // for TestExtArray::test_array_walk_recursive if (strcasecmp(function, "test_print") == 0) { String item = params[0].toString(); String key = params[1].toString(); echo(key + ": " + item + "\n"); } // for TestExtArray::test_array_walk if (strcasecmp(function, "test_alter") == 0) { Variant &item1 = lval(((Array&)params).lvalAt(0)); String key = params[1]; String prefix = params[2]; item1 = prefix + ": " + item1; } // for TestExtArray::test_array_udiff if (strcasecmp(function, "comp_func") == 0) { int n1 = params[0].toInt32(); int n2 = params[1].toInt32(); if (n1 == n2) return 0; return n1 > n2 ? 1 : -1; } // for TestExtArray::test_usort if (strcasecmp(function, "reverse_comp_func") == 0) { int n1 = params[0].toInt32(); int n2 = params[1].toInt32(); if (n1 == n2) return 0; return n1 > n2 ? -1 : 1; } // for TestExtArray::test_array_uintersect if (strcasecmp(function, "strcasecmp") == 0) { String s1 = params[0].toString(); String s2 = params[1].toString(); return strcasecmp(s1.data(), s2.data()); } // for TestExtArray::test_uasort if (strcasecmp(function, "reverse_strcasecmp") == 0) { String s1 = params[0].toString(); String s2 = params[1].toString(); return strcasecmp(s2.data(), s1.data()); } // for TestExtFbml if (strcasecmp(function, "urltr") == 0) { String s1 = params[0].toString(); String s2 = params[1].toString(); return String("url:") + s1 + "=" + s2; } // for TestExtCurl::test_curl_exec if (strcasecmp(function, "curl_write_func") == 0) { print("curl_write_func called with "); print(params[1]); return params[1].toString().size(); } // for TestExtPreg::test_preg_replace if (strcasecmp(function, "strtoupper") == 0) { return f_strtoupper(params[0].toString()); } if (strcasecmp(function, "test_preg_rep") == 0) { return test_preg_rep(params[0].toString(), params[1].toString(), params[2].toString()); } if (strcasecmp(function, "sprintf") == 0) { return f_sprintf(params.size(), params[0], params.slice(1, params.size() - 1, false)); } // for TestExtSqlite3::test_sqlite3 if (strcasecmp(function, "lower") == 0) { return f_strtolower(params[0]); } if (strcasecmp(function, "sumlen_step") == 0) { return params[0].toInt64() + f_strlen(params[2]); } if (strcasecmp(function, "sumlen_fini") == 0) { return params[0].toInt64(); } // for TestExtSoap if (strcasecmp(function, "hello") == 0) { return "Hello World"; } if (strcasecmp(function, "add") == 0) { return params[0].toInt32() + params[1].toInt32(); } if (strcasecmp(function, "sub") == 0) { return params[0].toInt32() - params[1].toInt32(); } if (strcasecmp(function, "sum") == 0) { int sum = 0; for (ArrayIter iter(params[0]); iter; ++iter) { sum += iter.second().toInt32(); } return sum; } if (strcasecmp(function, "strlen") == 0) { return f_strlen(params[0]); } if (strcasecmp(function, "fault") == 0) { return Object((NEW(c_SoapFault)())->create("MyFault","My fault string")); } // for TestExtServer if (strcasecmp(function, "xbox_process_message") == 0) { return StringUtil::Reverse(params[0]); } return true; }
ArrayData *GlobalArrayWrapper::lval(int64 k, Variant *&ret, bool copy, bool checkExist /* = false */) { return lval(String(k), ret, copy); }