void traverse(const BenchmarkHeaders &headers, HeaderTraverser &traverser) {
for (HeaderEntry entry = map.begin(); entry != map.end(); ++entry) {
if ((headers.*(entry->second)).is_set) {
traverser.header(entry->first, (headers.*(entry->second)).value);
}
}
}
// implementing RequestHandler
virtual void handleRequest(Transport *transport) {
g_context.getCheck();
HeaderMap headers;
transport->getHeaders(headers);
std::string response;
response = "\nGET param: name = ";
response += transport->getParam("name");
if (transport->getMethod() == Transport::Method::POST) {
int size = 0;
auto const data = (const char *)transport->getPostData(size);
response += "\nPOST data: ";
response += std::string(data, size);
}
for (HeaderMap::const_iterator iter = headers.begin();
iter != headers.end(); ++iter) {
response += "\nHeader: ";
response += iter->first;
for (unsigned int i = 0; i < iter->second.size(); i++) {
response += "\n";
response += folly::to<std::string>(i);
response += ": ";
response += iter->second[i];
}
}
transport->addHeader("Custom", "blah");
transport->sendString(response);
hphp_memory_cleanup();
}
// implementing RequestHandler
virtual void handleRequest(Transport *transport) {
HeaderMap headers;
transport->getHeaders(headers);
string response;
response = "\nGET param: name = ";
response += transport->getParam("name");
if (transport->getMethod() == Transport::POST) {
int size = 0;
const char *data = (const char *)transport->getPostData(size);
response += "\nPOST data: ";
response += string(data, size);
}
for (HeaderMap::const_iterator iter = headers.begin();
iter != headers.end(); ++iter) {
response += "\nHeader: ";
response += iter->first;
for (unsigned int i = 0; i < iter->second.size(); i++) {
response += "\n";
response += lexical_cast<string>(i);
response += ": ";
response += iter->second[i];
}
}
transport->addHeader("Custom", "blah");
transport->sendString(response);
}
string HeaderInterface::headerMapToString( const HeaderMap& h )
{
string headerMap = "";
for ( HeaderMap::const_iterator iter = h.begin(); iter != h.end(); ++iter ) {
headerMap += keyValuePairToString( *iter, ":" ) + sCrLf;
}
return headerMap;
}
GetValue(const char16_t* pKey)
#endif
const
{
HeaderMap* headerMapPtr = reinterpret_cast<HeaderMap*>(mHeaderMap);
EA::WebKit::HeaderMap::iterator itWK = headerMapPtr->find_as(pKey, EA::WebKit::str_iless());
if(itWK != headerMapPtr->end())
return itWK->second.c_str();
return 0;
}
void SavingCtrlObj::HwSavingStream::setCommonHeader(const HeaderMap& headerMap) {
DEB_MEMBER_FUNCT();
if (!headerMap.empty()) {
Group header = Group(m_entry->createGroup("Header"));
for (map<string, string>::const_iterator it = headerMap.begin(); it != headerMap.end(); it++) {
string key = it->first;
string value = it->second;
write_h5_dataset(header, key.c_str(), value);
}
}
}
HeaderMap HeaderInterface::stringToHeaderMap( const string& h )
{
vector<string> tokens;
boost::split( tokens, h, boost::is_any_of( sCrLf ) );
HeaderMap headerMap;
for ( vector<string>::const_iterator iter = tokens.begin(); iter != tokens.end(); ++iter ) {
if ( !iter->empty() ) {
KeyValuePair kvp = stringToKeyValuePair( *iter, ":" );
headerMap.insert( kvp );
}
}
return headerMap;
}
Array f_apache_response_headers() {
Transport *transport = g_context->getTransport();
if (transport) {
HeaderMap headers;
transport->getResponseHeaders(headers);
Array ret;
for (auto iter = headers.begin(); iter != headers.end(); ++iter) {
const auto& values = iter->second;
ret.set(String(iter->first), String(values.back()));
}
return ret;
}
return Array();
}
EASTLHeaderMapWrapper::EASTLHeaderMapWrapperIterator* EASTLHeaderMapWrapper::First()
{
HeaderMap* headerMapPtr = reinterpret_cast<HeaderMap*>(mHeaderMap);
if(headerMapPtr && !headerMapPtr->empty())
{
if(!mHeaderMapWrapperIterator)
mHeaderMapWrapperIterator = EAWEBKIT_NEW("HeaderMapIteratorWrapper") EASTLHeaderMapWrapperIterator();
*(reinterpret_cast<HeaderMap::iterator*>(mHeaderMapWrapperIterator->mIterator)) = headerMapPtr->begin();
return mHeaderMapWrapperIterator;
}
return 0;
}
Array f_apache_request_headers() {
Transport *transport = g_context->getTransport();
if (transport) {
HeaderMap headers;
transport->getHeaders(headers);
Array ret;
for (HeaderMap::const_iterator iter = headers.begin();
iter != headers.end(); ++iter) {
const vector<string> &values = iter->second;
ret.set(String(iter->first), String(values.back()));
}
return ret;
}
return Array();
}
SetValue(const char16_t* pKey, const char16_t* pValue)
#endif
{
HeaderMap* headerMapPtr = reinterpret_cast<HeaderMap*>(mHeaderMap);
EA::WebKit::HeaderMap::iterator itWK = headerMapPtr->find_as(pKey, EA::WebKit::str_iless());
if(itWK != headerMapPtr->end())
{
itWK->second = pValue;
}
else
{
const EA::WebKit::HeaderMap::value_type entry(pKey, pValue);
headerMapPtr->insert(entry);
}
}
EASTLHeaderMapWrapper::EASTLHeaderMapWrapperIterator* EASTLHeaderMapWrapper::GetNext()
{
EAW_ASSERT_MSG(mHeaderMapWrapperIterator, "Please make sure to call EASTLHeaderMapWrapper::First() before this. See header file for documentation.\n");
if(mHeaderMapWrapperIterator)
{
HeaderMap* headerMapPtr = reinterpret_cast<HeaderMap*>(mHeaderMap);
HeaderMap::iterator& headerMapIterator = *(reinterpret_cast<HeaderMap::iterator*>(mHeaderMapWrapperIterator->mIterator));
++headerMapIterator;
if(headerMapIterator != headerMapPtr->end())
return mHeaderMapWrapperIterator;
}
return 0;
}
Array HHVM_FUNCTION(headers_list) {
Transport *transport = g_context->getTransport();
Array ret = Array::Create();
if (transport) {
HeaderMap headers;
transport->getResponseHeaders(headers);
for (HeaderMap::const_iterator iter = headers.begin();
iter != headers.end(); ++iter) {
const std::vector<std::string> &values = iter->second;
for (unsigned int i = 0; i < values.size(); i++) {
ret.append(String(iter->first + ": " + values[i]));
}
}
}
return ret;
}
void SavingCtrlObj::setCommonHeader(const HeaderMap &header)
{
DEB_MEMBER_FUNCT();
std::string cmd = "mxsettings ";
for(HeaderMap::const_iterator i = header.begin();
i != header.end();++i)
{
cmd += i->first;
cmd += ' ';
cmd += i->second;
}
std::string errorMessage = m_cam.sendAnyCommandAndGetErrorMsg(cmd);
if(!errorMessage.empty())
THROW_HW_ERROR(lima::Error) << errorMessage;
}
bool HTTPSocket::OnConnected()
{
std::string request = "GET " + url.request + " HTTP/1.1\r\n";
// Dump headers into the request
HeaderMap headers = req.GetHeaders();
for (HeaderMap::iterator i = headers.begin(); i != headers.end(); i++)
request += i->first + ": " + i->second + "\r\n";
// The Host header is required for HTTP 1.1 and isn't known when the request is created; if they didn't overload it
// manually, add it here
if (headers.find("Host") == headers.end())
request += "Host: " + url.domain + "\r\n";
request += "\r\n";
this->status = HTTP_REQSENT;
return this->Write(request);
}
static Array get_headers(const HeaderMap& headers, bool allHeaders = false) {
ArrayInit ret(headers.size(), ArrayInit::Mixed{});
for (auto& iter : headers) {
const auto& values = iter.second;
if (auto size = values.size()) {
if (!allHeaders) {
ret.set(String(iter.first), String(values.back()));
} else {
PackedArrayInit dups(size);
for (auto& dup : values) {
dups.append(String(dup));
}
ret.set(String(toLower(iter.first)), dups.toArray());
}
}
}
return ret.toArray();
}
Response ConnectionImpl::Request( const std::string & method, const std::string & url, const HeaderMap & header )
{
HeaderMap hm;
hm["Host"] = this->HostName;
hm["Connection"] = "close";
hm.Update( header );
std::ostringstream ossReq( std::ios::binary ); // \r\n を正しく処理するためバイナリとする。
ossReq << method << " " << url << " HTTP/1.1\r\n" << hm.ToString() << "\r\n" << '\0';
this->makeConnection();
this->sendRequest( ossReq.str() );
std::ostringstream ossResult( std::ios::binary );
const int BufferSize = 256;
char buf[BufferSize+1];
// サーバからヘッダ部を受信
while( 1 )
{
int readSize = this->receive( buf, BufferSize );
if( readSize > 0 )
{
buf[readSize] = '\0';
std::string bufStr( buf );
std::string::size_type endOfHeader = bufStr.find( "\r\n\r\n" );
if( endOfHeader == std::string::npos )
{
ossResult.write( buf, readSize );
}
else
{
ossResult.write( buf, readSize );
break;
}
}
else if( readSize == 0 )
{
break;
}
else
{
throw CACOON_EXCEPTION( "recv エラー" );
}
}
std::string respHeaderStr = ossResult.str();
std::string::size_type firstLine = respHeaderStr.find( "\r\n" );
std::string::size_type lastLine = respHeaderStr.find( "\r\n\r\n" );
HeaderMap respHeader( respHeaderStr.substr( firstLine + 2, lastLine - firstLine - 2 ) );
if( respHeader["Transfer-Encoding"] == "chunked" )
{ // サーバから続きを受信 (chunked バージョン)
int chunkSize = 0;
while( 1 )
{
int readSize = this->receive( buf, BufferSize );
if( chunkSize == 0 )
{
if( readSize == 0 )
{
break;
}
buf[readSize-2] = '\0';
chunkSize = strtol( buf, NULL, 16 );
}
else
{
if( readSize > 0 )
{
ossResult.write( buf, readSize );
chunkSize -= readSize;
}
else if( readSize == 0 )
{
break;
}
else
{
throw CACOON_EXCEPTION( "recv エラー" );
}
}
}
}
else
{ // サーバから続きを受信 (普通)
while( 1 )
{
int readSize = this->receive( buf, BufferSize );
if( readSize > 0 )
{
ossResult.write( buf, readSize );
break;
}
else if( readSize == 0 )
{
break;
}
else
{
throw CACOON_EXCEPTION( "recv エラー" );
}
}
}
return Response( ossResult.str() );
}
void Communication::getRawData(const string &_url, const string &method,
string data, const HeaderMap &headers, bool ignoreTimeout){
string url = baseURL + _url;
#ifdef COUCH_DB_ANNOUNCE_URLS
printf("%s %s\n", method.c_str(), url.c_str());
#endif
buffer.clear();
if(curl_easy_setopt(curl, CURLOPT_URL, url.c_str()) != CURLE_OK)
throw Exception("Unable to set URL: " + url);
if(data.size() > 0){
#ifdef COUCH_DB_DEBUG
printf("Sending data: %s\n", data.c_str());
#endif
if(curl_easy_setopt(curl, CURLOPT_READFUNCTION, reader) != CURLE_OK)
throw Exception("Unable to set read function");
if(curl_easy_setopt(curl, CURLOPT_READDATA, &data) != CURLE_OK)
throw Exception("Unable to set data: " + data);
if(curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L) != CURLE_OK)
throw Exception("Unable to set upload request");
if(curl_easy_setopt(curl, CURLOPT_INFILESIZE, (long)data.size()) != CURLE_OK)
throw Exception("Unable to set content size: " + data.size());
}
if(headers.size() > 0 || data.size() > 0){
struct curl_slist *chunk = NULL;
HeaderMap::const_iterator header = headers.begin();
const HeaderMap::const_iterator &headerEnd = headers.end();
for(; header != headerEnd; ++header){
string headerStr = header->first + ": " + header->second;
chunk = curl_slist_append(chunk, headerStr.c_str());
}
if(data.size() > 0 && headers.find("Content-Type") == headers.end())
chunk = curl_slist_append(chunk, "Content-Type: application/json");
if(curl_easy_setopt(curl, CURLOPT_HTTPHEADER, chunk) != CURLE_OK)
throw Exception("Unable to set custom headers");
}
if(curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, method.c_str()) != CURLE_OK)
throw Exception("Unable to set HTTP method: " + method);
CURLcode rc = curl_easy_perform(curl);
if ( !(ignoreTimeout && rc == CURLE_OPERATION_TIMEDOUT) ){
if( rc != CURLE_OK)
throw Exception("Unable to load URL: " + url);
}
if(data.size() > 0 || headers.size() > 0){
if(curl_easy_setopt(curl, CURLOPT_UPLOAD, 0L) != CURLE_OK)
throw Exception("Unable to reset upload request");
if(curl_easy_setopt(curl, CURLOPT_HTTPHEADER, NULL) != CURLE_OK)
throw Exception("Unable to reset custom headers");
}
#ifdef COUCH_DB_DEBUG
long responseCode;
if(curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &responseCode) != CURLE_OK)
throw Exception("Unable to get response code");
printf("Response code: %ld\n", responseCode);
printf("Raw buffer: %s\n", buffer.c_str());
#endif
}
/**
* PHP has "EGPCS" processing order of these global variables, and this
* order is important in preparing $_REQUEST that needs to know which to
* overwrite what when name happens to be the same.
*/
void HttpProtocol::PrepareSystemVariables(Transport *transport,
const RequestURI &r,
const SourceRootInfo &sri) {
SystemGlobals *g = (SystemGlobals*)get_global_variables();
const VirtualHost *vhost = VirtualHost::GetCurrent();
// reset global symbols to nulls or empty arrays
pm_php$globals$symbols_php();
Variant &server = g->GV(_SERVER);
server.set("REQUEST_START_TIME", time(NULL));
// $_ENV
process_env_variables(g->GV(_ENV));
g->GV(_ENV).set("HPHP", 1);
g->GV(_ENV).set("HPHP_SERVER", 1);
#ifdef HOTPROFILER
g->GV(_ENV).set("HPHP_HOTPROFILER", 1);
#endif
Variant &request = g->GV(_REQUEST);
// $_GET and $_REQUEST
if (!r.queryString().empty()) {
DecodeParameters(g->GV(_GET), r.queryString().data(),
r.queryString().size());
CopyParams(request, g->GV(_GET));
}
string contentType = transport->getHeader("Content-Type");
string contentLength = transport->getHeader("Content-Length");
// $_POST and $_REQUEST
if (transport->getMethod() == Transport::POST) {
bool needDelete = false;
int size = 0;
const void *data = transport->getPostData(size);
if (data && size) {
ASSERT(((char*)data)[size] == 0); // we need a NULL terminated string
string boundary;
int content_length = atoi(contentLength.c_str());
bool rfc1867Post = IsRfc1867(contentType, boundary);
string files;
if (rfc1867Post) {
if (content_length > VirtualHost::GetMaxPostSize()) {
// $_POST and $_FILES are empty
Logger::Warning("POST Content-Length of %d bytes exceeds "
"the limit of %lld bytes",
content_length, VirtualHost::GetMaxPostSize());
needDelete = read_all_post_data(transport, data, size);
} else {
if (transport->hasMorePostData()) {
needDelete = true;
data = Util::buffer_duplicate(data, size);
}
DecodeRfc1867(transport, g->GV(_POST), g->GV(_FILES),
content_length, data, size, boundary);
}
ASSERT(!transport->getFiles(files));
} else {
needDelete = read_all_post_data(transport, data, size);
bool decodeData = strncasecmp(contentType.c_str(),
DEFAULT_POST_CONTENT_TYPE,
sizeof(DEFAULT_POST_CONTENT_TYPE)-1) == 0;
// Always decode data for now. (macvicar)
decodeData = true;
if (decodeData) {
DecodeParameters(g->GV(_POST), (const char*)data, size, true);
}
bool ret = transport->getFiles(files);
if (ret) {
g->GV(_FILES) = f_unserialize(files);
}
}
CopyParams(request, g->GV(_POST));
if (needDelete) {
if (RuntimeOption::AlwaysPopulateRawPostData) {
g->GV(HTTP_RAW_POST_DATA) = String((char*)data, size, AttachString);
} else {
free((void *)data);
}
} else {
// For literal we disregard RuntimeOption::AlwaysPopulateRawPostData
g->GV(HTTP_RAW_POST_DATA) = String((char*)data, size, AttachLiteral);
}
}
}
// $_COOKIE
string cookie_data = transport->getHeader("Cookie");
if (!cookie_data.empty()) {
StringBuffer sb;
sb.append(cookie_data);
DecodeCookies(g->GV(_COOKIE), (char*)sb.data());
CopyParams(request, g->GV(_COOKIE));
}
// $_SERVER
// HTTP_ headers -- we don't exclude headers we handle elsewhere (e.g.,
// Content-Type, Authorization), since the CGI "spec" merely says the server
// "may" exclude them; this is not what APE does, but it's harmless.
HeaderMap headers;
transport->getHeaders(headers);
for (HeaderMap::const_iterator iter = headers.begin();
iter != headers.end(); ++iter) {
const vector<string> &values = iter->second;
for (unsigned int i = 0; i < values.size(); i++) {
String key = "HTTP_";
key += StringUtil::ToUpper(iter->first).replace("-", "_");
server.set(key, String(values[i]));
}
}
string host = transport->getHeader("Host");
String hostName(VirtualHost::GetCurrent()->serverName(host));
string hostHeader(host);
if (hostHeader.empty()) {
server.set("HTTP_HOST", hostName);
StackTraceNoHeap::AddExtraLogging("Server", hostName.data());
} else {
StackTraceNoHeap::AddExtraLogging("Server", hostHeader.c_str());
}
if (hostName.empty() || RuntimeOption::ForceServerNameToHeader) {
hostName = hostHeader;
// _SERVER['SERVER_NAME'] shouldn't contain the port number
int colonPos = hostName.find(':');
if (colonPos != String::npos) {
hostName = hostName.substr(0, colonPos);
}
}
// APE sets CONTENT_TYPE and CONTENT_LENGTH without HTTP_
if (!contentType.empty()) {
server.set("CONTENT_TYPE", String(contentType));
}
if (!contentLength.empty()) {
server.set("CONTENT_LENGTH", String(contentLength));
}
// APE processes Authorization: Basic into PHP_AUTH_USER and PHP_AUTH_PW
string authorization = transport->getHeader("Authorization");
if (!authorization.empty()) {
if (strncmp(authorization.c_str(), "Basic ", 6) == 0) {
// it's safe to pass this as a string literal since authorization
// outlives decodedAuth; this saves us a superfluous copy.
String decodedAuth =
StringUtil::Base64Decode(String(authorization.c_str() + 6));
int colonPos = decodedAuth.find(':');
if (colonPos != String::npos) {
server.set("PHP_AUTH_USER", decodedAuth.substr(0, colonPos));
server.set("PHP_AUTH_PW", decodedAuth.substr(colonPos + 1));
}
}
}
server.set("REQUEST_URI", String(transport->getUrl(), CopyString));
server.set("SCRIPT_URL", r.originalURL());
String prefix(transport->isSSL() ? "https://" : "http://");
String port_suffix("");
// Need to append port
if (!transport->isSSL() && RuntimeOption::ServerPort != 80) {
port_suffix = ":" + RuntimeOption::ServerPort;
}
server.set("SCRIPT_URI", String(prefix +
(hostHeader.empty() ?
hostName + port_suffix : hostHeader)
+ r.originalURL()));
if (r.rewritten()) {
// when URL is rewritten, PHP decided to put original URL as SCRIPT_NAME
String name = r.originalURL();
if (!r.pathInfo().empty()) {
int pos = name.find(r.pathInfo());
if (pos >= 0) {
name = name.substr(0, pos);
}
}
if (r.defaultDoc()) {
if (!name.empty() && name[name.length() - 1] != '/') {
name += "/";
}
name += String(RuntimeOption::DefaultDocument);
}
server.set("SCRIPT_NAME", name);
} else {
server.set("SCRIPT_NAME", r.resolvedURL());
}
if (!r.rewritten() && r.pathInfo().empty()) {
server.set("PHP_SELF", r.resolvedURL());
} else {
// when URL is rewritten, or pathinfo is not empty, use original URL
server.set("PHP_SELF", r.originalURL());
}
server.set("SCRIPT_FILENAME", r.absolutePath());
if (r.pathInfo().empty()) {
server.set("PATH_TRANSLATED", r.absolutePath());
} else {
server.set("PATH_TRANSLATED",
String(vhost->getDocumentRoot() + r.pathInfo().data()));
server.set("PATH_INFO", r.pathInfo());
}
server.set("argv", r.queryString());
server.set("argc", 0);
server.set("GATEWAY_INTERFACE", "CGI/1.1");
server.set("SERVER_ADDR", String(RuntimeOption::ServerPrimaryIP));
server.set("SERVER_NAME", hostName);
server.set("SERVER_PORT", RuntimeOption::ServerPort);
server.set("SERVER_SOFTWARE", "HPHP");
server.set("SERVER_PROTOCOL", "HTTP/" + transport->getHTTPVersion());
server.set("SERVER_ADMIN", "");
server.set("SERVER_SIGNATURE", "");
switch (transport->getMethod()) {
case Transport::GET: server.set("REQUEST_METHOD", "GET"); break;
case Transport::HEAD: server.set("REQUEST_METHOD", "HEAD"); break;
case Transport::POST:
if (transport->getExtendedMethod() == NULL) {
server.set("REQUEST_METHOD", "POST");
} else {
server.set("REQUEST_METHOD", transport->getExtendedMethod());
}
break;
default: server.set("REQUEST_METHOD", ""); break;
}
server.set("HTTPS", transport->isSSL() ? "1" : "");
server.set("REQUEST_TIME", time(NULL));
server.set("QUERY_STRING", r.queryString());
server.set("REMOTE_ADDR", String(transport->getRemoteHost(), CopyString));
server.set("REMOTE_HOST", ""); // I don't think we need to nslookup
server.set("REMOTE_PORT", 0); // TODO: quite useless
server.set("DOCUMENT_ROOT", String(vhost->getDocumentRoot()));
for (map<string, string>::const_iterator iter =
RuntimeOption::ServerVariables.begin();
iter != RuntimeOption::ServerVariables.end(); ++iter) {
server.set(String(iter->first), String(iter->second));
}
const map<string, string> &vServerVars = vhost->getServerVars();
for (map<string, string>::const_iterator iter =
vServerVars.begin();
iter != vServerVars.end(); ++iter) {
server.set(String(iter->first), String(iter->second));
}
sri.setServerVariables(server);
const char *threadType = transport->getThreadTypeName();
server.set("THREAD_TYPE", threadType);
StackTraceNoHeap::AddExtraLogging("ThreadType", threadType);
#ifdef TAINTED
taint_array_variant(g->GV(_GET), "$_GET");
taint_array_variant(g->GV(_POST), "$_POST");
taint_array_variant(g->GV(_SERVER), "$_SERVER");
taint_array_variant(g->GV(_COOKIE), "$_COOKIE");
#endif
}
void apply(BenchmarkHeaders &headers, const string &name, const string &string_value) {
HeaderEntry entry = map.find(name);
if (entry != map.end()) {
(headers.*(entry->second)).set(string_value);
}
}
void Tool::HeadermapResolver::
resolve(
Tool::Context *toolContext,
pbxsetting::Environment const &environment,
pbxproj::PBX::Target::shared_ptr const &target
) const
{
/* Add the compiler default environment, which contains the headermap setting defaults. */
pbxsetting::Environment compilerEnvironment = pbxsetting::Environment(environment);
compilerEnvironment.insertFront(_compiler->defaultSettings(), true);
if (!pbxsetting::Type::ParseBoolean(compilerEnvironment.resolve("USE_HEADERMAP"))) {
return;
}
if (pbxsetting::Type::ParseBoolean(compilerEnvironment.resolve("HEADERMAP_USES_VFS"))) {
// TODO(grp): Support VFS-based header maps.
}
HeaderMap targetName;
HeaderMap ownTargetHeaders;
HeaderMap projectHeaders;
HeaderMap allTargetHeaders;
HeaderMap allNonFrameworkTargetHeaders;
bool includeFlatEntriesForTargetBeingBuilt = pbxsetting::Type::ParseBoolean(compilerEnvironment.resolve("HEADERMAP_INCLUDES_FLAT_ENTRIES_FOR_TARGET_BEING_BUILT"));
bool includeFrameworkEntriesForAllProductTypes = pbxsetting::Type::ParseBoolean(compilerEnvironment.resolve("HEADERMAP_INCLUDES_FRAMEWORK_ENTRIES_FOR_ALL_PRODUCT_TYPES"));
bool includeProjectHeaders = pbxsetting::Type::ParseBoolean(compilerEnvironment.resolve("HEADERMAP_INCLUDES_PROJECT_HEADERS"));
// TODO(grp): Populate generated headers.
HeaderMap generatedFiles;
pbxproj::PBX::Project::shared_ptr project = target->project();
std::vector<std::string> headermapSearchPaths = HeadermapSearchPaths(_specManager, compilerEnvironment, target, toolContext->searchPaths(), toolContext->workingDirectory());
for (std::string const &path : headermapSearchPaths) {
Filesystem::GetDefaultUNSAFE()->readDirectory(path, false, [&](std::string const &fileName) -> bool {
// TODO(grp): Use FileTypeResolver when reliable.
std::string extension = FSUtil::GetFileExtension(fileName);
if (extension != "h" && extension != "hpp") {
return true;
}
targetName.add(fileName, path + "/", fileName);
return true;
});
}
for (pbxproj::PBX::FileReference::shared_ptr const &fileReference : project->fileReferences()) {
std::string filePath = compilerEnvironment.expand(fileReference->resolve());
pbxspec::PBX::FileType::shared_ptr fileType = FileTypeResolver::Resolve(Filesystem::GetDefaultUNSAFE(), _specManager, { pbxspec::Manager::AnyDomain() }, fileReference, filePath);
if (fileType == nullptr || (fileType->identifier() != "sourcecode.c.h" && fileType->identifier() != "sourcecode.cpp.h")) {
continue;
}
std::string fileName = FSUtil::GetBaseName(filePath);
std::string fileDirectory = FSUtil::GetDirectoryName(filePath) + "/";
projectHeaders.add(fileName, fileDirectory, fileName);
if (includeProjectHeaders) {
targetName.add(fileName, fileDirectory, fileName);
}
}
for (pbxproj::PBX::Target::shared_ptr const &projectTarget : project->targets()) {
for (pbxproj::PBX::BuildPhase::shared_ptr const &buildPhase : projectTarget->buildPhases()) {
if (buildPhase->type() != pbxproj::PBX::BuildPhase::Type::Headers) {
continue;
}
for (pbxproj::PBX::BuildFile::shared_ptr const &buildFile : buildPhase->files()) {
if (buildFile->fileRef() == nullptr || buildFile->fileRef()->type() != pbxproj::PBX::GroupItem::Type::FileReference) {
continue;
}
pbxproj::PBX::FileReference::shared_ptr const &fileReference = std::static_pointer_cast <pbxproj::PBX::FileReference> (buildFile->fileRef());
std::string filePath = compilerEnvironment.expand(fileReference->resolve());
pbxspec::PBX::FileType::shared_ptr fileType = FileTypeResolver::Resolve(Filesystem::GetDefaultUNSAFE(), _specManager, { pbxspec::Manager::AnyDomain() }, fileReference, filePath);
if (fileType == nullptr || (fileType->identifier() != "sourcecode.c.h" && fileType->identifier() != "sourcecode.cpp.h")) {
continue;
}
std::string fileName = FSUtil::GetBaseName(filePath);
std::string fileDirectory = FSUtil::GetDirectoryName(filePath) + "/";
std::string frameworkName = projectTarget->productName() + "/" + fileName;
std::vector<std::string> const &attributes = buildFile->attributes();
bool isPublic = std::find(attributes.begin(), attributes.end(), "Public") != attributes.end();
bool isPrivate = std::find(attributes.begin(), attributes.end(), "Private") != attributes.end();
if (projectTarget == target) {
ownTargetHeaders.add(fileName, fileDirectory, fileName);
if (!isPublic && !isPrivate) {
ownTargetHeaders.add(frameworkName, fileDirectory, fileName);
if (includeFlatEntriesForTargetBeingBuilt) {
targetName.add(frameworkName, fileDirectory, fileName);
}
}
}
if (isPublic || isPrivate) {
allTargetHeaders.add(frameworkName, fileDirectory, fileName);
if (includeFrameworkEntriesForAllProductTypes) {
targetName.add(frameworkName, fileDirectory, fileName);
}
// TODO(grp): This is a little messy. Maybe check the product type specification, or the product reference's file type?
if (projectTarget->type() == pbxproj::PBX::Target::Type::Native && std::static_pointer_cast<pbxproj::PBX::NativeTarget>(projectTarget)->productType().find("framework") == std::string::npos) {
allNonFrameworkTargetHeaders.add(frameworkName, fileDirectory, fileName);
if (!includeFrameworkEntriesForAllProductTypes) {
targetName.add(frameworkName, fileDirectory, fileName);
}
}
}
}
}
}
std::string headermapFile = compilerEnvironment.resolve("CPP_HEADERMAP_FILE");
std::string headermapFileForOwnTargetHeaders = compilerEnvironment.resolve("CPP_HEADERMAP_FILE_FOR_OWN_TARGET_HEADERS");
std::string headermapFileForAllTargetHeaders = compilerEnvironment.resolve("CPP_HEADERMAP_FILE_FOR_ALL_TARGET_HEADERS");
std::string headermapFileForAllNonFrameworkTargetHeaders = compilerEnvironment.resolve("CPP_HEADERMAP_FILE_FOR_ALL_NON_FRAMEWORK_TARGET_HEADERS");
std::string headermapFileForGeneratedFiles = compilerEnvironment.resolve("CPP_HEADERMAP_FILE_FOR_GENERATED_FILES");
std::string headermapFileForProjectFiles = compilerEnvironment.resolve("CPP_HEADERMAP_FILE_FOR_PROJECT_FILES");
std::vector<Tool::AuxiliaryFile> auxiliaryFiles = {
Tool::AuxiliaryFile::Data(headermapFile, targetName.write()),
Tool::AuxiliaryFile::Data(headermapFileForOwnTargetHeaders, ownTargetHeaders.write()),
Tool::AuxiliaryFile::Data(headermapFileForAllTargetHeaders, allTargetHeaders.write()),
Tool::AuxiliaryFile::Data(headermapFileForAllNonFrameworkTargetHeaders, allNonFrameworkTargetHeaders.write()),
Tool::AuxiliaryFile::Data(headermapFileForGeneratedFiles, generatedFiles.write()),
Tool::AuxiliaryFile::Data(headermapFileForProjectFiles, projectHeaders.write()),
};
toolContext->auxiliaryFiles().insert(toolContext->auxiliaryFiles().end(), auxiliaryFiles.begin(), auxiliaryFiles.end());
std::vector<std::string> systemHeadermapFiles;
std::vector<std::string> userHeadermapFiles;
if (pbxsetting::Type::ParseBoolean(compilerEnvironment.resolve("ALWAYS_SEARCH_USER_PATHS")) && !pbxsetting::Type::ParseBoolean(compilerEnvironment.resolve("ALWAYS_USE_SEPARATE_HEADERMAPS"))) {
systemHeadermapFiles.push_back(headermapFile);
} else {
if (includeFlatEntriesForTargetBeingBuilt) {
systemHeadermapFiles.push_back(headermapFileForOwnTargetHeaders);
}
if (includeFrameworkEntriesForAllProductTypes) {
systemHeadermapFiles.push_back(headermapFileForAllTargetHeaders);
} else {
systemHeadermapFiles.push_back(headermapFileForAllNonFrameworkTargetHeaders);
}
userHeadermapFiles.push_back(headermapFileForGeneratedFiles);
if (includeProjectHeaders) {
userHeadermapFiles.push_back(headermapFileForProjectFiles);
}
}
Tool::HeadermapInfo *headermapInfo = &toolContext->headermapInfo();
headermapInfo->systemHeadermapFiles().insert(headermapInfo->systemHeadermapFiles().end(), systemHeadermapFiles.begin(), systemHeadermapFiles.end());
headermapInfo->userHeadermapFiles().insert(headermapInfo->userHeadermapFiles().end(), userHeadermapFiles.begin(), userHeadermapFiles.end());
}
EraseValue(const char16_t* pKey)
#endif
{
HeaderMap* headerMapPtr = reinterpret_cast<HeaderMap*>(mHeaderMap);
headerMapPtr->erase(pKey);
}
static void dump_headers() {
for (HeaderMap::iterator i = HEADERS.begin(); i != HEADERS.end(); ++i)
printf("Header: %s=%s\n", i->first.c_str(), i->second.c_str());
}
void
VirtualProgram::addShadersToProgram(const ShaderVector& shaders,
const AttribBindingList& attribBindings,
const AttribAliasMap& attribAliases,
osg::Program* program )
{
#ifdef USE_ATTRIB_ALIASES
// apply any vertex attribute aliases. But first, sort them from longest to shortest
// so we don't get any overlap and bad replacements.
AttribAliasVector sortedAliases;
sortedAliases.reserve( attribAliases.size() );
sortedAliases.insert(sortedAliases.begin(), attribAliases.begin(), attribAliases.end());
std::sort( sortedAliases.begin(), sortedAliases.end(), s_attribAliasSortFunc );
for( VirtualProgram::ShaderVector::const_iterator i = shaders.begin(); i != shaders.end(); ++i )
{
osg::Shader* shader = i->get();
applyAttributeAliases( shader, sortedAliases );
}
#endif
// merge the shaders if necessary.
if ( s_mergeShaders )
{
unsigned vertVersion = 0;
HeaderMap vertHeaders;
std::stringstream vertBody;
unsigned fragVersion = 0;
HeaderMap fragHeaders;
std::stringstream fragBody;
// parse the shaders, combining header lines and finding the highest version:
for( VirtualProgram::ShaderVector::const_iterator i = shaders.begin(); i != shaders.end(); ++i )
{
osg::Shader* s = i->get();
if ( s->getType() == osg::Shader::VERTEX )
{
parseShaderForMerging( s->getShaderSource(), vertVersion, vertHeaders, vertBody );
}
else if ( s->getType() == osg::Shader::FRAGMENT )
{
parseShaderForMerging( s->getShaderSource(), fragVersion, fragHeaders, fragBody );
}
}
// write out the merged shader code:
std::string vertBodyText;
vertBodyText = vertBody.str();
std::stringstream vertShaderBuf;
if ( vertVersion > 0 )
vertShaderBuf << "#version " << vertVersion << "\n";
for( HeaderMap::const_iterator h = vertHeaders.begin(); h != vertHeaders.end(); ++h )
vertShaderBuf << h->second << "\n";
vertShaderBuf << vertBodyText << "\n";
vertBodyText = vertShaderBuf.str();
std::string fragBodyText;
fragBodyText = fragBody.str();
std::stringstream fragShaderBuf;
if ( fragVersion > 0 )
fragShaderBuf << "#version " << fragVersion << "\n";
for( HeaderMap::const_iterator h = fragHeaders.begin(); h != fragHeaders.end(); ++h )
fragShaderBuf << h->second << "\n";
fragShaderBuf << fragBodyText << "\n";
fragBodyText = fragShaderBuf.str();
// add them to the program.
program->addShader( new osg::Shader(osg::Shader::VERTEX, vertBodyText) );
program->addShader( new osg::Shader(osg::Shader::FRAGMENT, fragBodyText) );
if ( s_dumpShaders )
{
OE_NOTICE << LC
<< "\nMERGED VERTEX SHADER: \n\n" << vertBodyText << "\n\n"
<< "MERGED FRAGMENT SHADER: \n\n" << fragBodyText << "\n" << std::endl;
}
}
else
{
for( VirtualProgram::ShaderVector::const_iterator i = shaders.begin(); i != shaders.end(); ++i )
{
program->addShader( i->get() );
if ( s_dumpShaders )
OE_NOTICE << LC << "SHADER " << i->get()->getName() << ":\n" << i->get()->getShaderSource() << "\n" << std::endl;
}
}
// add the attribute bindings
for( VirtualProgram::AttribBindingList::const_iterator abl = attribBindings.begin(); abl != attribBindings.end(); ++abl )
{
program->addBindAttribLocation( abl->first, abl->second );
}
}
void
VirtualProgram::addShadersToProgram(const ShaderVector& shaders,
const AttribBindingList& attribBindings,
osg::Program* program )
{
if ( s_mergeShaders )
{
unsigned vertVersion = 0;
HeaderMap vertHeaders;
std::stringstream vertBody;
unsigned fragVersion = 0;
HeaderMap fragHeaders;
std::stringstream fragBody;
// parse the shaders, combining header lines and finding the highest version:
for( VirtualProgram::ShaderVector::const_iterator i = shaders.begin(); i != shaders.end(); ++i )
{
osg::Shader* s = i->get();
if ( s->getType() == osg::Shader::VERTEX )
{
parseShaderForMerging( s->getShaderSource(), vertVersion, vertHeaders, vertBody );
}
else if ( s->getType() == osg::Shader::FRAGMENT )
{
parseShaderForMerging( s->getShaderSource(), fragVersion, fragHeaders, fragBody );
}
}
// write out the merged shader code:
std::string vertBodyText;
vertBodyText = vertBody.str();
std::stringstream vertShaderBuf;
if ( vertVersion > 0 )
vertShaderBuf << "#version " << vertVersion << "\n";
for( HeaderMap::const_iterator h = vertHeaders.begin(); h != vertHeaders.end(); ++h )
vertShaderBuf << h->second << "\n";
vertShaderBuf << vertBodyText << "\n";
vertBodyText = vertShaderBuf.str();
std::string fragBodyText;
fragBodyText = fragBody.str();
std::stringstream fragShaderBuf;
if ( fragVersion > 0 )
fragShaderBuf << "#version " << fragVersion << "\n";
for( HeaderMap::const_iterator h = fragHeaders.begin(); h != fragHeaders.end(); ++h )
fragShaderBuf << h->second << "\n";
fragShaderBuf << fragBodyText << "\n";
fragBodyText = fragShaderBuf.str();
// add them to the program.
program->addShader( new osg::Shader(osg::Shader::VERTEX, vertBodyText) );
program->addShader( new osg::Shader(osg::Shader::FRAGMENT, fragBodyText) );
if ( s_dumpShaders )
{
OE_NOTICE << LC
<< "\nMERGED VERTEX SHADER: \n\n" << vertBodyText << "\n\n"
<< "MERGED FRAGMENT SHADER: \n\n" << fragBodyText << "\n" << std::endl;
}
}
else
{
for( VirtualProgram::ShaderVector::const_iterator i = shaders.begin(); i != shaders.end(); ++i )
{
program->addShader( i->get() );
if ( s_dumpShaders )
OE_NOTICE << LC << "SHADER " << i->get()->getName() << ":\n" << i->get()->getShaderSource() << "\n" << std::endl;
}
}
// add the attribute bindings
for( VirtualProgram::AttribBindingList::const_iterator abl = attribBindings.begin(); abl != attribBindings.end(); ++abl )
{
program->addBindAttribLocation( abl->first, abl->second );
}
}
