Variant f_bzopen(CVarRef filename, CStrRef mode) { if (mode != "r" && mode != "w") { raise_warning( "'%s' is not a valid mode for bzopen(). " "Only 'w' and 'r' are supported.", mode.data() ); return false; } BZ2File *bz; if (filename.isString()) { if (filename.asCStrRef().empty()) { raise_warning("filename cannot be empty"); return false; } bz = NEWOBJ(BZ2File)(); bool ret = bz->open(File::TranslatePath(filename.toString()), mode); if (!ret) { raise_warning("%s", Util::safe_strerror(errno).c_str()); return false; } } else { if (!filename.isResource()) { raise_warning("first parameter has to be string or file-resource"); return false; } PlainFile* f = filename.cast<PlainFile>(); if (!f) { return false; } std::string stream_mode = f->getMode(); int stream_mode_len = stream_mode.length(); if (stream_mode_len != 1 && !(stream_mode_len == 2 && stream_mode.find('b') != string::npos)) { raise_warning("cannot use stream opened in mode '%s'", stream_mode.c_str()); return false; } else if (stream_mode_len == 1 && stream_mode[0] != 'r' && stream_mode[0] != 'w' && stream_mode[0] != 'a' && stream_mode[0] != 'x') { raise_warning("cannot use stream opened in mode '%s'", stream_mode.c_str()); return false; } const char rw_mode = stream_mode[0]; if (mode == "r" && rw_mode != 'r') { raise_warning("cannot write to a stream opened in read only mode"); return false; } else if (mode == "w" && rw_mode != 'w' && rw_mode != 'a' && rw_mode != 'x') { raise_warning("cannot read from a stream opened in write only mode"); return false; } bz = NEWOBJ(BZ2File)(f); } Object handle(bz); return handle; }
string& SourceRootInfo::initPhpRoot() { GlobalVariables *g = get_global_variables(); CVarRef server = g->get(s_SERVER); CVarRef v = server.rvalAt(s_PHP_ROOT); if (v.isString()) { *s_phproot.getCheck() = string(v.asCStrRef().data()) + string("/"); } else { // Our best guess at the source root. *s_phproot.getCheck() = GetCurrentSourceRoot(); } return *s_phproot.getCheck(); }
bool f_stream_is_local(CVarRef stream_or_url) { if (stream_or_url.isString()) { auto wrapper = Stream::getWrapperFromURI(stream_or_url.asCStrRef()); return wrapper->m_isLocal; } else if (stream_or_url.isResource()) { File* file = dynamic_cast<File*>(stream_or_url.asCResRef().get()); if (!file) { raise_warning("supplied resource is not a valid stream resource"); return false; } return file->m_isLocal; } // Zend returns true for random data types... return true; }
Variant Array::rvalAt(CVarRef key, bool error /* = false */, bool isKey /* = false */) const { if (!m_px) return null_variant; switch (key.m_type) { case KindOfNull: return m_px->get(empty_string, error); case KindOfBoolean: case KindOfByte: case KindOfInt16: case KindOfInt32: case KindOfInt64: return m_px->get(key.m_data.num, error); case KindOfDouble: return m_px->get((int64)key.m_data.dbl, error); case KindOfStaticString: case KindOfString: { int64 n; if (!isKey && key.m_data.pstr->isStrictlyInteger(n)) { return m_px->get(n, error); } else { return m_px->get(key.asCStrRef(), error); } } case KindOfArray: throw_bad_type_exception("Invalid type used as key"); break; case KindOfObject: if (key.isResource()) { return m_px->get(key.toInt64(), error); } throw_bad_type_exception("Invalid type used as key"); break; case KindOfVariant: return rvalAt(*(key.m_data.pvar), error, isKey); default: ASSERT(false); break; } return null_variant; }
CVarRef Array::rvalAtRef(CVarRef key, ACCESSPARAMS_IMPL) const { if (!m_px) return null_variant; switch (key.m_type) { case KindOfUninit: case KindOfNull: return m_px->get(empty_string, flags & AccessFlags::Error); case KindOfBoolean: case KindOfInt32: case KindOfInt64: return m_px->get(key.m_data.num, flags & AccessFlags::Error); case KindOfDouble: return m_px->get((int64)key.m_data.dbl, flags & AccessFlags::Error); case KindOfStaticString: case KindOfString: { int64 n; if (!(flags & AccessFlags::Key) && key.m_data.pstr->isStrictlyInteger(n)) { return m_px->get(n, flags & AccessFlags::Error); } else { return m_px->get(key.asCStrRef(), flags & AccessFlags::Error); } } case KindOfArray: throw_bad_type_exception("Invalid type used as key"); break; case KindOfObject: if (key.isResource()) { return m_px->get(key.toInt64(), flags & AccessFlags::Error); } throw_bad_type_exception("Invalid type used as key"); break; case KindOfVariant: return rvalAtRef(*(key.m_data.pvar), flags); default: ASSERT(false); break; } return null_variant; }
void Globals::initialize() { StaticInits *s = s_next_inits; while (s) { const ClassPropTable *cpt = s->table; const int *e = s->entries; int n = *e++; while (n--) { const ClassPropTableEntry *p = cpt->m_entries + *e++; char *addr = (char*)this + p->offset; if (LIKELY(p->isFastInit())) { CVarRef v = cpt->getInitV(p->init_offset); switch (p->type) { case KindOfBoolean: *(bool*)addr = v.asBooleanVal(); break; case KindOfInt64: *(int64*)addr = v.asInt64Val(); break; case KindOfDouble: *(double*)addr = v.asDoubleVal(); break; case KindOfString: *(String*)addr = v.asCStrRef(); break; case KindOfArray: *(Array*)addr = v.asCArrRef(); break; case KindOfVariant: *(Variant*)addr = v; break; default: ASSERT(false); } continue; } CVarRef v = cpt->getInitVal(p); if (LIKELY(p->type == KindOfVariant)) { *(Variant*)addr = v; } else { switch (p->type) { case KindOfBoolean: *(bool*)addr = v; break; case KindOfInt64: *(int64*)addr = v; break; case KindOfDouble: *(double*)addr = v; break; case KindOfString: *(String*)addr = v; break; case KindOfArray: *(Array*)addr = v; break; default: ASSERT(false); } } } s = s->next; } }