{

return node.type == symbol_block_statement || node.type == symbol_if_statement || node.type == symbol_switch_statement;

{

/* Get the offset of a node via pointer arithmetic, very hackish */

const parse_node_t *addr = &node;

const parse_node_t *base = &this->tree.at(0);

assert(addr >= base);

node_offset_t offset = addr - base;

assert(offset < this->tree.size());

assert(&tree.at(offset) == &node);

return offset;

{

assert(plain_statement.type == symbol_plain_statement);

enum process_type_t process_type = EXTERNAL;

/* Determine the process type, which depends on the statement decoration (command, builtin, etc) */

enum parse_statement_decoration_t decoration = tree.decoration_for_plain_statement(plain_statement);

/* Do the "exec hack" */

if (decoration != parse_statement_decoration_command && cmd == L"exec")

{

/* Either 'builtin exec' or just plain 'exec', and definitely not 'command exec'. Note we don't allow overriding exec with a function. */

process_type = INTERNAL_EXEC;

}

else if (decoration == parse_statement_decoration_command)

{

/* Always a command */

process_type = EXTERNAL;

}

else if (decoration == parse_statement_decoration_builtin)

{

/* What happens if this builtin is not valid? */

process_type = INTERNAL_BUILTIN;

}

else if (function_exists(cmd))

{

process_type = INTERNAL_FUNCTION;

}

else if (builtin_exists(cmd))

{

process_type = INTERNAL_BUILTIN;

}

else

{

process_type = EXTERNAL;

}

return process_type;

{

if (shell_is_exiting())

{

return execution_cancellation_exit;

}

else if (parser && parser->cancellation_requested)

{

return execution_cancellation_skip;

}

else if (block && block->loop_status != LOOP_NORMAL)

{

/* Nasty hack - break and continue set the 'skip' flag as well as the loop status flag. */

return execution_cancellation_loop_control;

}

else if (block && block->skip)

{

return execution_cancellation_skip;

}

else

{

return execution_cancellation_none;

}

{

assert(job_node.type == symbol_job);

/* Must have one statement */

const parse_node_t &statement = *get_child(job_node, 0, symbol_statement);

const parse_node_t &specific_statement = *get_child(statement, 0);

if (! specific_statement_type_is_redirectable_block(specific_statement))

{

/* Not an appropriate block type */

return false;

}

/* Must be no pipes */

const parse_node_t &continuation = *get_child(job_node, 1, symbol_job_continuation);

if (continuation.child_count > 0)

{

/* Multiple statements in this job, so there's pipes involved */

return false;

}

/* Check for arguments and redirections. All of the above types have an arguments / redirections list. It must be empty. */

const parse_node_t &args_and_redirections = tree.find_child(specific_statement, symbol_arguments_or_redirections_list);

if (args_and_redirections.child_count > 0)

{

/* Non-empty, we have an argument or redirection */

return false;

}

/* Ok, we are a simple block! */

return true;

{

assert(statement.type == symbol_if_statement);

/* Push an if block */

if_block_t *ib = new if_block_t();

ib->node_offset = this->get_offset(statement);

parser->push_block(ib);

parse_execution_result_t result = parse_execution_success;

/* We have a sequence of if clauses, with a final else, resulting in a single job list that we execute */

const parse_node_t *job_list_to_execute = NULL;

const parse_node_t *if_clause = get_child(statement, 0, symbol_if_clause);

const parse_node_t *else_clause = get_child(statement, 1, symbol_else_clause);

for (;;)

{

if (should_cancel_execution(ib))

{

result = parse_execution_cancelled;

break;

}

assert(if_clause != NULL && else_clause != NULL);

const parse_node_t &condition = *get_child(*if_clause, 1, symbol_job);

/* Check the condition. We treat parse_execution_errored here as failure, in accordance with historic behavior */

parse_execution_result_t cond_ret = run_1_job(condition, ib);

bool take_branch = (cond_ret == parse_execution_success) && proc_get_last_status() == EXIT_SUCCESS;

if (take_branch)

{

/* condition succeeded */

job_list_to_execute = get_child(*if_clause, 3, symbol_job_list);

break;

}

else if (else_clause->child_count == 0)

{

/* 'if' condition failed, no else clause, we're done */

job_list_to_execute = NULL;

break;

}

else

{

/* We have an 'else continuation' (either else-if or else) */

const parse_node_t &else_cont = *get_child(*else_clause, 1, symbol_else_continuation);

assert(else_cont.production_idx < 2);

if (else_cont.production_idx == 0)

{

/* it's an 'else if', go to the next one */

if_clause = get_child(else_cont, 0, symbol_if_clause);

else_clause = get_child(else_cont, 1, symbol_else_clause);

}

else

{

/* it's the final 'else', we're done */

assert(else_cont.production_idx == 1);

job_list_to_execute = get_child(else_cont, 1, symbol_job_list);

break;

}

}

}

/* Execute any job list we got */

if (job_list_to_execute != NULL)

{

run_job_list(*job_list_to_execute, ib);

}

/* Done */

parser->pop_block(ib);

return result;

{

assert(header.type == symbol_begin_header);

assert(contents.type == symbol_job_list);

/* Basic begin/end block. Push a scope block. */

scope_block_t *sb = new scope_block_t(BEGIN);

parser->push_block(sb);

/* Run the job list */

parse_execution_result_t ret = run_job_list(contents, sb);

/* Pop the block */

parser->pop_block(sb);

return ret;

{

assert(header.type == symbol_function_header);

assert(contents.type == symbol_job_list);

parse_execution_result_t result = parse_execution_success;

/* Get arguments */

const parse_node_t *unmatched_wildcard = NULL;

wcstring_list_t argument_list = this->determine_arguments(header, &unmatched_wildcard);

if (unmatched_wildcard != NULL)

{

report_unmatched_wildcard_error(*unmatched_wildcard);

result = parse_execution_errored;

}

if (result == parse_execution_success)

{

const wcstring contents_str = get_source(contents);

wcstring error_str;

int err = define_function(*parser, argument_list, contents_str, &error_str);

proc_set_last_status(err);

if (! error_str.empty())

{

this->report_error(header, L"%ls", error_str.c_str());

result = parse_execution_errored;

}

}

return result;

{

assert(statement.type == symbol_block_statement);

const parse_node_t &block_header = *get_child(statement, 0, symbol_block_header); //block header

const parse_node_t &header = *get_child(block_header, 0); //specific header type (e.g. for loop)

const parse_node_t &contents = *get_child(statement, 2, symbol_job_list); //block contents

parse_execution_result_t ret = parse_execution_success;

switch (header.type)

{

case symbol_for_header:

ret = run_for_statement(header, contents);

break;

case symbol_while_header:

ret = run_while_statement(header, contents);

break;

case symbol_function_header:

ret = run_function_statement(header, contents);

break;

case symbol_begin_header:

ret = run_begin_statement(header, contents);

break;

default:

fprintf(stderr, "Unexpected block header: %ls\n", header.describe().c_str());

PARSER_DIE();

break;

}

return ret;

{

assert(header.type == symbol_for_header);

assert(block_contents.type == symbol_job_list);

/* Get the variable name: `for var_name in ...` */

const parse_node_t &var_name_node = *get_child(header, 1, parse_token_type_string);

const wcstring for_var_name = get_source(var_name_node);

/* Get the contents to iterate over. */

const parse_node_t *unmatched_wildcard = NULL;

wcstring_list_t argument_list = this->determine_arguments(header, &unmatched_wildcard);

if (unmatched_wildcard != NULL)

{

return report_unmatched_wildcard_error(*unmatched_wildcard);

}

parse_execution_result_t ret = parse_execution_success;

for_block_t *fb = new for_block_t(for_var_name);

parser->push_block(fb);

/* Note that we store the sequence of values in opposite order */

std::reverse(argument_list.begin(), argument_list.end());

fb->sequence = argument_list;

/* Now drive the for loop. */

while (! fb->sequence.empty())

{

if (should_cancel_execution(fb))

{

ret = parse_execution_cancelled;

break;

}

const wcstring &for_variable = fb->variable;

const wcstring &val = fb->sequence.back();

env_set(for_variable, val.c_str(), ENV_LOCAL);

fb->sequence.pop_back();

fb->loop_status = LOOP_NORMAL;

fb->skip = 0;

this->run_job_list(block_contents, fb);

if (this->cancellation_reason(fb) == execution_cancellation_loop_control)

{

/* Handle break or continue */

if (fb->loop_status == LOOP_CONTINUE)

{

/* Reset the loop state */

fb->loop_status = LOOP_NORMAL;

fb->skip = false;

continue;

}

else if (fb->loop_status == LOOP_BREAK)

{

break;

}

}

}

parser->pop_block(fb);

return ret;

{

assert(statement.type == symbol_switch_statement);

parse_execution_result_t ret = parse_execution_success;

const parse_node_t *matching_case_item = NULL;

parse_execution_result_t result = parse_execution_success;

/* Get the switch variable */

const parse_node_t &switch_value_node = *get_child(statement, 1, parse_token_type_string);

const wcstring switch_value = get_source(switch_value_node);

/* Expand it */

std::vector<completion_t> switch_values_expanded;

int expand_ret = expand_string(switch_value, switch_values_expanded, EXPAND_NO_DESCRIPTIONS);

switch (expand_ret)

{

case EXPAND_ERROR:

{

result = report_error(switch_value_node,

_(L"Could not expand string '%ls'"),

switch_value.c_str());

break;

}

case EXPAND_WILDCARD_NO_MATCH:

{

/* Store the node that failed to expand */

report_error(switch_value_node, WILDCARD_ERR_MSG, switch_value.c_str());

ret = parse_execution_errored;

break;

}

case EXPAND_WILDCARD_MATCH:

case EXPAND_OK:

{

break;

}

}

if (result == parse_execution_success && switch_values_expanded.size() != 1)

{

result = report_error(switch_value_node,

_(L"switch: Expected exactly one argument, got %lu\n"),

switch_values_expanded.size());

}

const wcstring &switch_value_expanded = switch_values_expanded.at(0).completion;

switch_block_t *sb = new switch_block_t(switch_value_expanded);

parser->push_block(sb);

if (result == parse_execution_success)

{

/* Expand case statements */

const parse_node_t *case_item_list = get_child(statement, 3, symbol_case_item_list);

/* Loop while we don't have a match but do have more of the list */

while (matching_case_item == NULL && case_item_list != NULL)

{

if (should_cancel_execution(sb))

{

result = parse_execution_cancelled;

break;

}

/* Get the next item and the remainder of the list */

const parse_node_t *case_item = tree.next_node_in_node_list(*case_item_list, symbol_case_item, &case_item_list);

if (case_item == NULL)

{

/* No more items */

break;

}

/* Pull out the argument list */

const parse_node_t &arg_list = *get_child(*case_item, 1, symbol_argument_list);

/* Expand arguments. We explicitly ignore unmatched_wildcard. That is, a case item list may have a wildcard that fails to expand to anything. */

const wcstring_list_t case_args = this->determine_arguments(arg_list, NULL);

for (size_t i=0; i < case_args.size(); i++)

{

const wcstring &arg = case_args.at(i);

/* Unescape wildcards so they can be expanded again */

wchar_t *unescaped_arg = parse_util_unescape_wildcards(arg.c_str());

bool match = wildcard_match(switch_value_expanded, unescaped_arg);

free(unescaped_arg);

/* If this matched, we're done */

if (match)

{

matching_case_item = case_item;

break;

}

}

}

}

if (result == parse_execution_success && matching_case_item != NULL)

{

/* Success, evaluate the job list */

const parse_node_t *job_list = get_child(*matching_case_item, 3, symbol_job_list);

result = this->run_job_list(*job_list, sb);

}

parser->pop_block(sb);

return result;

{

assert(header.type == symbol_while_header);

assert(block_contents.type == symbol_job_list);

/* Push a while block */

while_block_t *wb = new while_block_t();

wb->status = WHILE_TEST_FIRST;

wb->node_offset = this->get_offset(header);

parser->push_block(wb);

parse_execution_result_t ret = parse_execution_success;

/* The condition and contents of the while loop, as a job and job list respectively */

const parse_node_t &while_condition = *get_child(header, 1, symbol_job);

/* Run while the condition is true */

for (;;)

{

/* Check the condition */

parse_execution_result_t cond_result = this->run_1_job(while_condition, wb);

/* We only continue on successful execution and EXIT_SUCCESS */

if (cond_result != parse_execution_success || proc_get_last_status() != EXIT_SUCCESS)

{

break;

}

/* Check cancellation */

if (this->should_cancel_execution(wb))

{

ret = parse_execution_cancelled;

break;

}

/* The block ought to go inside the loop (see #1212) */

this->run_job_list(block_contents, wb);

if (this->cancellation_reason(wb) == execution_cancellation_loop_control)

{

/* Handle break or continue */

if (wb->loop_status == LOOP_CONTINUE)

{

/* Reset the loop state */

wb->loop_status = LOOP_NORMAL;

wb->skip = false;

continue;

}

else if (wb->loop_status == LOOP_BREAK)

{

break;

}

}

}

/* Done */

parser->pop_block(wb);

return ret;

{

if (parser->show_errors)

{

/* Create an error */

parse_error_t error;

error.source_start = node.source_start;

error.source_length = node.source_length;

error.code = parse_error_syntax; //hackish

va_list va;

va_start(va, fmt);

error.text = vformat_string(fmt, va);

va_end(va);

/* Get a backtrace */

wcstring backtrace_and_desc;

const parse_error_list_t error_list = parse_error_list_t(1, error);

parser->get_backtrace(src, error_list, &backtrace_and_desc);

fprintf(stderr, "<%ls>", backtrace_and_desc.c_str());

}

return parse_execution_errored;

{

proc_set_last_status(STATUS_UNMATCHED_WILDCARD);

/* For reasons I cannot explain, unmatched wildcards are only reported in interactive use. */

if (get_is_interactive())

{

return report_error(unmatched_wildcard, WILDCARD_ERR_MSG, get_source(unmatched_wildcard).c_str());

}

else

{

return parse_execution_errored;

}

{

assert(statement_node.type == symbol_plain_statement);

/* We couldn't find the specified command. This is a non-fatal error. We want to set the exit status to 127, which is the standard number used by other shells like bash and zsh. */

const wchar_t * const cmd = cmd_str.c_str();

const wchar_t * const equals_ptr = wcschr(cmd, L'=');

if (equals_ptr != NULL)

{

/* Try to figure out if this is a pure variable assignment (foo=bar), or if this appears to be running a command (foo=bar ruby...) */

const wcstring name_str = wcstring(cmd, equals_ptr - cmd); //variable name, up to the =

const wcstring val_str = wcstring(equals_ptr + 1); //variable value, past the =

const parse_node_tree_t::parse_node_list_t args = tree.find_nodes(statement_node, symbol_argument, 1);

if (! args.empty())

{

const wcstring argument = get_source(*args.at(0));

wcstring ellipsis_str = wcstring(1, ellipsis_char);

if (ellipsis_str == L"$")

ellipsis_str = L"...";

/* Looks like a command */

this->report_error(statement_node,

_(L"Unknown command '%ls'. Did you mean to run %ls with a modified environment? Try 'env %ls=%ls %ls%ls'. See the help section on the set command by typing 'help set'."),

cmd,

argument.c_str(),

name_str.c_str(),

val_str.c_str(),

argument.c_str(),

ellipsis_str.c_str());

}

else

{

this->report_error(statement_node,

COMMAND_ASSIGN_ERR_MSG,

cmd,

name_str.c_str(),

val_str.c_str());

}

}

else if (cmd[0]==L'$' || cmd[0] == VARIABLE_EXPAND || cmd[0] == VARIABLE_EXPAND_SINGLE)

{

const env_var_t val_wstr = env_get_string(cmd+1);

const wchar_t *val = val_wstr.missing() ? NULL : val_wstr.c_str();

if (val)

{

this->report_error(statement_node,

_(L"Variables may not be used as commands. Instead, define a function like 'function %ls; %ls $argv; end' or use the eval builtin instead, like 'eval %ls'. See the help section for the function command by typing 'help function'."),

cmd+1,

val,

cmd,

cmd);

}

else

{

this->report_error(statement_node,

_(L"Variables may not be used as commands. Instead, define a function or use the eval builtin instead, like 'eval %ls'. See the help section for the function command by typing 'help function'."),

cmd,

cmd);

}

}

else if (wcschr(cmd, L'$'))

{

this->report_error(statement_node,

_(L"Commands may not contain variables. Use the eval builtin instead, like 'eval %ls'. See the help section for the eval command by typing 'help eval'."),

cmd,

cmd);

}

else if (err_code!=ENOENT)

{

this->report_error(statement_node,

_(L"The file '%ls' is not executable by this user"),

cmd?cmd:L"UNKNOWN");

}

else

{

/*

wcstring_list_t event_args;

event_args.push_back(cmd_str);

event_fire_generic(L"fish_command_not_found", &event_args);

/* Here we want to report an error (so it shows a backtrace), but with no text */

this->report_error(statement_node, L"");

}

/* Set the last proc status appropriately */

proc_set_last_status(err_code==ENOENT?STATUS_UNKNOWN_COMMAND:STATUS_NOT_EXECUTABLE);

{

assert(job != NULL);

assert(proc != NULL);

assert(statement.type == symbol_plain_statement);

/* We may decide that a command should be an implicit cd */

bool use_implicit_cd = false;

/* Get the command. We expect to always get it here. */

wcstring cmd;

bool got_cmd = tree.command_for_plain_statement(statement, src, &cmd);

assert(got_cmd);

/* Expand it as a command. Return an error on failure. */

bool expanded = expand_one(cmd, EXPAND_SKIP_CMDSUBST | EXPAND_SKIP_VARIABLES);

if (! expanded)

{

report_error(statement, ILLEGAL_CMD_ERR_MSG, cmd.c_str());

return parse_execution_errored;

}

/* Determine the process type */

enum process_type_t process_type = process_type_for_command(statement, cmd);

/* Check for stack overflow */

if (process_type == INTERNAL_FUNCTION && parser->forbidden_function.size() > FISH_MAX_STACK_DEPTH)

{

this->report_error(statement, CALL_STACK_LIMIT_EXCEEDED_ERR_MSG);

return parse_execution_errored;

}

wcstring path_to_external_command;

if (process_type == EXTERNAL)

{

/* Determine the actual command. This may be an implicit cd. */

bool has_command = path_get_path(cmd, &path_to_external_command);

/* If there was no command, then we care about the value of errno after checking for it, to distinguish between e.g. no file vs permissions problem */

const int no_cmd_err_code = errno;

/* If the specified command does not exist, and is undecorated, try using an implicit cd. */

if (! has_command && tree.decoration_for_plain_statement(statement) == parse_statement_decoration_none)

{

/* Implicit cd requires an empty argument and redirection list */

const parse_node_t *args = get_child(statement, 1, symbol_arguments_or_redirections_list);

if (args->child_count == 0)

{

/* Ok, no arguments or redirections; check to see if the first argument is a directory */

wcstring implicit_cd_path;

use_implicit_cd = path_can_be_implicit_cd(cmd, &implicit_cd_path);

}

}

if (! has_command && ! use_implicit_cd)

{

/* No command */

this->handle_command_not_found(cmd, statement, no_cmd_err_code);

return parse_execution_errored;

}

}

/* The argument list and set of IO redirections that we will construct for the process */

wcstring_list_t argument_list;

io_chain_t process_io_chain;

if (use_implicit_cd)

{

/* Implicit cd is simple */

argument_list.push_back(L"cd");

argument_list.push_back(cmd);

path_to_external_command.clear();

/* If we have defined a wrapper around cd, use it, otherwise use the cd builtin */

process_type = function_exists(L"cd") ? INTERNAL_FUNCTION : INTERNAL_BUILTIN;

}

else

{

/* Form the list of arguments. The command is the first argument. TODO: count hack, where we treat 'count --help' as different from 'count $foo' that expands to 'count --help'. fish 1.x never successfully did this, but it tried to! */

const parse_node_t *unmatched_wildcard = NULL;

argument_list = this->determine_arguments(statement, &unmatched_wildcard);

argument_list.insert(argument_list.begin(), cmd);

/* If we were not able to expand any wildcards, here is the first one that failed */

if (unmatched_wildcard != NULL)

{

job_set_flag(job, JOB_WILDCARD_ERROR, 1);

report_unmatched_wildcard_error(*unmatched_wildcard);

return parse_execution_errored;

}

/* The set of IO redirections that we construct for the process */

if (! this->determine_io_chain(statement, &process_io_chain))

{

return parse_execution_errored;

}

/* Determine the process type */

process_type = process_type_for_command(statement, cmd);

}

/* Populate the process */

proc->type = process_type;

proc->set_argv(argument_list);

proc->set_io_chain(process_io_chain);

proc->actual_cmd = path_to_external_command;

return parse_execution_success;

{

wcstring_list_t argument_list;

/* Whether we failed to match any wildcards, and succeeded in matching any wildcards */

bool unmatched_wildcard = false, matched_wildcard = false;

/* First node that failed to expand as a wildcard (if any) */

const parse_node_t *unmatched_wildcard_node = NULL;

/* Get all argument nodes underneath the statement */

const parse_node_tree_t::parse_node_list_t argument_nodes = tree.find_nodes(parent, symbol_argument);

argument_list.reserve(argument_nodes.size());

for (size_t i=0; i < argument_nodes.size(); i++)

{

const parse_node_t &arg_node = *argument_nodes.at(i);

/* Expect all arguments to have source */

assert(arg_node.has_source());

const wcstring arg_str = arg_node.get_source(src);

/* Expand this string */

std::vector<completion_t> arg_expanded;

int expand_ret = expand_string(arg_str, arg_expanded, EXPAND_NO_DESCRIPTIONS);

switch (expand_ret)

{

case EXPAND_ERROR:

{

this->report_error(arg_node,

_(L"Could not expand string '%ls'"),

arg_str.c_str());

break;

}

case EXPAND_WILDCARD_NO_MATCH:

{

/* Store the node that failed to expand */

unmatched_wildcard = true;

if (! unmatched_wildcard_node)

{

unmatched_wildcard_node = &arg_node;

}

break;

}

case EXPAND_WILDCARD_MATCH:

{

matched_wildcard = true;

break;

}

case EXPAND_OK:

{

break;

}

}

/* Now copy over any expanded arguments */

for (size_t i=0; i < arg_expanded.size(); i++)

{

argument_list.push_back(arg_expanded.at(i).completion);

}

}

/* Return if we had a wildcard problem */

if (out_unmatched_wildcard_node != NULL && unmatched_wildcard && ! matched_wildcard)

{

*out_unmatched_wildcard_node = unmatched_wildcard_node;

}

return argument_list;

{

io_chain_t result;

bool errored = false;

/* We are called with a statement of varying types. We require that the statement have an arguments_or_redirections_list child. */

const parse_node_t &args_and_redirections_list = tree.find_child(statement_node, symbol_arguments_or_redirections_list);

/* Get all redirection nodes underneath the statement */

const parse_node_tree_t::parse_node_list_t redirect_nodes = tree.find_nodes(args_and_redirections_list, symbol_redirection);

for (size_t i=0; i < redirect_nodes.size(); i++)

{

const parse_node_t &redirect_node = *redirect_nodes.at(i);

int source_fd = -1; /* source fd */

wcstring target; /* file path or target fd */

enum token_type redirect_type = tree.type_for_redirection(redirect_node, src, &source_fd, &target);

/* PCA: I can't justify this EXPAND_SKIP_VARIABLES flag. It was like this when I got here. */

bool target_expanded = expand_one(target, no_exec ? EXPAND_SKIP_VARIABLES : 0);

if (! target_expanded || target.empty())

{

/* Should improve this error message */

errored = report_error(redirect_node,

_(L"Invalid redirection target: %ls"),

target.c_str());

}

/* Generate the actual IO redirection */

shared_ptr<io_data_t> new_io;

assert(redirect_type != TOK_NONE);

switch (redirect_type)

{

case TOK_REDIRECT_FD: