void expand_tilde(wcstring &input)
{
if (! input.empty() && input.at(0) == L'~')
{
input.at(0) = HOME_DIRECTORY;
expand_home_directory(input);
}
}
int expand_string(const wcstring &input, std::vector<completion_t> &output, expand_flags_t flags)
{
parser_t parser(PARSER_TYPE_ERRORS_ONLY, true /* show errors */);
std::vector<completion_t> list1, list2;
std::vector<completion_t> *in, *out;
size_t i;
int res = EXPAND_OK;
if ((!(flags & ACCEPT_INCOMPLETE)) && expand_is_clean(input.c_str()))
{
output.push_back(completion_t(input));
return EXPAND_OK;
}
if (EXPAND_SKIP_CMDSUBST & flags)
{
wchar_t *begin, *end;
if (parse_util_locate_cmdsubst(input.c_str(),
&begin,
&end,
1) != 0)
{
parser.error(CMDSUBST_ERROR, -1, L"Command substitutions not allowed");
return EXPAND_ERROR;
}
list1.push_back(completion_t(input));
}
else
{
int cmdsubst_ok = expand_cmdsubst(parser, input, list1);
if (! cmdsubst_ok)
return EXPAND_ERROR;
}
in = &list1;
out = &list2;
for (i=0; i < in->size(); i++)
{
/*
We accept incomplete strings here, since complete uses
expand_string to expand incomplete strings from the
commandline.
*/
int unescape_flags = UNESCAPE_SPECIAL | UNESCAPE_INCOMPLETE;
wcstring next = expand_unescape_string(in->at(i).completion, unescape_flags);
if (EXPAND_SKIP_VARIABLES & flags)
{
for (size_t i=0; i < next.size(); i++)
{
if (next.at(i) == VARIABLE_EXPAND)
{
next[i] = L'$';
}
}
out->push_back(completion_t(next));
}
else
{
if (!expand_variables2(parser, next, *out, next.size() - 1))
{
return EXPAND_ERROR;
}
}
}
in->clear();
in = &list2;
out = &list1;
for (i=0; i < in->size(); i++)
{
wcstring next = in->at(i).completion;
if (!expand_brackets(parser, next, flags, *out))
{
return EXPAND_ERROR;
}
}
in->clear();
in = &list1;
out = &list2;
for (i=0; i < in->size(); i++)
{
wcstring next = in->at(i).completion;
expand_home_directory(next);
if (flags & ACCEPT_INCOMPLETE)
{
if (next[0] == PROCESS_EXPAND)
{
/*
If process expansion matches, we are not
interested in other completions, so we
short-circut and return
*/
if (!(flags & EXPAND_SKIP_PROCESS))
expand_pid(next, flags, output);
return EXPAND_OK;
}
else
{
out->push_back(completion_t(next));
}
}
else
{
if (!(flags & EXPAND_SKIP_PROCESS) && ! expand_pid(next, flags, *out))
{
return EXPAND_ERROR;
}
}
}
in->clear();
in = &list2;
out = &list1;
for (i=0; i < in->size(); i++)
{
wcstring next_str = in->at(i).completion;
int wc_res;
remove_internal_separator(next_str, (EXPAND_SKIP_WILDCARDS & flags) ? true : false);
const wchar_t *next = next_str.c_str();
if (((flags & ACCEPT_INCOMPLETE) && (!(flags & EXPAND_SKIP_WILDCARDS))) ||
wildcard_has(next, 1))
{
const wchar_t *start, *rest;
std::vector<completion_t> *list = out;
if (next[0] == '/')
{
start = L"/";
rest = &next[1];
}
else
{
start = L"";
rest = next;
}
if (flags & ACCEPT_INCOMPLETE)
{
list = &output;
}
wc_res = wildcard_expand_string(rest, start, flags, *list);
if (!(flags & ACCEPT_INCOMPLETE))
{
switch (wc_res)
{
case 0:
{
if (!(flags & ACCEPT_INCOMPLETE))
{
if (res == EXPAND_OK)
res = EXPAND_WILDCARD_NO_MATCH;
break;
}
}
case 1:
{
size_t j;
res = EXPAND_WILDCARD_MATCH;
sort_completions(*out);
for (j=0; j< out->size(); j++)
{
output.push_back(out->at(j));
}
out->clear();
break;
}
case -1:
{
return EXPAND_ERROR;
}
}
}
}
else
{
if (flags & ACCEPT_INCOMPLETE)
{
}
else
{
output.push_back(completion_t(next));
}
}
}
return res;
}
std::string uhd::get_images_dir(const std::string &search_paths) {
/* This function will check for the existence of directories in this
* order:
*
* 1) `UHD_IMAGES_DIR` environment variable
* 2) Any paths passed to this function via `search_paths' (may contain
* Windows registry keys)
* 3) `UHD package path` / share / uhd / images
*/
std::string possible_dir;
/* We will start by looking for a path indicated by the `UHD_IMAGES_DIR`
* environment variable. */
std::vector<std::string> env_paths = get_env_paths("UHD_IMAGES_DIR");
for(auto possible_dir: env_paths) {
if (fs::is_directory(fs::path(possible_dir))) {
return possible_dir;
}
}
/* On Windows systems, we may need to modify the `search_paths` parameter
* (see below). Making a local copy for const correctness. */
std::string _search_paths = search_paths;
#ifdef UHD_IMAGES_DIR_WINREG_KEY
_search_paths = std::string(STR(UHD_IMAGES_DIR_WINREG_KEY)) + "," + search_paths;
#endif
/* Now we will parse and attempt to qualify the paths in the `search_paths`
* parameter. If this is Windows, we will check the system registry for
* these strings. */
if (!_search_paths.empty()) {
std::vector<std::string> search_paths_vector;
boost::split(search_paths_vector, _search_paths, boost::is_any_of(",;"));
for(std::string& search_path: search_paths_vector) {
boost::algorithm::trim(search_path);
if (search_path.empty()) continue;
#ifdef UHD_PLATFORM_WIN32
possible_dir = _get_images_path_from_registry(search_path);
if (possible_dir.empty()) {
//Could not read from the registry due to missing key, invalid
//values, etc Just use the search path. The is_directory check
//will fail if this is a registry path and we will move on to
//the next item in the list.
possible_dir = search_path;
}
#else
possible_dir = expand_home_directory(search_path);
#endif
if (fs::is_directory(fs::path(possible_dir))) {
return possible_dir;
}
}
}
/* Finally, check for the default UHD images installation path. */
fs::path pkg_path = fs::path(uhd::get_pkg_path()) / "share" / "uhd" / "images";
if (fs::is_directory(pkg_path)) {
return pkg_path.string();
} else {
/* No luck. Return an empty string. */
return std::string("");
}
}
