bool ArrayData::equal(const ArrayData *v2, bool strict) const {
assert(v2);
if (this == v2) return true;
auto const count1 = size();
auto const count2 = v2->size();
if (count1 != count2) return false;
if (count1 == 0) return true;
// prevent circular referenced objects/arrays or deep ones
DECLARE_THREAD_INFO; check_recursion(info);
if (strict) {
for (ArrayIter iter1(this), iter2(v2); iter1; ++iter1, ++iter2) {
assert(iter2);
if (!same(iter1.first(), iter2.first())
|| !same(iter1.second(), iter2.secondRef())) return false;
}
} else {
for (ArrayIter iter(this); iter; ++iter) {
Variant key(iter.first());
if (!v2->exists(key)) return false;
if (!tvEqual(*iter.second().asTypedValue(),
*v2->get(key).asTypedValue())) {
return false;
}
}
}
return true;
}
bool ArrayData::equal(const ArrayData *v2, bool strict) const {
assert(v2);
int count1 = size();
int count2 = v2->size();
if (count1 != count2) return false;
if (count1 == 0) return true;
// prevent circular referenced objects/arrays or deep ones
DECLARE_THREAD_INFO; check_recursion(info);
if (strict) {
for (ArrayIter iter1(this), iter2(v2); iter1 && iter2; ++iter1, ++iter2) {
Variant key1(iter1.first());
Variant key2(iter2.first());
if (!key1.same(key2)) return false;
Variant value1(iter1.second());
Variant value2(iter2.second());
if (!value1.same(value2)) return false;
}
} else {
for (ArrayIter iter(this); iter; ++iter) {
Variant key(iter.first());
if (!v2->exists(key)) return false;
Variant value1(iter.second());
Variant value2(v2->get(key));
if (!value1.equal(value2)) return false;
}
}
return true;
}
static inline void injection_check(ThreadInfo *&info) {
#ifdef INFINITE_RECURSION_DETECTION
check_recursion(info);
#endif
if (info->m_pendingException) {
throw_pending_exception(info);
}
}
static inline void injection_check(ThreadInfo *info) {
#ifdef INFINITE_RECURSION_DETECTION
check_recursion(info);
#endif
#ifdef REQUEST_TIMEOUT_DETECTION
check_request_timeout(info);
#endif
}
void cook(struct s_node *g) {
char *newname;
int l;
dexpr(g, 0, 0);
cook0(g);
l = strlen(g->text) + strlen("_feed") + 1;
newname = realloc(0, l);
if (!newname) nomem();
strcpy(newname, g->text);
strcat(newname, "_feed");
g->text = newname;
check_recursion(g);
}
/* Compare v to w. Return
-1 if v < w or exception (PyErr_Occurred() true in latter case).
0 if v == w.
1 if v > w.
XXX The docs (C API manual) say the return value is undefined in case
XXX of error.
*/
int
PyObject_Compare(PyObject *v, PyObject *w)
{
PyTypeObject *vtp;
int result;
#if defined(USE_STACKCHECK)
if (PyOS_CheckStack()) {
PyErr_SetString(PyExc_MemoryError, "Stack overflow");
return -1;
}
#endif
if (v == NULL || w == NULL) {
PyErr_BadInternalCall();
return -1;
}
if (v == w)
return 0;
vtp = v->ob_type;
compare_nesting++;
if (compare_nesting > NESTING_LIMIT &&
(vtp->tp_as_mapping
|| (vtp->tp_as_sequence
&& !PyString_Check(v)
&& !PyTuple_Check(v)))) {
/* try to detect circular data structures */
PyObject *token = check_recursion(v, w, -1);
if (token == NULL) {
result = -1;
}
else if (token == Py_None) {
/* already comparing these objects. assume
they're equal until shown otherwise */
result = 0;
}
else {
result = do_cmp(v, w);
delete_token(token);
}
}
else {
result = do_cmp(v, w);
}
compare_nesting--;
return result < 0 ? -1 : result;
}
int ArrayData::compare(const ArrayData *v2) const {
assert(v2);
auto const count1 = size();
auto const count2 = v2->size();
if (count1 < count2) return -1;
if (count1 > count2) return 1;
if (count1 == 0) return 0;
// prevent circular referenced objects/arrays or deep ones
DECLARE_THREAD_INFO; check_recursion(info);
for (ArrayIter iter(this); iter; ++iter) {
auto key = iter.first();
if (!v2->exists(key)) return 1;
auto value1 = iter.second();
auto value2 = v2->get(key);
if (HPHP::more(value1, value2)) return 1;
if (HPHP::less(value1, value2)) return -1;
}
return 0;
}
int ArrayData::compare(const ArrayData *v2) const {
ASSERT(v2);
int count1 = size();
int count2 = v2->size();
if (count1 < count2) return -1;
if (count1 > count2) return 1;
if (count1 == 0) return 0;
// prevent circular referenced objects/arrays or deep ones
DECLARE_THREAD_INFO; check_recursion(info);
for (ArrayIter iter(this); iter; ++iter) {
Variant key(iter.first());
if (!v2->exists(key)) return 1;
Variant value1(iter.second());
Variant value2(v2->get(key));
if (value1.more(value2)) return 1;
if (value1.less(value2)) return -1;
}
return 0;
}
static inline void injection_check(ThreadInfo *info) {
#ifdef INFINITE_RECURSION_DETECTION
check_recursion(info);
#endif
}
Variant ClassConstantExpression::eval(VariableEnvironment &env) const {
DECLARE_THREAD_INFO;
check_recursion(info);
String cls = m_class->get(env);
return get_class_constant(cls, m_constant.c_str());
}
/* Return:
NULL for exception;
some object not equal to NotImplemented if it is implemented
(this latter object may not be a Boolean).
*/
PyObject *
PyObject_RichCompare(PyObject *v, PyObject *w, int op)
{
PyObject *res;
assert(Py_LT <= op && op <= Py_GE);
compare_nesting++;
if (compare_nesting > NESTING_LIMIT &&
(v->ob_type->tp_as_mapping
|| (v->ob_type->tp_as_sequence
&& !PyString_Check(v)
&& !PyTuple_Check(v)))) {
/* try to detect circular data structures */
PyObject *token = check_recursion(v, w, op);
if (token == NULL) {
res = NULL;
goto Done;
}
else if (token == Py_None) {
/* already comparing these objects with this operator.
assume they're equal until shown otherwise */
if (op == Py_EQ)
res = Py_True;
else if (op == Py_NE)
res = Py_False;
else {
PyErr_SetString(PyExc_ValueError,
"can't order recursive values");
res = NULL;
}
Py_XINCREF(res);
}
else {
res = do_richcmp(v, w, op);
delete_token(token);
}
goto Done;
}
/* No nesting extremism.
If the types are equal, and not old-style instances, try to
get out cheap (don't bother with coercions etc.). */
if (v->ob_type == w->ob_type && !PyInstance_Check(v)) {
cmpfunc fcmp;
richcmpfunc frich = RICHCOMPARE(v->ob_type);
/* If the type has richcmp, try it first. try_rich_compare
tries it two-sided, which is not needed since we've a
single type only. */
if (frich != NULL) {
res = (*frich)(v, w, op);
if (res != Py_NotImplemented)
goto Done;
Py_DECREF(res);
}
/* No richcmp, or this particular richmp not implemented.
Try 3-way cmp. */
fcmp = v->ob_type->tp_compare;
if (fcmp != NULL) {
int c = (*fcmp)(v, w);
if (c < 0 && PyErr_Occurred()) {
res = NULL;
goto Done;
}
res = convert_3way_to_object(op, c);
goto Done;
}
}
/* Fast path not taken, or couldn't deliver a useful result. */
res = do_richcmp(v, w, op);
Done:
compare_nesting--;
return res;
}