/* Yash: yet another shell */

/* exec.c: command execution */

/* (C) 2007-2026 magicant */

/* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 2 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>. */

#include "common.h"

#include "exec.h"

#include <assert.h>

#include <errno.h>

#include <fcntl.h>

#if HAVE_GETTEXT

# include <libintl.h>

#endif

#include <limits.h>

#include <math.h>

#if HAVE_PATHS_H

# include <paths.h>

#endif

#include <signal.h>

#include <stdbool.h>

#include <stdint.h> /* required before <sys/resource.h> on freebsd */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#if HAVE_RUSAGE

# include <sys/time.h> /* required before <sys/resource.h> on old Mac OS X */

# include <sys/resource.h>

#endif

#include <sys/times.h>

#include <unistd.h>

#include <wchar.h>

#include "alias.h"

#include "builtin.h"

#include "expand.h"

#if YASH_ENABLE_HISTORY

# include "history.h"

#endif

#include "input.h"

#include "job.h"

#include "option.h"

#include "parser.h"

#include "path.h"

#include "plist.h"

#include "redir.h"

#include "sig.h"

#include "strbuf.h"

#include "util.h"

#include "variable.h"

#include "xfnmatch.h"

#include "yash.h"

#if YASH_ENABLE_DOUBLE_BRACKET

# include "builtins/test.h"

#endif

#if YASH_ENABLE_LINEEDIT

# include "lineedit/complete.h"

# include "lineedit/lineedit.h"

#endif

/* type of command execution */

typedef enum {

E_NORMAL, /* normal execution */

E_ASYNC, /* asynchronous execution */

E_SELF, /* execution in the shell's own process */

} exec_T;

/* info about file descriptors of pipes */

typedef struct pipeinfo_T {

int pi_fromprevfd; /* reading end of the pipe from the previous process */

int pi_tonextfds[2]; /* both ends of the pipe to the next process */

/* -1 is assigned to unused members. */

} pipeinfo_T;

#define PIPEINFO_INIT { -1, { -1, -1 }, }

/* values used to specify the behavior of command search. */

typedef enum srchcmdtype_T {

SCT_EXTERNAL = 1 << 0, /* search for an external command */

SCT_BUILTIN = 1 << 1, /* search for a built-in */

SCT_FUNCTION = 1 << 2, /* search for a function */

SCT_ALL = 1 << 3, /* search all */

SCT_STDPATH = 1 << 4, /* search the standard PATH */

SCT_CHECK = 1 << 5, /* check command existence */

} srchcmdtype_T;

typedef enum cmdtype_T {

CT_NONE,

CT_EXTERNALPROGRAM,

CT_SPECIALBUILTIN,

CT_MANDATORYBUILTIN,

CT_ELECTIVEBUILTIN,

CT_EXTENSIONBUILTIN,

CT_SUBSTITUTIVEBUILTIN,

CT_FUNCTION,

} cmdtype_T;

/* info about a simple command to execute */

typedef struct commandinfo_T {

cmdtype_T type; /* type of command */

union {

const char *path; /* command path (for external program) */

main_T *builtin; /* body of built-in */

command_T *function; /* body of function */

} value;

} commandinfo_T;

#define ci_path value.path

#define ci_builtin value.builtin

#define ci_function value.function

/* result of `fork_and_wait' */

typedef struct fork_and_wait_T {

pid_t cpid; /* child process ID */

wchar_t **namep; /* where to place the job name */

} fork_and_wait_T;

typedef enum exception_T {

E_NONE,

E_CONTINUE,

E_RETURN,

E_BREAK_ITERATION,

E_CONTINUE_ITERATION,

E_CANCEL,

} exception_T;

/* state of currently executed loop */

typedef struct execstate_T {

unsigned loopnest; /* level of nested loops */

unsigned breakloopnest; /* target level of "break" */

bool noreturn; /* true when the "return" built-in is not allowed */

bool iterating; /* true when iterative execution is ongoing */

} execstate_T;

static void exec_pipelines(const pipeline_T *p, bool finally_exit);

static void exec_pipelines_async(const pipeline_T *p)

__attribute__((nonnull));

static void exec_commands(command_T *cs, exec_T type)

__attribute__((nonnull));

static inline size_t number_of_commands_in_pipeline(const command_T *c)

__attribute__((nonnull,pure,warn_unused_result));

static void apply_errexit_errreturn(const command_T *c);

static bool is_errexit_condition(void)

__attribute__((pure));

static bool is_errreturn_condition(void)

__attribute__((pure));

static bool is_err_condition_for(const command_T *c)

__attribute__((pure));

static inline void next_pipe(pipeinfo_T *pi, bool next)

__attribute__((nonnull));

static inline void connect_pipes(pipeinfo_T *pi)

__attribute__((nonnull));

static void exec_one_command(command_T *c, bool finally_exit)

__attribute__((nonnull));

static void exec_simple_command(const command_T *c, bool finally_exit)

__attribute__((nonnull));

static bool exec_simple_command_without_words(const command_T *c)

__attribute__((nonnull,warn_unused_result));

static bool exec_simple_command_with_words(

const command_T *c, int argc, void **argv, bool finally_exit)

__attribute__((nonnull,warn_unused_result));

static void print_xtrace(void *const *argv);

static void search_command(

const char *restrict name, const wchar_t *restrict wname,

commandinfo_T *restrict ci, enum srchcmdtype_T type)

__attribute__((nonnull));

static inline bool is_special_builtin(const char *cmdname)

__attribute__((nonnull,pure));

static bool command_not_found_handler(void *const *argv)

__attribute__((nonnull));

static wchar_t **invoke_simple_command(const commandinfo_T *ci,

int argc, char *argv0, void **argv, bool finally_exit)

__attribute__((nonnull,warn_unused_result));

static void exec_external_program(

const char *path, int argc, char *argv0, void **argv, char **envs)

__attribute__((nonnull));

static inline int xexecve(

const char *path, char *const *argv, char *const *envp)

__attribute__((nonnull(1)));

static void exec_fall_back_on_sh(

int argc, char *const *argv, char *const *env, const char *path)

__attribute__((nonnull(2,3,4)));

static void exec_function_body(

command_T *body, void *const *args, bool finally_exit, bool complete)

__attribute__((nonnull));

static void exec_nonsimple_command(command_T *c, bool finally_exit)

__attribute__((nonnull));

static void exec_if(const command_T *c, bool finally_exit)

__attribute__((nonnull));

static inline bool exec_condition(const and_or_T *c);

static void exec_for(const command_T *c, bool finally_exit)

__attribute__((nonnull));

static void exec_while(const command_T *c, bool finally_exit)

__attribute__((nonnull));

static void exec_case(const command_T *c, bool finally_exit)

__attribute__((nonnull));

static void exec_funcdef(const command_T *c, bool finally_exit)

__attribute__((nonnull));

static fork_and_wait_T fork_and_wait(sigtype_T sigtype)

__attribute__((warn_unused_result));

static void become_child(sigtype_T sigtype);

static int exec_iteration(void *const *commands, const char *codename)

__attribute__((nonnull));

/* exit status of the last command */

int laststatus = Exit_SUCCESS;

/* exit status of the command preceding the currently executed trap action */

int savelaststatus = -1; // -1 if not in a trap handler

/* exit status of the last command substitution */

static int lastcmdsubstatus;

/* exit status of the command that immediately preceded the EXIT trap. */

int exitstatus = -1; // -1 if not executing the EXIT trap

/* the process ID of the last asynchronous list */

pid_t lastasyncpid;

/* This flag is set to true while the shell is executing the condition of an if-

* statement, an and-or list, etc. to suppress the effect of the "errexit" and

* "errreturn" options. */

static bool suppresserrexit = false, suppresserrreturn = false;

/* state of currently executed loop */

static execstate_T execstate;

/* exceptional jump to be done (other than "break") */

static exception_T exception;

/* This flag is set when a special built-in is executed as such. */

bool special_builtin_executed;

/* This flag is set while the "exec" built-in is executed. */

static bool exec_builtin_executed = false;

/* True while executing auxiliary commands such as $PROMPT_COMMAND and

* $COMMAND_NOT_FOUND_HANDLER. */

bool is_executing_auxiliary = false;

/* the last assignment. */

static const assign_T *last_assign;

/* a buffer for xtrace.

* When assignments are performed while executing a simple command, the trace

* is appended to this buffer. Each trace of an assignment must be prefixed

* with a space to separate it with the previous one. The first space will be

* trimmed when the buffer is flushed to the standard error. */

static xwcsbuf_T xtrace_buffer = { .contents = NULL };

/* Resets `execstate' to the initial state. */

void reset_execstate(bool reset_iteration)

{

execstate.loopnest = 0;

execstate.breakloopnest = 0;

execstate.noreturn = false;

if (reset_iteration)

execstate.iterating = false;

}

/* Saves the current `execstate' and returns it.

* You typically call `reset_execstate' after calling this function. */

execstate_T *save_execstate(void)

{

execstate_T *save = xmalloc(sizeof execstate);

*save = execstate;

return save;

}

/* Restores `execstate' to `save' and frees `save'. */

void restore_execstate(execstate_T *save)

{

execstate = *save;

free(save);

}

/* Disables the "return" built-in in the current `execstate'. */

void disable_return(void)

{

execstate.noreturn = true;

}

/* If we're returning, clear the flag. */

void cancel_return(void)

{

if (exception == E_RETURN)

exception = E_NONE;

}

/* Forces the interactive shell to return to the command prompt by aborting the

* current command. This is used when a foreground job has been suspended and

* when a shell error occurs that would terminate the shell if it were not

* interactive. */

void cancel_current_command(void)

{

exception = E_CANCEL;

}

/* Clears the effect of `cancel_current_command'. */

void uncancel_current_command(void)

{

if (exception == E_CANCEL)

exception = E_NONE;

}

/* Returns true iff we're breaking/continuing/returning now. */

bool need_break(void)

{

return execstate.breakloopnest < execstate.loopnest

|| exception != E_NONE

|| is_interrupted();

}

/* Executes the and-or lists.

* If `finally_exit' is true, the shell exits after execution. */

void exec_and_or_lists(const and_or_T *a, bool finally_exit)

{

while (a != NULL && !need_break()) {

if (!a->ao_async)

exec_pipelines(a->ao_pipelines, finally_exit && !a->next);

else

exec_pipelines_async(a->ao_pipelines);

a = a->next;

}

if (finally_exit)

exit_shell();

}

/* Executes the pipelines. */

void exec_pipelines(const pipeline_T *p, bool finally_exit)

{

for (bool first = true; p != NULL; p = p->next, first = false) {

if (!first && p->pl_cond == (laststatus != Exit_SUCCESS))

continue;

bool savesee = suppresserrexit, saveser = suppresserrreturn;

bool suppress = p->pl_neg || p->next != NULL;

suppresserrexit |= suppress;

suppresserrreturn |= suppress;

bool self = finally_exit && !p->next && !p->pl_neg;

exec_commands(p->pl_commands, self ? E_SELF : E_NORMAL);

suppresserrexit = savesee, suppresserrreturn = saveser;

if (need_break())

break;

if (p->pl_neg) {

if (laststatus == Exit_SUCCESS)

laststatus = Exit_FAILURE;

else

laststatus = Exit_SUCCESS;

}

}

if (finally_exit)

exit_shell();

}

/* Executes the pipelines asynchronously. */

void exec_pipelines_async(const pipeline_T *p)

{

if (p->next == NULL && !p->pl_neg) {

exec_commands(p->pl_commands, E_ASYNC);

return;

}

pid_t cpid = fork_and_reset(0, false, t_quitint);

if (cpid > 0) {

/* parent process: add a new job */

job_T *job = xmalloc(add(sizeof *job, sizeof *job->j_procs));

process_T *ps = job->j_procs;

ps->pr_pid = cpid;

ps->pr_status = JS_RUNNING;

ps->pr_statuscode = 0;

ps->pr_name = pipelines_to_wcs(p);

job->j_pgid = doing_job_control_now ? cpid : 0;

job->j_status = JS_RUNNING;

job->j_statuschanged = false;

job->j_legacy = false;

job->j_nonotify = false;

job->j_pcount = 1;

set_active_job(job);

size_t jobnumber = add_job(shopt_curasync);

if (is_interactive_now)

fprintf(stderr, "[%zu] %jd\n", jobnumber, (intmax_t) cpid);

laststatus = Exit_SUCCESS;

lastasyncpid = cpid;

} else if (cpid == 0) {

/* child process: execute the commands and then exit */

maybe_redirect_stdin_to_devnull();

exec_pipelines(p, true);

UNREACHABLE();

} else {

/* fork failure */

laststatus = Exit_NOEXEC;

}

}

/* Executes the commands in a pipeline. */

void exec_commands(command_T *const cs, exec_T type)

{

size_t count = number_of_commands_in_pipeline(cs);

assert(count > 0);

bool short_circuit =

type == E_SELF && !doing_job_control_now && !any_trap_set &&

(count == 1 || !shopt_pipefail);

if (count == 1 && type != E_ASYNC) {

exec_one_command(cs, /* finally_exit = */ short_circuit);

goto done;

}

/* fork a child process for each command in the pipeline */

pid_t pgid = 0;

pipeinfo_T pipe = PIPEINFO_INIT;

job_T *job = xmallocs(sizeof *job, count, sizeof *job->j_procs);

command_T *c;

process_T *p;

int forkstatus = Exit_SUCCESS;

for (c = cs, p = job->j_procs; c != NULL; c = c->next, p++) {

bool is_last = c->next == NULL;

next_pipe(&pipe, !is_last);

if (is_last && short_circuit)

goto exec_one_command; /* skip forking */

sigtype_T sigtype = (type == E_ASYNC) ? t_quitint : 0;

pid_t pid = fork_and_reset(pgid, type == E_NORMAL, sigtype);

if (pid == 0) {

exec_one_command: /* child process */

free(job);

connect_pipes(&pipe);

if (type == E_ASYNC && pipe.pi_fromprevfd < 0)

maybe_redirect_stdin_to_devnull();

exec_one_command(c, true);

UNREACHABLE();

} else if (pid >= 0) {

/* parent process: fork succeeded */

if (pgid == 0)

pgid = pid;

p->pr_pid = pid;

p->pr_status = JS_RUNNING;

// p->pr_statuscode = ?; // The process is still running.

p->pr_name = NULL; // The actual name is given later.

} else {

/* parent process: fork failed */

p->pr_pid = 0;

p->pr_status = JS_DONE;

p->pr_statuscode = forkstatus = Exit_NOEXEC;

p->pr_name = NULL;

}

}

assert(pipe.pi_tonextfds[PIPE_IN] < 0);

assert(pipe.pi_tonextfds[PIPE_OUT] < 0);

if (pipe.pi_fromprevfd >= 0)

xclose(pipe.pi_fromprevfd); /* close the leftover pipe */

/* establish the job and wait for it */

job->j_pgid = doing_job_control_now ? pgid : 0;

job->j_status = JS_RUNNING;

job->j_statuschanged = false;

job->j_legacy = false;

job->j_nonotify = false;

job->j_pcount = count;

set_active_job(job);

if (type != E_ASYNC) {

wait_for_job(ACTIVE_JOBNO, doing_job_control_now, false, false);

if (doing_job_control_now)

put_foreground(shell_pgid);

laststatus = calc_status_of_job(job);

} else {

laststatus = forkstatus;

lastasyncpid = job->j_procs[count - 1].pr_pid;

}

if (job->j_status == JS_DONE) {

notify_signaled_job(ACTIVE_JOBNO);

remove_job(ACTIVE_JOBNO);

} else {

/* name the job processes */

for (c = cs, p = job->j_procs; c != NULL; c = c->next, p++)

p->pr_name = command_to_wcs(c, false);

/* retain the job */

size_t jobnumber = add_job(type == E_NORMAL || shopt_curasync);

if (type == E_ASYNC && is_interactive_now)

fprintf(stderr, "[%zu] %jd\n", jobnumber, (intmax_t) lastasyncpid);

}

done:

handle_signals();

apply_errexit_errreturn(cs);

if (type == E_SELF)

exit_shell();

}

size_t number_of_commands_in_pipeline(const command_T *c)

{

size_t count = 1;

while ((c = c->next) != NULL)

count++;

return count;

}

/* Tests the current condition for "errexit" and "errreturn" and then performs

* exit or return if applicable. */

void apply_errexit_errreturn(const command_T *c)

{

if (is_errexit_condition() && is_err_condition_for(c))

exit_shell_with_status(laststatus);

if (is_errreturn_condition() && is_err_condition_for(c))

exception = E_RETURN;

}

/* Returns true if the shell should exit because of the `errexit' option. */

bool is_errexit_condition(void)

{

if (!shopt_errexit || suppresserrexit)

return false;

if (laststatus == Exit_SUCCESS)

return false;

#if YASH_ENABLE_LINEEDIT

if (le_state & LE_STATE_COMPLETING)

return false;

#endif

return true;

}

/* Returns true if the shell should return because of the `errreturn' option. */

bool is_errreturn_condition(void)

{

if (!shopt_errreturn || suppresserrreturn || execstate.noreturn)

return false;

return laststatus != Exit_SUCCESS;

}

/* Returns true if "errexit" and "errreturn" should be applied to the given

* command. */

bool is_err_condition_for(const command_T *c)

{

if (c == NULL)

return true;

/* If this is a multi-command pipeline, the commands are executed in

* subshells. Otherwise, we need to check the type of the command. */

if (c->next != NULL)

return true;

switch (c->c_type) {

case CT_SIMPLE:

case CT_SUBSHELL:

#if YASH_ENABLE_DOUBLE_BRACKET

case CT_BRACKET:

#endif

case CT_FUNCDEF:

return true;

case CT_GROUP:

case CT_IF:

case CT_FOR:

case CT_WHILE:

case CT_CASE:

return false;

}

UNREACHABLE();

}

/* Updates the contents of the `pipeinfo_T' to proceed to the next process

* execution. `pi->pi_fromprevfd' and `pi->pi_tonextfds[PIPE_OUT]' are closed,

* `pi->pi_tonextfds[PIPE_IN]' is moved to `pi->pi_fromprevfd', and,

* if `next' is true, a new pipe is opened in `pi->pi_tonextfds'; otherwise,

* `pi->pi_tonextfds' is assigned -1.

* Returns true iff successful. */

void next_pipe(pipeinfo_T *pi, bool next)

{

if (pi->pi_fromprevfd >= 0)

xclose(pi->pi_fromprevfd);

if (pi->pi_tonextfds[PIPE_OUT] >= 0)

xclose(pi->pi_tonextfds[PIPE_OUT]);

pi->pi_fromprevfd = pi->pi_tonextfds[PIPE_IN];

if (next) {

if (pipe(pi->pi_tonextfds) < 0)

goto fail;

/* The pipe's FDs must not be 0 or 1, or they may be overridden by each

* other when we move the pipe to the standard input/output later. So,

* if they are 0 or 1, we move them to bigger numbers. */

int origin = pi->pi_tonextfds[PIPE_IN];

int origout = pi->pi_tonextfds[PIPE_OUT];

if (origin < 2 || origout < 2) {

if (origin < 2)

pi->pi_tonextfds[PIPE_IN] = dup(origin);

if (origout < 2)

pi->pi_tonextfds[PIPE_OUT] = dup(origout);

if (origin < 2)

xclose(origin);

if (origout < 2)

xclose(origout);

if (pi->pi_tonextfds[PIPE_IN] < 0) {

xclose(pi->pi_tonextfds[PIPE_OUT]);

goto fail;

}

if (pi->pi_tonextfds[PIPE_OUT] < 0) {

xclose(pi->pi_tonextfds[PIPE_IN]);

goto fail;

}

}

} else {

pi->pi_tonextfds[PIPE_IN] = pi->pi_tonextfds[PIPE_OUT] = -1;

}

return;

fail:

pi->pi_tonextfds[PIPE_IN] = pi->pi_tonextfds[PIPE_OUT] = -1;

xerror(errno, Ngt("cannot open a pipe"));

}

/* Connects the pipe(s) and closes the pipes left. */

void connect_pipes(pipeinfo_T *pi)

{

if (pi->pi_fromprevfd >= 0) {

xdup2(pi->pi_fromprevfd, STDIN_FILENO);

xclose(pi->pi_fromprevfd);

}

if (pi->pi_tonextfds[PIPE_OUT] >= 0) {

xdup2(pi->pi_tonextfds[PIPE_OUT], STDOUT_FILENO);

xclose(pi->pi_tonextfds[PIPE_OUT]);

}

if (pi->pi_tonextfds[PIPE_IN] >= 0)

xclose(pi->pi_tonextfds[PIPE_IN]);

}

/* Executes the command. */

void exec_one_command(command_T *c, bool finally_exit)

{

/* prevent the command data from being freed in case the command is part of

* a function that is unset during execution. */

c = comsdup(c);

update_lineno(c->c_lineno);

if (c->c_type == CT_SIMPLE) {

exec_simple_command(c, finally_exit);

} else {

savefd_T *savefd;

if (open_redirections(c->c_redirs, &savefd)) {

exec_nonsimple_command(c, finally_exit && savefd == NULL);

undo_redirections(savefd);

} else {

undo_redirections(savefd);

laststatus = Exit_REDIRERR;

apply_errexit_errreturn(NULL);

}

}

comsfree(c);

if (finally_exit)

exit_shell();

}

/* Executes the simple command. */

void exec_simple_command(const command_T *c, bool finally_exit)

{

lastcmdsubstatus = Exit_SUCCESS;

/* expand the command words */

plist_T args = expand_line(c->c_words, c->c_isdeclutil);

if (args.contents == NULL) {

laststatus = Exit_EXPERROR;

goto done;

}

if (is_interrupted())

goto done1;

/* execute the remaining part */

if (args.length == 0)

finally_exit |= exec_simple_command_without_words(c);

else

finally_exit |= exec_simple_command_with_words(

c, args.length, args.contents, finally_exit);

/* cleanup */

done1:

plfree(pl_toary(&args), free);

done:

if (finally_exit)

/* If we're running the EXIT trap and the simple command failed with a

* shell error, we should exit with the current exit status indicating

* the error rather than the exit status saved just before entering the

* EXIT trap, so... */

exit_shell_with_status(laststatus); // rather than: exit_shell();

}

/* Executes the simple command that has no expanded words.

* Returns true if the shell should exit. */

bool exec_simple_command_without_words(const command_T *c)

{

/* perform assignments */

bool ok = do_assignments(c->c_assigns, false, false);

print_xtrace(NULL);

last_assign = c->c_assigns;

if (!ok) {

laststatus = Exit_ASSGNERR;

if (is_interactive_now) {

cancel_current_command();

return false;

}

return true;

}

/* done? */

if (c->c_redirs == NULL) {

laststatus = lastcmdsubstatus;

return false;

}

/* create a subshell to perform redirections in */

fork_and_wait_T faw = fork_and_wait(0);

if (faw.cpid != 0) {

/* parent process */

if (faw.namep != NULL)

*faw.namep = command_to_wcs(c, false);

return false;

}

/* open redirections in subshell */

savefd_T *savefd;

ok = open_redirections(c->c_redirs, &savefd);

undo_redirections(savefd);

exit_shell_with_status(ok ? lastcmdsubstatus : Exit_REDIRERR);

}

/* Executes the simple command that has one or more expanded words.

* `argv' must be a NULL-terminated array of pointers to wide strings that are

* the results of the word expansion on the simple command being executed.

* `argc' must be the number of words in `argv', which must be at least 1.

* If `finally_exit' is true, the shell process may be replaced by the command

* process. However, this function still may return in some cases.

* Returns true if the shell should exit. */

bool exec_simple_command_with_words(

const command_T *c, int argc, void **argv, bool finally_exit)

{

assert(argc > 0);

char *argv0 = malloc_wcstombs(argv[0]);

if (argv0 == NULL)

argv0 = xstrdup("");

/* open redirections */

savefd_T *savefd;

if (!open_redirections(c->c_redirs, &savefd)) {

/* On redirection error, the command is not executed. */

laststatus = Exit_REDIRERR;

if (posixly_correct && is_special_builtin(argv0)) {

if (is_interactive_now)

cancel_current_command();

else

finally_exit = true;

}

goto done;

}

last_assign = c->c_assigns;

/* check if the command is a special built-in or function */

commandinfo_T cmdinfo;

search_command(argv0, argv[0], &cmdinfo, SCT_BUILTIN | SCT_FUNCTION);

special_builtin_executed = (cmdinfo.type == CT_SPECIALBUILTIN);

/* open a temporary variable environment */

bool temp = c->c_assigns != NULL && !special_builtin_executed;

if (temp)

open_new_environment(true);

/* perform the assignments */

if (!do_assignments(c->c_assigns, temp, true)) {

/* On assignment error, the command is not executed. */

print_xtrace(NULL);

laststatus = Exit_ASSGNERR;

if (is_interactive_now)

cancel_current_command();

else

finally_exit = true;

goto done1;

}

print_xtrace(argv);

/* find command path */

if (cmdinfo.type == CT_NONE) {

search_command(argv0, argv[0], &cmdinfo,

SCT_EXTERNAL | SCT_BUILTIN | SCT_CHECK);

if (cmdinfo.type == CT_NONE) {

if (!posixly_correct && command_not_found_handler(argv))

goto done1;

if (wcschr(argv[0], L'/') != NULL) {

cmdinfo.type = CT_EXTERNALPROGRAM;

cmdinfo.ci_path = argv0;

}

}

}

/* execute! */

wchar_t **namep = invoke_simple_command(&cmdinfo, argc, argv0, argv,

finally_exit && /* !temp && */ savefd == NULL);

if (namep != NULL)

*namep = command_to_wcs(c, false);

/* Redirections are not undone after a successful "exec" command:

* remove the saved data of file descriptors. */

if (exec_builtin_executed && laststatus == Exit_SUCCESS) {

clear_savefd(savefd);

savefd = NULL;

}

exec_builtin_executed = false;

/* cleanup */

done1:

if (temp)

close_current_environment();

done:

undo_redirections(savefd);

free(argv0);

return finally_exit;

}

/* Returns a pointer to the xtrace buffer.

* The buffer is initialized if not. */

xwcsbuf_T *get_xtrace_buffer(void)

{

if (xtrace_buffer.contents == NULL)

wb_init(&xtrace_buffer);

return &xtrace_buffer;

}

/* Prints a trace if the "xtrace" option is on. */

void print_xtrace(void *const *argv)

{

static bool expanding_ps4 = false;

bool tracevars = xtrace_buffer.contents != NULL

&& xtrace_buffer.length > 0;

if (shopt_xtrace && !expanding_ps4

&& (!is_executing_auxiliary || shopt_traceall)

&& (tracevars || argv != NULL)

#if YASH_ENABLE_LINEEDIT

&& !(le_state & LE_STATE_ACTIVE)

#endif

) {

bool first = true;

// Disallow recursion in case $PS4 contains a command substitution

// that may trigger another xtrace, which would be an infinite loop

expanding_ps4 = true;

struct promptset_T prompt = get_prompt(4);

expanding_ps4 = false;

print_prompt(prompt.main);

print_prompt(prompt.styler);

if (tracevars) {

fprintf(stderr, "%ls", xtrace_buffer.contents + 1);

first = false;

}

if (argv != NULL) {

for (void *const *a = argv; *a != NULL; a++) {

if (!first)

fputc(' ', stderr);

first = false;

wchar_t *quoted = quote_as_word(*a);

fprintf(stderr, "%ls", quoted);

free(quoted);

}

}

fputc('\n', stderr);

print_prompt(PROMPT_RESET);

free_prompt(prompt);

}

if (xtrace_buffer.contents != NULL) {

wb_destroy(&xtrace_buffer);

xtrace_buffer.contents = NULL;

}

}

/* Searches for a command.

* The result is assigned to `*ci'.

* `name' and `wname' must contain the same string value.

* If the SCT_ALL flag is not set:

* * a function whose name contains a slash cannot be found

* * a substitutive built-in cannot be found if the SCT_EXTERNAL flag is not

* set either.

* If the SCT_EXTERNAL flag is set, the SCT_CHECK flag is not set, and `name'

* contains a slash, the external command of the given `name' is always found.

*/

void search_command(

const char *restrict name, const wchar_t *restrict wname,

commandinfo_T *restrict ci, enum srchcmdtype_T type)

{

bool slash = wcschr(wname, L'/') != NULL;

const builtin_T *bi;

if (!slash && (type & SCT_BUILTIN))

bi = get_builtin(name);

else

bi = NULL;

if (bi != NULL && bi->type == BI_SPECIAL) {

ci->type = CT_SPECIALBUILTIN;

ci->ci_builtin = bi->body;

return;

}

if ((type & SCT_FUNCTION) && (!slash || (type & SCT_ALL))) {

command_T *funcbody = get_function(wname);

if (funcbody != NULL) {

ci->type = CT_FUNCTION;

ci->ci_function = funcbody;

return;

}

}

if (bi != NULL) {

switch (bi->type) {

case BI_MANDATORY:

ci->type = CT_MANDATORYBUILTIN;

ci->ci_builtin = bi->body;

return;

case BI_ELECTIVE:

ci->type = CT_ELECTIVEBUILTIN;

ci->ci_builtin = bi->body;

return;

case BI_EXTENSION:

if (posixly_correct) {

bi = NULL;

break;

} else {

ci->type = CT_EXTENSIONBUILTIN;

ci->ci_builtin = bi->body;

return;

}

case BI_SPECIAL:

UNREACHABLE();

case BI_SUBSTITUTIVE:

break;

}

}

if (slash) {

if (type & SCT_EXTERNAL) {

if (!(type & SCT_CHECK) || is_executable_regular(name)) {

ci->type = CT_EXTERNALPROGRAM;

ci->ci_path = name;

return;

}

}

} else {

if ((type & SCT_EXTERNAL) || (bi != NULL && (type & SCT_ALL))) {

const char *cmdpath;

if (type & SCT_STDPATH)

cmdpath = get_command_path_default(name);

else

cmdpath = get_command_path(name, false);

if (cmdpath != NULL) {

if (bi != NULL) {

assert(bi->type == BI_SUBSTITUTIVE);

ci->type = CT_SUBSTITUTIVEBUILTIN;

ci->ci_builtin = bi->body;

} else {

ci->type = CT_EXTERNALPROGRAM;

ci->ci_path = cmdpath;