bool AbstractCompositeHelpTopic::writeSubTopicList(const HelpWriterContext &context, const std::string &title) const { if (context.outputFormat() != eHelpOutputFormat_Console) { Impl::SubTopicList::const_iterator topic; for (topic = impl_->subTopics_.begin(); topic != impl_->subTopics_.end(); ++topic) { const char *const title = (*topic)->title(); if (!isNullOrEmpty(title)) { context.outputFile().writeLine(); HelpWriterContext subContext(context); subContext.enterSubSection(title); (*topic)->writeHelp(subContext); } } return true; } int maxNameLength = 0; Impl::SubTopicMap::const_iterator topic; for (topic = impl_->subTopicMap_.begin(); topic != impl_->subTopicMap_.end(); ++topic) { const char *const title = topic->second->title(); if (!isNullOrEmpty(title)) { int nameLength = static_cast<int>(topic->first.length()); if (nameLength > maxNameLength) { maxNameLength = nameLength; } } } if (maxNameLength == 0) { return false; } TextWriter &file = context.outputFile(); TextTableFormatter formatter; formatter.addColumn(NULL, maxNameLength + 1, false); formatter.addColumn(NULL, 72 - maxNameLength, true); formatter.setFirstColumnIndent(4); file.writeLine(title); for (topic = impl_->subTopicMap_.begin(); topic != impl_->subTopicMap_.end(); ++topic) { const char *const name = topic->first.c_str(); const char *const title = topic->second->title(); if (!isNullOrEmpty(title)) { formatter.clear(); formatter.addColumnLine(0, name); formatter.addColumnLine(1, title); file.writeString(formatter.formatRow()); } } return true; }
void DataFileFinder::setSearchPathFromEnv(const char *envVarName) { if (!impl_) { impl_.reset(new Impl()); } impl_->envName_ = envVarName; const char *const lib = getenv(envVarName); if (!isNullOrEmpty(lib)) { std::vector<std::string> &path = impl_->searchPath_; // convenience const std::string defaultPath = impl_->getDefaultPath(); std::vector<std::string> tmpPath; Path::splitPathEnvironment(lib, &tmpPath); std::set<std::string> pathsSeen; pathsSeen.insert(defaultPath); for (auto &d : tmpPath) { if (!pathsSeen.count(d)) { path.push_back(d); pathsSeen.insert(d); } } impl_->bEnvIsSet_ = true; } }
bool endsWith(const char *str, const char *suffix) { if (isNullOrEmpty(suffix)) { return true; } const size_t strLength = std::strlen(str); const size_t suffixLength = std::strlen(suffix); return (strLength >= suffixLength && std::strcmp(&str[strLength - suffixLength], suffix) == 0); }
std::string DataFileFinder::Impl::getDefaultPath() { const InstallationPrefixInfo installPrefix = getProgramContext().installationPrefix(); if (!isNullOrEmpty(installPrefix.path)) { const char *const dataPath = installPrefix.bSourceLayout ? "share" : GMX_INSTALL_GMXDATADIR; return Path::join(installPrefix.path, dataPath, "top"); } return std::string(); }
void DataFileFinder::setSearchPathFromEnv(const char *envVarName) { if (!impl_.get()) { impl_.reset(new Impl()); } impl_->envName_ = envVarName; const char *const lib = getenv(envVarName); if (!isNullOrEmpty(lib)) { impl_->bEnvIsSet_ = true; Path::splitPathEnvironment(lib, &impl_->searchPath_); } }
const IR::StructInitializerExpression* StructTypeReplacement::explode( const IR::Expression *root, cstring prefix) { auto vec = new IR::IndexedVector<IR::NamedExpression>(); auto fieldType = ::get(structFieldMap, prefix); BUG_CHECK(fieldType, "No field for %1%", prefix); for (auto f : fieldType->fields) { cstring fieldName = prefix + "." + f->name.name; auto newFieldname = ::get(fieldNameRemap, fieldName); const IR::Expression* expr; if (!newFieldname.isNullOrEmpty()) { expr = new IR::Member(root, newFieldname); } else { expr = explode(root, fieldName); } vec->push_back(new IR::NamedExpression(f->name, expr)); } return new IR::StructInitializerExpression(fieldType->name, *vec, false); }
const IR::Node* ReplaceStructs::postorder(IR::Member* expression) { // Find out if this applies to one of the parameters that are being replaced. const IR::Expression* e = expression; cstring prefix = ""; while (auto mem = e->to<IR::Member>()) { e = mem->expr; prefix = cstring(".") + mem->member + prefix; } auto pe = e->to<IR::PathExpression>(); if (pe == nullptr) return expression; // At this point we know that pe is an expression of the form // param.field1.etc.fieldN, where param has a type that needs to be replaced. auto decl = replacementMap->refMap->getDeclaration(pe->path, true); auto param = decl->to<IR::Parameter>(); if (param == nullptr) return expression; auto repl = ::get(toReplace, param); if (repl == nullptr) return expression; auto newFieldName = ::get(repl->fieldNameRemap, prefix); const IR::Expression* result; if (newFieldName.isNullOrEmpty()) { auto type = replacementMap->typeMap->getType(getOriginal(), true); // This could be, for example, a method like setValid. if (!type->is<IR::Type_Struct>()) return expression; if (getParent<IR::Member>() != nullptr) // We only want to process the outermost Member return expression; // Prefix is a reference to a field of the original struct whose // type is actually a struct itself. We need to replace the field // with a struct initializer expression. (This won't work if the // field is being used as a left-value. Hopefully, all such uses // of a struct-valued field as a left-value have been already // replaced by the NestedStructs pass.) result = repl->explode(pe, prefix); } else { result = new IR::Member(pe, newFieldName); } LOG3("Replacing " << expression << " with " << result); return result; }