{

const wchar_t * str = in;

CHECK(in, 1);

/*

if (wcschr(UNCLEAN_FIRST, *str))

return 0;

/*

while (*str)

{

if (wcschr(UNCLEAN, *str))

return 0;

str++;

}

return 1;

{

if (!in)

return env_var_t::missing_var();

return env_get_string(in);

{

switch (*str)

{

case 0:

return 1;

case L'\n':

case L'\t':

case L'\r':

case L'\b':

case L'\x1b':

return 0;

default:

return is_quotable(str+1);

}

return 0;

{

wcstring_list_t lst;

wcstring buff;

tokenize_variable_array(in, lst);

switch (lst.size())

{

case 0:

buff.append(L"''");

break;

case 1:

{

const wcstring &el = lst.at(0);

if (el.find(L' ') != wcstring::npos && is_quotable(el))

{

buff.append(L"'");

buff.append(el);

buff.append(L"'");

}

else

{

buff.append(escape_string(el, 1));

}

break;

}

default:

{

for (size_t j=0; j<lst.size(); j++)

{

const wcstring &el = lst.at(j);

if (j)

buff.append(L" ");

if (is_quotable(el))

{

buff.append(L"'");

buff.append(el);

buff.append(L"'");

}

else

{

buff.append(escape_string(el, 1));

}

}

}

}

return buff;

{

for (; *n; n++)

{

if (*n < L'0' || *n > L'9')

{

return 0;

}

}

return 1;

const wchar_t *proc,

int flags,

size_t *offset)

{

/* Test for a direct match. If the proc string is empty (e.g. the user tries to complete against %), then return an offset pointing at the base command. That ensures that you don't see a bunch of dumb paths when completing against all processes. */

if (proc[0] != L'\0' && wcsncmp(cmd.c_str(), proc, wcslen(proc)) == 0)

{

if (offset)

*offset = 0;

return true;

}

/* Get the command to match against. We're only interested in the last path component. */

const wcstring base_cmd = wbasename(cmd);

bool result = string_prefixes_string(proc, base_cmd);

if (result)

{

/* It's a match. Return the offset within the full command. */

if (offset)

*offset = cmd.size() - base_cmd.size();

}

return result;

{

std::vector<pid_t> pids;

size_t idx;

wcstring name_for_pid(pid_t pid);

process_iterator_t();

bool next_process(wcstring *str, pid_t *pid);

{

wcstring result;

int mib[4], maxarg = 0, numArgs = 0;

size_t size = 0;

char *args = NULL, *stringPtr = NULL;

mib[0] = CTL_KERN;

mib[1] = KERN_ARGMAX;

size = sizeof(maxarg);

if (sysctl(mib, 2, &maxarg, &size, NULL, 0) == -1)

{

return result;

}

args = (char *)malloc(maxarg);

if (args == NULL)

{

return result;

}

mib[0] = CTL_KERN;

mib[1] = KERN_PROCARGS2;

mib[2] = pid;

size = (size_t)maxarg;

if (sysctl(mib, 3, args, &size, NULL, 0) == -1)

{

free(args);

return result;;

}

memcpy(&numArgs, args, sizeof(numArgs));

stringPtr = args + sizeof(numArgs);

result = str2wcstring(stringPtr);

free(args);

return result;

{

wcstring name;

pid_t pid = 0;

bool result = false;

while (idx < pids.size())

{

pid = pids.at(idx++);

name = name_for_pid(pid);

if (! name.empty())

{

result = true;

break;

}

}

if (result)

{

*out_str = name;

*out_pid = pid;

}

return result;

{

int err;

struct kinfo_proc * result;

bool done;

static const int name[] = { CTL_KERN, KERN_PROC, KERN_PROC_ALL, 0 };

// Declaring name as const requires us to cast it when passing it to

// sysctl because the prototype doesn't include the const modifier.

size_t length;

// We start by calling sysctl with result == NULL and length == 0.

// That will succeed, and set length to the appropriate length.

// We then allocate a buffer of that size and call sysctl again

// with that buffer. If that succeeds, we're done. If that fails

// with ENOMEM, we have to throw away our buffer and loop. Note

// that the loop causes use to call sysctl with NULL again; this

// is necessary because the ENOMEM failure case sets length to

// the amount of data returned, not the amount of data that

// could have been returned.

result = NULL;

done = false;

do

{

assert(result == NULL);

// Call sysctl with a NULL buffer.

length = 0;

err = sysctl((int *) name, (sizeof(name) / sizeof(*name)) - 1,

NULL, &length,

NULL, 0);

if (err == -1)

{

err = errno;

}

// Allocate an appropriately sized buffer based on the results

// from the previous call.

if (err == 0)

{

result = (struct kinfo_proc *)malloc(length);

if (result == NULL)

{

err = ENOMEM;

}

}

// Call sysctl again with the new buffer. If we get an ENOMEM

// error, toss away our buffer and start again.

if (err == 0)

{

err = sysctl((int *) name, (sizeof(name) / sizeof(*name)) - 1,

result, &length,

NULL, 0);

if (err == -1)

{

err = errno;

}

if (err == 0)

{

done = true;

}

else if (err == ENOMEM)

{

assert(result != NULL);

free(result);

result = NULL;

err = 0;

}

}

}

while (err == 0 && ! done);

// Clean up and establish post conditions.

if (err == 0 && result != NULL)

{

for (size_t idx = 0; idx < length / sizeof(struct kinfo_proc); idx++)

pids.push_back(result[idx].kp_proc.p_pid);

}

if (result)

free(result);

{

DIR *dir;

process_iterator_t();

~process_iterator_t();

bool next_process(wcstring *out_str, pid_t *out_pid);

{

wcstring cmd;

pid_t pid = 0;

while (cmd.empty())

{

wcstring name;

if (! dir || ! wreaddir(dir, name))

break;

if (!iswnumeric(name.c_str()))

continue;

wcstring path = wcstring(L"/proc/") + name;

struct stat buf;

if (wstat(path, &buf))

continue;

if (buf.st_uid != getuid())

continue;

/* remember the pid */

pid = fish_wcstoi(name.c_str(), NULL, 10);

/* the 'cmdline' file exists, it should contain the commandline */

FILE *cmdfile;

if ((cmdfile=wfopen(path + L"/cmdline", "r")))

{

wcstring full_command_line;

fgetws2(&full_command_line, cmdfile);

/* The command line needs to be escaped */

cmd = tok_first(full_command_line.c_str());

}

#ifdef SunOS

else if ((cmdfile=wfopen(path + L"/psinfo", "r")))

{

psinfo_t info;

if (fread(&info, sizeof(info), 1, cmdfile))

{

/* The filename is unescaped */

cmd = str2wcstring(info.pr_fname);

}

}

#endif

if (cmdfile)

fclose(cmdfile);

}

bool result = ! cmd.empty();

if (result)

{

*out_str = cmd;

*out_pid = pid;

}

return result;

{

wcstring name;

pid_t pid;

process_iterator_t iterator;

std::vector<wcstring> result;

while (iterator.next_process(&name, &pid))

{

result.push_back(name);

}

return result;

{

const wchar_t *proc; /* The process to search for - possibly numeric, possibly a name */

expand_flags_t flags;

std::vector<completion_t> *completions;

{

ASSERT_IS_MAIN_THREAD();

const wchar_t * const proc = info->proc;

const expand_flags_t flags = info->flags;

std::vector<completion_t> &completions = *info->completions;

const job_t *j;

int found = 0;

// do the empty param check first, because an empty string passes our 'numeric' check

if (wcslen(proc)==0)

{

/*

job_iterator_t jobs;

while ((j = jobs.next()))

{

if (!j->command_is_empty())

{

append_completion(completions, to_string<long>(j->pgid));

break;

}

}

/*

found = 1;

}

else if (iswnumeric(proc))

{

/*

if (flags & ACCEPT_INCOMPLETE)

{

job_iterator_t jobs;

while ((j = jobs.next()))

{

wchar_t jid[16];

if (j->command_is_empty())

continue;

swprintf(jid, 16, L"%d", j->job_id);

if (wcsncmp(proc, jid, wcslen(proc))==0)

{

wcstring desc_buff = format_string(COMPLETE_JOB_DESC_VAL, j->command_wcstr());

append_completion(completions,

jid+wcslen(proc),

desc_buff,

0);

}

}

}

else

{

int jid;

wchar_t *end;

errno = 0;

jid = fish_wcstoi(proc, &end, 10);

if (jid > 0 && !errno && !*end)

{

j = job_get(jid);

if ((j != 0) && (j->command_wcstr() != 0) && (!j->command_is_empty()))

{

append_completion(completions, to_string<long>(j->pgid));

}

}

}

/*

found = 1;

}

if (! found)

{

job_iterator_t jobs;

while ((j = jobs.next()))

{

if (j->command_is_empty())

continue;

size_t offset;

if (match_pid(j->command(), proc, flags, &offset))

{

if (flags & ACCEPT_INCOMPLETE)

{

append_completion(completions,

j->command_wcstr() + offset + wcslen(proc),

COMPLETE_JOB_DESC,

0);

}

else

{

append_completion(completions, to_string<long>(j->pgid));

found = 1;

}

}

}

if (! found)

{

jobs.reset();

while ((j = jobs.next()))

{

process_t *p;

if (j->command_is_empty())

continue;

for (p=j->first_process; p; p=p->next)

{

if (p->actual_cmd.empty())

continue;

size_t offset;

if (match_pid(p->actual_cmd, proc, flags, &offset))

{

if (flags & ACCEPT_INCOMPLETE)

{

append_completion(completions,

wcstring(p->actual_cmd, offset + wcslen(proc)),

COMPLETE_CHILD_PROCESS_DESC,

0);

}

else

{

append_completion(completions,

to_string<long>(p->pid),

L"",

0);

found = 1;

}

}

}

}

}

}

return found;

expand_flags_t flags,

std::vector<completion_t> &out)

{

int found = 0;

if (!(flags & EXPAND_SKIP_JOBS))

{

const struct find_job_data_t data = {proc, flags, &out};

found = iothread_perform_on_main(find_job, &data);

if (found)

{

return 1;

}

}

/* Iterate over all processes */

wcstring process_name;

pid_t process_pid;

process_iterator_t iterator;

while (iterator.next_process(&process_name, &process_pid))

{

size_t offset;

if (match_pid(process_name, proc, flags, &offset))

{

if (flags & ACCEPT_INCOMPLETE)

{

append_completion(out,

process_name.c_str() + offset + wcslen(proc),

COMPLETE_PROCESS_DESC,

0);

}

else

{

append_completion(out, to_string<long>(process_pid));

}

}

}

return 1;

expand_flags_t flags,

std::vector<completion_t> &out)

{

/* Hack. If there's no INTERNAL_SEP and no PROCESS_EXPAND, then there's nothing to do. Check out this "null terminated string." */

const wchar_t some_chars[] = {INTERNAL_SEPARATOR, PROCESS_EXPAND, L'\0'};

if (instr_with_sep.find_first_of(some_chars) == wcstring::npos)

{

/* Nothing to do */

append_completion(out, instr_with_sep);

return 1;

}

/* expand_string calls us with internal separators in instr...sigh */

wcstring instr = instr_with_sep;

remove_internal_separator(instr, false);

if (instr.empty() || instr.at(0) != PROCESS_EXPAND)

{

append_completion(out, instr);

return 1;

}

const wchar_t * const in = instr.c_str();

if (flags & ACCEPT_INCOMPLETE)

{

if (wcsncmp(in+1, SELF_STR, wcslen(in+1))==0)

{

append_completion(out,

&SELF_STR[wcslen(in+1)],

COMPLETE_SELF_DESC,

0);

}

else if (wcsncmp(in+1, LAST_STR, wcslen(in+1))==0)

{

append_completion(out,

&LAST_STR[wcslen(in+1)],

COMPLETE_LAST_DESC,

0);

}

}

else

{

if (wcscmp((in+1), SELF_STR)==0)

{

append_completion(out, to_string<long>(getpid()));

return 1;

}

if (wcscmp((in+1), LAST_STR)==0)

{

if (proc_last_bg_pid > 0)

{

append_completion(out, to_string<long>(proc_last_bg_pid));

}

return 1;

}

}

size_t prev = out.size();

if (!find_process(in+1, flags, out))

return 0;

if (prev == out.size())

{

if (!(flags & ACCEPT_INCOMPLETE))

{

return 0;

}

}

return 1;

{

size_t stop_pos = token_pos+1;

switch (token[stop_pos])

{

case BRACKET_BEGIN:

{

wchar_t *cpy = wcsdup(token.c_str());

*(cpy+token_pos)=0;

wchar_t *name = &cpy[stop_pos+1];

wchar_t *end = wcschr(name, BRACKET_END);

wchar_t *post;

int is_var=0;

if (end)

{

post = end+1;

*end = 0;

if (!wcsvarname(name))

{

is_var = 1;

}

}

if (is_var)

{

parser.error(SYNTAX_ERROR,

error_pos,

COMPLETE_VAR_BRACKET_DESC,

cpy,

name,

post);

}

else

{

parser.error(SYNTAX_ERROR,

error_pos,

COMPLETE_VAR_BRACKET_DESC,

L"",

L"VARIABLE",

L"");

}

free(cpy);

break;

}

case INTERNAL_SEPARATOR:

{

parser.error(SYNTAX_ERROR,

error_pos,

COMPLETE_VAR_PARAN_DESC);

break;

}

case 0:

{

parser.error(SYNTAX_ERROR,

error_pos,

COMPLETE_VAR_NULL_DESC);

break;

}

default:

{

wchar_t token_stop_char = token[stop_pos];

// Unescape (see http://github.com/fish-shell/fish-shell/issues/50)

if (token_stop_char == ANY_CHAR)

token_stop_char = L'?';

else if (token_stop_char == ANY_STRING || token_stop_char == ANY_STRING_RECURSIVE)

token_stop_char = L'*';

parser.error(SYNTAX_ERROR,

error_pos,

(token_stop_char == L'?' ? COMPLETE_YOU_WANT_STATUS : COMPLETE_VAR_DESC),

token_stop_char);

break;

}

}

{

wchar_t *end;

const long size = (long)array_size;

size_t pos = 1; //skip past the opening square bracket

// debug( 0, L"parse_slice on '%ls'", in );

while (1)

{

long tmp;

while (iswspace(in[pos]) || (in[pos]==INTERNAL_SEPARATOR))

pos++;

if (in[pos] == L']')

{

pos++;

break;

}

errno=0;

tmp = wcstol(&in[pos], &end, 10);

if ((errno) || (end == &in[pos]))

{

return 1;

}

// debug( 0, L"Push idx %d", tmp );

long i1 = tmp>-1 ? tmp : (long)array_size+tmp+1;

pos = end-in;

while (in[pos]==INTERNAL_SEPARATOR)

pos++;

if (in[pos]==L'.' && in[pos+1]==L'.')

{

pos+=2;

while (in[pos]==INTERNAL_SEPARATOR)

pos++;

long tmp1 = wcstol(&in[pos], &end, 10);

if ((errno) || (end == &in[pos]))

{

return 1;

}

pos = end-in;

// debug( 0, L"Push range %d %d", tmp, tmp1 );

long i2 = tmp1>-1 ? tmp1 : size+tmp1+1;

// debug( 0, L"Push range idx %d %d", i1, i2 );

short direction = i2<i1 ? -1 : 1 ;

for (long jjj = i1; jjj*direction <= i2*direction; jjj+=direction)

{

// debug(0, L"Expand range [subst]: %i\n", jjj);

idx.push_back(jjj);