String debug_string_backtrace(bool skip, bool ignore_args /* = false */, int64_t limit /* = 0 */) { Array bt; StringBuffer buf; bt = createBacktrace(BacktraceArgs() .skipTop(skip) .ignoreArgs(ignore_args) .setLimit(limit)); int i = 0; for (ArrayIter it = bt.begin(); !it.end(); it.next(), i++) { Array frame = it.second().toArray(); buf.append('#'); buf.append(i); if (i < 10) buf.append(' '); buf.append(' '); if (frame.exists(s_class)) { buf.append(frame->get(s_class).toString()); buf.append(frame->get(s_type).toString()); } buf.append(frame->get(s_function).toString()); buf.append("("); if (!ignore_args) { bool first = true; for (ArrayIter argsIt(frame->get(s_args).toArray()); !argsIt.end(); argsIt.next()) { if (!first) { buf.append(", "); } else { first = false; } try { buf.append(argsIt.second().toString()); } catch (FatalErrorException& fe) { buf.append(fe.getMessage()); } } } buf.append(")"); if (frame.exists(s_file)) { buf.append(" called at ["); buf.append(frame->get(s_file).toString()); buf.append(':'); buf.append(frame->get(s_line).toString()); buf.append(']'); } buf.append('\n'); } return buf.detach(); }
Variant HHVM_FUNCTION(shell_exec, const String& cmd) { ShellExecContext ctx; FILE *fp = ctx.exec(cmd); if (!fp) return init_null(); StringBuffer sbuf; sbuf.read(fp); auto ret = sbuf.detach(); if (ret.empty() && !RuntimeOption::EnableHipHopSyntax) { // Match php5 return init_null(); } return ret; }
bool UrlFile::open(CStrRef url, CStrRef mode) { if (strchr(mode, '+') || strchr(mode, 'a') || strchr(mode, 'w')) { std::string msg = "cannot open a url stream for write/append operation: "; msg += url.c_str(); m_error = msg; return false; } HttpClient http(m_timeout, m_maxRedirect); StringBuffer response; HeaderMap *pHeaders = NULL; HeaderMap requestHeaders; if (!m_headers.empty()) { pHeaders = &requestHeaders; for (ArrayIter iter(m_headers); iter; ++iter) { requestHeaders[string(iter.first().toString().data())]. push_back(iter.second().toString().data()); } } int code; vector<String> responseHeaders; if (m_get) { code = http.get(url.c_str(), response, pHeaders, &responseHeaders); } else { code = http.post(url.c_str(), m_postData.data(), m_postData.size(), response, pHeaders, &responseHeaders); } SystemGlobals *g = (SystemGlobals*)get_global_variables(); Variant &r = g->GV(http_response_header); r = Array::Create(); for (unsigned int i = 0; i < responseHeaders.size(); i++) { r.append(responseHeaders[i]); } if (code == 200) { int len = m_len; m_name = url; m_data = response.detach(len); m_len = len; m_malloced = true; return true; } else { m_error = http.getLastError().c_str(); return false; } }
char *CThorCodeContextBase::getDaliServers() { StringBuffer dali; IGroup &group = queryCoven().queryComm().queryGroup(); Owned<INodeIterator> coven = group.getIterator(); bool first = true; ForEach(*coven) { if (first) first = false; else dali.append(','); coven->query().endpoint().getUrlStr(dali); } return dali.detach(); }
static String normalize_variable_name(const String& name) { StringBuffer sb; for (int i = 0; i < name.size(); i++) { char ch = name.charAt(i); if ((i > 0 && ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z') || (ch == '_')) { sb.append(ch); } else if (ch >= 'A' && ch <= 'Z') { sb.append((char)(ch + 'a' - 'A')); } else { sb.append('_'); } } return sb.detach(); }
String debug_string_backtrace(bool skip, bool ignore_args /* = false */, int limit /* = 0 */) { if (RuntimeOption::InjectedStackTrace) { Array bt; StringBuffer buf; bt = g_vmContext->debugBacktrace(skip, false, false, nullptr, ignore_args, limit); int i = 0; for (ArrayIter it = bt.begin(); !it.end(); it.next(), i++) { Array frame = it.second().toArray(); buf.append('#'); buf.append(i); if (i < 10) buf.append(' '); buf.append(' '); if (frame.exists(s_class)) { buf.append(frame->get(s_class).toString()); buf.append(frame->get(s_type).toString()); } buf.append(frame->get(s_function).toString()); buf.append("("); if (!ignore_args) { bool first = true; for (ArrayIter it = frame->get(s_args).begin(); !it.end(); it.next()) { if (!first) { buf.append(", "); } else { first = false; } buf.append(it.second().toString()); } } buf.append(")"); if (frame.exists(s_file)) { buf.append(" called at ["); buf.append(frame->get(s_file).toString()); buf.append(':'); buf.append(frame->get(s_line).toString()); buf.append(']'); } buf.append('\n'); } return buf.detach(); } else { StackTrace st; return String(st.toString()); } }
std::pair<bool,Variant> DebuggerProxy::ExecutePHP(const std::string &php, String &output, int frame, int flags) { TRACE(2, "DebuggerProxy::ExecutePHP\n"); // Wire up stdout and stderr to our own string buffer so we can pass // any output back to the client. StringBuffer sb; StringBuffer *save = g_context->swapOutputBuffer(nullptr); DebuggerStdoutHook stdout_hook(sb); DebuggerLoggerHook stderr_hook(sb); g_context->setStdout(&stdout_hook); if (flags & ExecutePHPFlagsLog) { Logger::SetThreadHook(&stderr_hook); } SCOPE_EXIT { g_context->setStdout(nullptr); g_context->swapOutputBuffer(save); if (flags & ExecutePHPFlagsLog) { Logger::SetThreadHook(nullptr); } }; String code(php.c_str(), php.size(), CopyString); // We're about to start executing more PHP. This is typically done // in response to commands from the client, and the client expects // those commands to send more interrupts since, of course, the // user might want to debug the code we're about to run. If we're // already processing an interrupt, enable signal polling around // the execution of the new PHP to ensure that we can handle // signals while doing so. // // Note: we must switch the thread mode to Sticky so we block // other threads which may hit interrupts while we're running, // since nested processInterrupt() calls would normally release // other threads on the way out. assertx(m_thread == (int64_t)Process::GetThreadId()); ThreadMode origThreadMode = m_threadMode; switchThreadMode(Sticky, m_thread); if (flags & ExecutePHPFlagsAtInterrupt) enableSignalPolling(); SCOPE_EXIT { if (flags & ExecutePHPFlagsAtInterrupt) disableSignalPolling(); switchThreadMode(origThreadMode, m_thread); }; auto const ret = g_context->evalPHPDebugger(code.get(), frame); output = sb.detach(); return {ret.failed, ret.result}; }
/* Xml encode the passed string. */ String xdebug_xmlize(const char* string, size_t len) { StringBuffer out; for (size_t i = 0; i < len; ++i) { switch (string[i]) { case '&': out.append("&"); break; case '>': out.append(">"); break; case '<': out.append("<"); break; case '"': out.append("""); break; case '\'': out.append("'"); break; case '\n': out.append(" "); break; case '\r': out.append(" "); break; case '\0': out.append("�"); break; default: out.append(string[i]); break; } } return out.detach(); }
static void json_create_zval(Variant &z, StringBuffer &buf, int type) { switch (type) { case KindOfInt64: { const char *p = buf.data(); ASSERT(p); if (p == NULL) { z = 0LL; return; } bool neg = (buf.charAt(0) == '-'); int len = buf.size(); if (neg) len--; if (len >= MAX_LENGTH_OF_LONG - 1) { if (len == MAX_LENGTH_OF_LONG - 1) { int cmp = strcmp(p + (neg ? 1 : 0), long_min_digits); if (!(cmp < 0 || (cmp == 0 && neg))) { z = strtod(p, NULL); return; } } else { z = strtod(p, NULL); return; } } z = strtoll(buf.data(), NULL, 10); } break; case KindOfDouble: z = buf.data() ? strtod(buf.data(), NULL) : 0.0; break; case KindOfString: z = buf.detach(); buf.reset(); break; case KindOfBoolean: z = (buf.data() && (*buf.data() == 't')); break; default: z = null; break; } }
String PageletTransport::getResults( Array &headers, int &code, int64_t timeout_ms ) { { Lock lock(this); while (!m_done && m_pipeline.empty()) { if (timeout_ms > 0) { long seconds = timeout_ms / 1000; long long nanosecs = (timeout_ms % 1000) * 1000000; if (!wait(seconds, nanosecs)) { code = -1; return empty_string(); } } else { wait(); } } if (!m_pipeline.empty()) { // intermediate results do not have headers and code std::string ret = m_pipeline.front(); m_pipeline.pop_front(); code = 0; return ret; } } String response(m_response.c_str(), m_response.size(), CopyString); headers = Array::Create(); for (HeaderMap::const_iterator iter = m_responseHeaders.begin(); iter != m_responseHeaders.end(); ++iter) { for (unsigned int i = 0; i < iter->second.size(); i++) { StringBuffer sb; sb.append(iter->first); sb.append(": "); sb.append(iter->second[i]); headers.append(sb.detach()); } } code = m_code; return response; }
void StringBuffer::absorb(StringBuffer &buf) { if (empty()) { char *buffer = m_buffer; int size = m_size; m_buffer = buf.m_buffer; m_size = buf.m_size; m_pos = buf.m_pos; #ifdef TAINTED propagate_tainting1_bufbuf( buf, *this ); #endif buf.m_buffer = buffer; buf.m_size = size; buf.reset(); } else { append(buf.detach()); } }
void StringBuffer::absorb(StringBuffer &buf) { if (empty()) { TAINT_OBSERVER_REGISTER_ACCESSED(buf.getTaintDataRefConst()); TAINT_OBSERVER_REGISTER_MUTATED(m_taint_data); char *buffer = m_buffer; int size = m_size; m_buffer = buf.m_buffer; m_size = buf.m_size; m_pos = buf.m_pos; buf.m_buffer = buffer; buf.m_size = size; buf.reset(); } else { append(buf.detach()); } }
CachedUnit createUnitFromUrl(const StringData* const requestedPath, const Native::FuncTable& nativeFuncs, FileLoadFlags& flags) { auto const w = Stream::getWrapperFromURI(StrNR(requestedPath)); StringBuffer sb; { // Stream wrappers can reenter PHP via user defined callbacks. Roll this // operation into a single event rqtrace::EventGuard trace{"STREAM_WRAPPER_OPEN"}; rqtrace::DisableTracing disable; if (!w) return CachedUnit{}; auto const f = w->open(StrNR(requestedPath), "r", 0, nullptr); if (!f) return CachedUnit{}; sb.read(f.get()); } OptLog ent; return createUnitFromString(requestedPath->data(), sb.detach(), nullptr, ent, nativeFuncs, RepoOptions::defaults(), flags); }
String getResults(Array &headers, int &code) { { Lock lock(this); while (!m_done) wait(); } String response(m_response.c_str(), m_response.size(), CopyString); headers = Array::Create(); for (HeaderMap::const_iterator iter = m_responseHeaders.begin(); iter != m_responseHeaders.end(); ++iter) { for (unsigned int i = 0; i < iter->second.size(); i++) { StringBuffer sb; sb.append(iter->first); sb.append(": "); sb.append(iter->second[i]); headers.append(sb.detach()); } } code = m_code; return response; }
Variant f_stream_get_contents(CResRef handle, int maxlen /* = -1 */, int offset /* = -1 */) { if (maxlen < -1) { throw_invalid_argument("maxlen: %d", maxlen); return false; } if (maxlen == 0) { return String(); } File *file = handle.getTyped<File>(false /* nullOkay */, true /* badTypeOkay */); if (!file) { throw_invalid_argument( "stream_get_contents() expects parameter 1 to be a resource"); return false; } if (offset >= 0 && !file->seek(offset, SEEK_SET) ) { raise_warning("Failed to seek to position %d in the stream", offset); return false; } String ret; if (maxlen != -1) { ret = String(maxlen, ReserveString); char *buf = ret.bufferSlice().ptr; maxlen = file->readImpl(buf, maxlen); if (maxlen < 0) { return false; } ret.setSize(maxlen); } else { StringBuffer sb; sb.read(file); ret = sb.detach(); } return ret; }
void StringBuffer::absorb(StringBuffer& buf) { if (empty()) { StringData* str = m_str; m_str = buf.m_str; m_len = buf.m_len; m_cap = buf.m_cap; buf.m_str = str; if (str) { buf.m_len = str->size(); buf.m_cap = str->capacity(); } else { buf.m_len = 0; buf.m_cap = 0; } buf.clear(); return; } append(buf.detach()); }
bool CmdExtension::processList(DebuggerProxy *proxy) { IDebuggable::InfoVec info; Array exts = Extension::GetLoadedExtensions(); typedef std::set<std::string, string_lessi> sorted_iset; sorted_iset names; for (ArrayIter iter(exts); iter; ++iter) { names.insert(iter.second().toString().data()); } for (sorted_iset::const_iterator iter = names.begin(); iter != names.end(); ++iter) { Extension *ext = Extension::GetExtension(*iter); ASSERT(ext); if (ext) { int support = ext->debuggerSupport(); string line; line += (support & IDebuggable::SupportInfo) ? "Yes " : " "; line += (support & IDebuggable::SupportDump) ? "Yes " : " "; line += (support & IDebuggable::SupportVerb) ? "Yes " : " "; line += ext->getVersion(); IDebuggable::Add(info, iter->c_str(), line); } } int nameLen; String body = DebuggerClient::FormatInfoVec(info, &nameLen); int hrLen = nameLen + 42; if (hrLen > DebuggerClient::LineWidth) hrLen = DebuggerClient::LineWidth; StringBuffer sb; for (int i = 0; i < hrLen; i++) sb.append(BOX_H); sb.append("\n"); sb.append(StringUtil::Pad("Name\\Support", nameLen)); sb.append("Info Dump Verb Version\n"); for (int i = 0; i < hrLen; i++) sb.append(BOX_H); sb.append("\n"); sb.append(body); for (int i = 0; i < hrLen; i++) sb.append(BOX_H); sb.append("\n"); m_out = sb.detach(); return proxy->send(this); }
Variant DebuggerProxy::ExecutePHP(const std::string &php, String &output, bool log, int frame) { TRACE(2, "DebuggerProxy::ExecutePHP\n"); Variant ret; StringBuffer sb; StringBuffer *save = g_context->swapOutputBuffer(nullptr); g_context->setStdout(append_stdout, &sb); if (log) { Logger::SetThreadHook(append_stderr, &sb); } try { String code(php.c_str(), php.size(), CopyString); g_vmContext->evalPHPDebugger((TypedValue*)&ret, code.get(), frame); } catch (InvalidFunctionCallException &e) { sb.append(Debugger::ColorStderr(String(e.what()))); sb.append(Debugger::ColorStderr( "You may also need to connect to a host " "(e.g., machine connect localhost).")); } catch (Exception &e) { sb.append(Debugger::ColorStderr(String(e.what()))); } catch (Object &e) { try { sb.append(Debugger::ColorStderr(e.toString())); } catch (BadTypeConversionException &e) { sb.append(Debugger::ColorStderr (String("(object without __toString() is thrown)"))); } } catch (...) { sb.append(Debugger::ColorStderr(String("(unknown exception was thrown)"))); } g_context->setStdout(nullptr, nullptr); g_context->swapOutputBuffer(save); if (log) { Logger::SetThreadHook(nullptr, nullptr); } output = sb.detach(); return ret; }
bool CmdExtension::processList(DebuggerProxy &proxy) { IDebuggable::InfoVec info; Array exts = ExtensionRegistry::getLoaded(); std::set<std::string, string_lessi> names; for (ArrayIter iter(exts); iter; ++iter) { names.insert(iter.second().toString().data()); } for (auto const& name : names) { auto ext = ExtensionRegistry::get(name); assert(ext); if (ext) { int support = ext->debuggerSupport(); std::string line; line += (support & IDebuggable::SupportInfo) ? "Yes " : " "; line += (support & IDebuggable::SupportDump) ? "Yes " : " "; line += (support & IDebuggable::SupportVerb) ? "Yes " : " "; line += ext->getVersion(); IDebuggable::Add(info, name.c_str(), line); } } int nameLen; String body = DebuggerClient::FormatInfoVec(info, &nameLen); int hrLen = nameLen + 42; if (hrLen > DebuggerClient::LineWidth) hrLen = DebuggerClient::LineWidth; StringBuffer sb; for (int i = 0; i < hrLen; i++) sb.append(BOX_H); sb.append("\n"); sb.append(StringUtil::Pad("Name\\Support", nameLen)); sb.append("Info Dump Verb Version\n"); for (int i = 0; i < hrLen; i++) sb.append(BOX_H); sb.append("\n"); sb.append(body); for (int i = 0; i < hrLen; i++) sb.append(BOX_H); sb.append("\n"); m_out = sb.detach(); return proxy.sendToClient(this); }
String WddxPacket::wrapValue(const String& start, const String& end, const String& varValue, const String& varName, bool hasVarTag) { StringBuffer valueStr; if (hasVarTag) { valueStr.append("<var name='"); valueStr.append(varName); valueStr.append("'>"); } valueStr.append(start); valueStr.append(varValue); valueStr.append(end); if (hasVarTag) { valueStr.append("</var>"); } return valueStr.detach(); }
bool TestExtProcess::test_proc_open_env_inh() { Array descriptorspec = CREATE_MAP3(0, CREATE_VECTOR2("pipe", "r"), 1, CREATE_VECTOR2("pipe", "w"), 2, CREATE_VECTOR3("file", "/tmp/error-output.txt", "a")); Variant pipes; g_context->setenv("inherit_me", "please"); Variant process = f_proc_open("echo $inherit_me", descriptorspec, ref(pipes)); VERIFY(!same(process, false)); { File *f = pipes[1].toObject().getTyped<File>(); VERIFY(f->valid()); StringBuffer sbuf; sbuf.read(f); f->close(); VS(sbuf.detach(), "please\n"); } VS(f_proc_close(process.toObject()), 0); return Count(true); }
bool TestExtNetwork::test_fsockopen() { { Variant f = f_fsockopen("facebook.com", 80); VERIFY(!same(f, false)); f_fputs(f, "GET / HTTP/1.0\n\n"); VERIFY(!f_fread(f, 15).toString().empty()); } { Variant f = f_fsockopen("ssl://www.facebook.com", 443); VERIFY(!same(f, false)); f_fwrite(f, "GET / HTTP/1.1\r\n" "Host: www.facebook.com\r\n" "Connection: Close\r\n" "\r\n"); StringBuffer response; while (!same(f_feof(f), true)) { Variant line = f_fgets(f, 128); response.append(line.toString()); } VERIFY(!response.detach().empty()); } return Count(true); }
String Eval::location_to_string(const Location *loc) { StringBuffer buf; buf.printf("%s:%d:%d", loc->file, loc->line1, loc->char1); return buf.detach(); }
PhpFile *FileRepository::checkoutFile(StringData *rname, const struct stat &s) { FileInfo fileInfo; PhpFile *ret = nullptr; String name(rname); bool isPlainFile = File::IsPlainFilePath(name); if (isPlainFile) { if (rname->data()[0] != '/') { name = String(SourceRootInfo::GetCurrentSourceRoot()) + name; } // Get the common fast path out of the way with as little locking // as possible: it's in the map and has not changed on disk ParsedFilesMap::const_accessor acc; if (s_files.find(acc, name.get()) && !acc->second->isChanged(s)) { TRACE(1, "FR fast path hit %s\n", rname->data()); ret = acc->second->getPhpFile(); return ret; } } else { // Do the read before we get the repo lock, since it will call into the // stream library and will needs its own locks. if (isAuthoritativeRepo()) { throw FatalErrorException( "including urls doesn't work in RepoAuthoritative mode" ); } Stream::Wrapper* w = Stream::getWrapperFromURI(name); File* f = w->open(name, "r", 0, null_variant); if (!f) return nullptr; StringBuffer sb; sb.read(f); fileInfo.m_inputString = sb.detach(); computeMd5(name.get(), fileInfo); } TRACE(1, "FR fast path miss: %s\n", rname->data()); const StringData *n = makeStaticString(name.get()); PhpFile* toKill = nullptr; SCOPE_EXIT { // run this after acc is destroyed (and its lock released) if (toKill) toKill->decRefAndDelete(); }; ParsedFilesMap::accessor acc; bool isNew = s_files.insert(acc, n); PhpFileWrapper* old = acc->second; SCOPE_EXIT { // run this just before acc is released if (old && old != acc->second) { if (old->getPhpFile() != acc->second->getPhpFile()) { toKill = old->getPhpFile(); } delete old; } if (!acc->second) s_files.erase(acc); }; assert(isNew || old); // We don't leave null entries around. bool isChanged = !isNew && old->isChanged(s); if (isNew || isChanged) { if (isPlainFile && !readFile(n, s, fileInfo)) { TRACE(1, "File disappeared between stat and FR::readNewFile: %s\n", rname->data()); return nullptr; } ret = fileInfo.m_phpFile; if (isChanged && ret == old->getPhpFile()) { // The file changed but had the same contents. if (debug && md5Enabled()) { ReadLock lock(s_md5Lock); assert(s_md5Files.find(ret->getMd5())->second == ret); } return ret; } } else if (!isNew) { // Somebody might have loaded the file between when we dropped // our read lock and got the write lock ret = old->getPhpFile(); return ret; } // If we get here the file was not in s_files or has changed on disk if (!ret) { // Try to read Unit from .hhbc repo. ret = readHhbc(n->data(), fileInfo); } if (!ret) { if (isAuthoritativeRepo()) { raise_error("Tried to parse %s in repo authoritative mode", n->data()); } ret = parseFile(n->data(), fileInfo); if (!ret) return nullptr; } assert(ret != nullptr); if (isNew) { acc->second = new PhpFileWrapper(s, ret); ret->incRef(); ret->setId(Transl::TargetCache::allocBit()); } else { PhpFile *f = old->getPhpFile(); if (f != ret) { ret->setId(f->getId()); ret->incRef(); } acc->second = new PhpFileWrapper(s, ret); } if (md5Enabled()) { WriteLock lock(s_md5Lock); s_md5Files[ret->getMd5()] = ret; } return ret; }
int CDfuPlusHelper::despray() { const char* srcname = globals->queryProp("srcname"); if(srcname == NULL) throw MakeStringException(-1, "srcname not specified"); const char* dstxml = globals->queryProp("dstxml"); const char* dstip = globals->queryProp("dstip"); const char* dstfile = globals->queryProp("dstfile"); bool nowait = globals->getPropBool("nowait", false); MemoryBuffer xmlbuf; if(dstxml == NULL) { if(dstfile == NULL) throw MakeStringException(-1, "dstfile not specified"); if(dstip == NULL) { #ifdef DAFILESRV_LOCAL progress("dstip not specified - assuming spray from local machine\n"); dstip = "."; #else throw MakeStringException(-1, "dstip not specified"); #endif } } else { if(dstip != NULL || dstfile != NULL) throw MakeStringException(-1, "dstip/dstfile and dstxml can't be used at the same time"); StringBuffer buf; buf.loadFile(dstxml); int len = buf.length(); xmlbuf.setBuffer(len, buf.detach(), true); } if(dstxml == NULL) info("\nDespraying %s to host %s file %s\n", srcname, dstip, dstfile); else info("\nDespraying %s\n", srcname); Owned<IClientDespray> req = sprayclient->createDesprayRequest(); req->setSourceLogicalName(srcname); if(dstxml == NULL) { req->setDestIP(dstip); req->setDestPath(dstfile); } else req->setDstxml(xmlbuf); req->setOverwrite(globals->getPropBool("overwrite", false)); if(globals->hasProp("connect")) req->setMaxConnections(globals->getPropInt("connect")); if(globals->hasProp("throttle")) req->setThrottle(globals->getPropInt("throttle")); if(globals->hasProp("transferbuffersize")) req->setTransferBufferSize(globals->getPropInt("transferbuffersize")); if(globals->hasProp("norecover")) req->setNorecover(globals->getPropBool("norecover", false)); else if(globals->hasProp("noRecover")) req->setNorecover(globals->getPropBool("noRecover", false)); if(globals->hasProp("splitprefix")) req->setSplitprefix(globals->queryProp("splitprefix")); else if(globals->hasProp("splitPrefix")) req->setSplitprefix(globals->queryProp("splitPrefix")); if(globals->hasProp("wrap")) req->setWrap(globals->getPropBool("wrap", false)); if(globals->hasProp("multicopy")) req->setMultiCopy(globals->getPropBool("multicopy", false)); else if(globals->hasProp("multiCopy")) req->setMultiCopy(globals->getPropBool("multiCopy", false)); if(globals->hasProp("compress")) req->setCompress(globals->getPropBool("compress", false)); if(globals->hasProp("encrypt")) req->setEncrypt(globals->queryProp("encrypt")); if(globals->hasProp("decrypt")) req->setDecrypt(globals->queryProp("decrypt")); SocketEndpoint localep; StringBuffer localeps; if (checkLocalDaFileSvr(dstip,localep)) dstip = localep.getUrlStr(localeps).str(); Owned<IClientDesprayResponse> result = sprayclient->Despray(req); const char* wuid = result->getWuid(); if(wuid == NULL || *wuid == '\0') exc(result->getExceptions(),"despraying"); else { const char* jobname = globals->queryProp("jobname"); if(jobname && *jobname) updatejobname(wuid, jobname); info("Submitted WUID %s\n", wuid); if(!nowait) waitToFinish(wuid); } return 0; }
String highlight_php(CStrRef source, int line /* = 0 */, int lineFocus0 /* = 0 */, int charFocus0 /* = 0 */, int lineFocus1 /* = 0 */, int charFocus1 /* = 0 */) { StringBuffer res; Scanner scanner(source.data(), source.size(), Scanner::AllowShortTags | Scanner::ReturnAllTokens); ScannerToken tok1, tok2; std::vector<pair<int, string> > ahead_tokens; Location loc1, loc2; const char *colorComment = NULL, *endComment = NULL; get_color(T_COMMENT, 0, 0, colorComment, endComment); int prev = 0; int tokid = scanner.getNextToken(tok1, loc1); int next = 0; while (tokid) { // look ahead next = scanner.getNextToken(tok2, loc2); while (next == T_WHITESPACE || next == T_COMMENT || next == T_DOC_COMMENT) { string text = tok2.text(); string hcolor = check_char_highlight(lineFocus0, charFocus0, lineFocus1, charFocus1, loc2); if (!hcolor.empty()) { text = hcolor + text + ANSI_COLOR_END; } ahead_tokens.push_back(pair<int, string>(next, text)); next = scanner.getNextToken(tok2, loc2); } string hcolor = check_char_highlight(lineFocus0, charFocus0, lineFocus1, charFocus1, loc1); if (tokid < 256) { if (!hcolor.empty()) { res.append(hcolor); res.append((char)tokid); res.append(ANSI_COLOR_END); } else { res.append((char)tokid); } } else { const char *color = NULL, *end = NULL; get_color(tokid, prev, next, color, end); if (!hcolor.empty()) { color = hcolor.c_str(); end = ANSI_COLOR_END; } const std::string &text = tok1.text(); int offset = 0; if (text[0] == '$') { if (!hcolor.empty()) { res.append(hcolor); res.append('$'); res.append(ANSI_COLOR_END); } else { res.append('$'); } offset = 1; } append_line_no(res, text.c_str() + offset, line, color, end, lineFocus0, charFocus0, lineFocus1, charFocus1); } if (!ahead_tokens.empty()) { for (unsigned int i = 0; i < ahead_tokens.size(); i++) { bool comment = ahead_tokens[i].first != T_WHITESPACE; append_line_no(res, ahead_tokens[i].second.c_str(), line, comment ? colorComment : NULL, comment ? endComment : NULL, lineFocus0, charFocus0, lineFocus1, charFocus1); } ahead_tokens.clear(); } if (!(tokid == T_WHITESPACE || tokid == T_COMMENT || tokid == T_DOC_COMMENT)) { prev = tokid; } tok1 = tok2; loc1 = loc2; tokid = next; } append_line_no(res, NULL, line, NULL, NULL, lineFocus0, charFocus0, lineFocus1, charFocus1); return res.detach(); }
String xdebug_xml_return_node(xdebug_xml_node* node) { StringBuffer out; xdebug_xml_return_node_impl(out, node); return out.detach(); }
String DateInterval::format(CStrRef format_spec) { StringBuffer s; for(int i = 0; i < format_spec.length(); i++) { const int MAXLEN = 22; // 64bit signed int string length, plus terminating \0 char buf[MAXLEN]; int l; char c = format_spec.charAt(i); if (c != '%') { s.append(c); continue; } i++; if (i == format_spec.length()) { // End of format, use literal % and finish s.append(c); break; } c = format_spec.charAt(i); switch(c) { case 'Y': l = snprintf(buf, MAXLEN, "%02lld", getYears()); break; case 'y': l = snprintf(buf, MAXLEN, "%lld", getYears()); break; case 'M': l = snprintf(buf, MAXLEN, "%02lld", getMonths()); break; case 'm': l = snprintf(buf, MAXLEN, "%lld", getMonths()); break; case 'D': l = snprintf(buf, MAXLEN, "%02lld", getDays()); break; case 'd': l = snprintf(buf, MAXLEN, "%lld", getDays()); break; case 'H': l = snprintf(buf, MAXLEN, "%02lld", getHours()); break; case 'h': l = snprintf(buf, MAXLEN, "%lld", getHours()); break; case 'I': l = snprintf(buf, MAXLEN, "%02lld", getMinutes()); break; case 'i': l = snprintf(buf, MAXLEN, "%lld", getMinutes()); break; case 'S': l = snprintf(buf, MAXLEN, "%02lld", getSeconds()); break; case 's': l = snprintf(buf, MAXLEN, "%lld", getSeconds()); break; case 'a': if (haveTotalDays()) { l = snprintf(buf, MAXLEN, "%lld", getTotalDays()); } else { l = snprintf(buf, MAXLEN, "(unknown)"); } break; case 'R': l = snprintf(buf, MAXLEN, "%c", isInverted() ? '-' : '+'); break; case 'r': l = snprintf(buf, MAXLEN, "%s", isInverted() ? "-" : ""); break; case '%': default: l = 0; s.append('%'); break; } if (l > 0) { s.append(buf, l); } } return s.detach(); }
String highlight_php(CStrRef source, int line) { Lock lock(Eval::Parser::s_lock); const char *input = source.data(); istringstream iss(input); StringBuffer res; Eval::Scanner scanner(new ylmm::basic_buffer(iss, false, true), true, false, true); Eval::Token tok1, tok2; std::vector<pair<int, Eval::Token> > ahead_tokens; ylmm::basic_location loc; const char *colorComment = NULL, *endComment = NULL; get_color(365 /* T_COMMENT */, 0, 0, colorComment, endComment); int prev = 0; int tokid = scanner.getNextToken(tok1, loc); int next = 0; while (tokid) { // look ahead next = scanner.getNextToken(tok2, loc); while (next == 370 /* T_WHITESPACE */ || next == 365 /* T_COMMENT */ || next == 366 /* T_DOC_COMMENT */) { ahead_tokens.push_back(pair<int, Eval::Token>(next, tok2)); next = scanner.getNextToken(tok2, loc); } if (tokid < 256) { res.append((char)tokid); } else { const char *color = NULL, *end = NULL; get_color(tokid, prev, next, color, end); const std::string &text = tok1.getText(); int offset = 0; if (text[0] == '$') { res.append('$'); offset = 1; } append_line_no(res, text.c_str() + offset, line, color, end); } if (!ahead_tokens.empty()) { for (unsigned int i = 0; i < ahead_tokens.size(); i++) { bool comment = ahead_tokens[i].first != 370 /* T_WHITESPACE */; append_line_no(res, ahead_tokens[i].second.getText().c_str(), line, comment ? colorComment : NULL, comment ? endComment : NULL); } ahead_tokens.clear(); } if (!(tokid == 370 /* T_WHITESPACE */ || tokid == 365 /* T_COMMENT */ || tokid == 366 /* T_DOC_COMMENT */)) { prev = tokid; } tok1 = tok2; tokid = next; } append_line_no(res, NULL, line, NULL, NULL); return res.detach(); }
Variant f_icu_match(CStrRef pattern, CStrRef subject, VRefParam matches /* = null */, int64_t flags /* = 0 */) { UErrorCode status = U_ZERO_ERROR; if (matches.isReferenced()) { matches = Array(); } // Create hash map key by concatenating pattern and flags. StringBuffer bpattern; bpattern.append(pattern); bpattern.append(':'); bpattern.append(flags); String spattern = bpattern.detach(); // Find compiled pattern matcher in hash map or add it. PatternStringMap::accessor accessor; const RegexPattern* rpattern; if (s_patternCacheMap.find(accessor, spattern.get())) { rpattern = accessor->second; } else { // First 32 bits are reserved for ICU-specific flags. rpattern = RegexPattern::compile( UnicodeString::fromUTF8(pattern.data()), (flags & 0xFFFFFFFF), status); if (U_FAILURE(status)) { return false; } if (s_patternCacheMap.insert( accessor, StringData::GetStaticString(spattern.get()))) { accessor->second = rpattern; } else { delete rpattern; rpattern = accessor->second; } } // Build regex matcher from compiled pattern and passed-in subject. UnicodeString usubject = UnicodeString::fromUTF8(subject.data()); boost::scoped_ptr<RegexMatcher> matcher(rpattern->matcher(usubject, status)); if (U_FAILURE(status)) { return false; } // Return 0 or 1 depending on whether or not a match was found and // (optionally), set matched (sub-)patterns for passed-in reference. int matched = 0; if (matcher->find()) { matched = 1; if (matches.isReferenced()) { int32_t count = matcher->groupCount(); for (int32_t i = 0; i <= count; i++) { UnicodeString ustring = matcher->group(i, status); if (U_FAILURE(status)) { return false; } // Convert UnicodeString back to UTF-8. std::string string; ustring.toUTF8String(string); String match = String(string); if (flags & k_UREGEX_OFFSET_CAPTURE) { // start() returns the index in UnicodeString, which // normally means the index into an array of 16-bit // code "units" (not "points"). int32_t start = matcher->start(i, status); if (U_FAILURE(status)) { return false; } start = usubject.countChar32(0, start); matches->append(CREATE_VECTOR2(match, start)); } else { matches->append(match); } } } } return matched; }