Mirrors/fish-shell
2
0
Fork 0
mirror of https://github.com/fish-shell/fish-shell synced 2024-12-25 20:33:08 +00:00
Code Issues Projects Releases Packages Wiki Activity

Remove INTERNAL_BUFFER, which was only used by fish_pager

Browse source
This commit is contained in:
ridiculousfish 2014-09-22 10:16:16 -07:00
parent cb40507b7b
commit e5aa06991e
2 changed files with 5 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

67
exec.cpp
View file

@ -603,11 +603,7 @@ void exec_job(parser_t &parser, job_t *j)
debug(4, L"Exec job '%ls' with id %d", j->command_wcstr(), j->job_id);
/* PCA Here we detect the special case of an input buffer redirection, i.e. we want a process to receive data that we hold in a buffer (it is an INPUT for the process, but an output for fish). This is extremely rare: I believe only run_pager creates these and it would be nice to dump it. So we can only have at most one.
It would be great to wean fish_pager off of input redirections so that we can dump input redirections and the INTERNAL_BUFFER process type altogether.
*/
const io_buffer_t *single_magic_input_redirect = NULL;
/* Verify that all IO_BUFFERs are output. We used to support a (single, hacked-in) magical input IO_BUFFER used by fish_pager, but now the claim is that there are no more clients and it is removed. This assertion double-checks that. */
const io_chain_t all_ios = j->all_io_redirections();
for (size_t idx = 0; idx < all_ios.size(); idx++)
{
@ -616,23 +612,7 @@ void exec_job(parser_t &parser, job_t *j)
if ((io->io_mode == IO_BUFFER))
{
CAST_INIT(io_buffer_t *, io_buffer, io.get());
if (io_buffer->is_input)
{
/* We expect to have at most one of these, per the comment above. Note that this assertion is the only reason we don't break out of the loop below */
assert(single_magic_input_redirect == NULL && "Should have at most one input IO_BUFFER");
/*
Input redirection - create a new gobetween process to take
care of buffering, save the redirection in input_redirect
*/
process_t *fake = new process_t();
fake->type = INTERNAL_BUFFER;
fake->pipe_write_fd = STDOUT_FILENO;
j->first_process->pipe_read_fd = io->fd;
fake->next = j->first_process;
j->first_process = fake;
single_magic_input_redirect = io_buffer;
}
assert(! io_buffer->is_input);
}
}
@ -1118,11 +1098,6 @@ void exec_job(parser_t &parser, job_t *j)
/* We should have handled exec up above */
assert(0 && "INTERNAL_EXEC process found in pipeline, where it should never be. Aborting.");
break;
case INTERNAL_BUFFER:
/* Internal buffers are handled in the next switch statement below */
break;
}
if (exec_error)
@ -1214,44 +1189,6 @@ void exec_job(parser_t &parser, job_t *j)
}
case INTERNAL_BUFFER:
{
assert(single_magic_input_redirect != NULL);
const char *buffer = single_magic_input_redirect->out_buffer_ptr();
size_t count = single_magic_input_redirect->out_buffer_size();
/* We don't have to drain threads here because our child process is simple */
if (g_log_forks)
{
printf("fork #%d: Executing fork for internal buffer for '%ls'\n", g_fork_count, p->argv0() ? p->argv0() : L"(null)");
}
pid = execute_fork(false);
if (pid == 0)
{
/*
This is the child process. Write out the
contents of the pipeline.
*/
p->pid = getpid();
setup_child_process(j, p, process_net_io_chain);
exec_write_and_exit(1, buffer, count, 0);
}
else
{
/*
This is the parent process. Store away
information on the child, and possibly give
it control over the terminal.
*/
p->pid = pid;
set_child_group(j, p, 0);
}
break;
}
case INTERNAL_BUILTIN:
{
/*

12
proc.h
View file

@ -80,12 +80,7 @@ enum process_type_t
/**
The exec builtin
*/
INTERNAL_EXEC,
/**
A buffer
*/
INTERNAL_BUFFER,
INTERNAL_EXEC
};
enum
@ -105,8 +100,7 @@ enum
commands to be evaluated by calling eval. Lastly, this process can
be the result of an exec command. The role of this process_t is
determined by the type field, which can be one of EXTERNAL,
INTERNAL_BUILTIN, INTERNAL_FUNCTION, INTERNAL_BLOCK, INTERNAL_EXEC,
and INTERNAL_BUFFER.
INTERNAL_BUILTIN, INTERNAL_FUNCTION, INTERNAL_BLOCK, INTERNAL_EXEC.
The process_t contains information on how the process should be
started, such as command name and arguments, as well as runtime
@ -153,7 +147,7 @@ public:
/**
Type of process. Can be one of \c EXTERNAL, \c
INTERNAL_BUILTIN, \c INTERNAL_FUNCTION, \c INTERNAL_BLOCK,
INTERNAL_EXEC, or INTERNAL_BUFFER
INTERNAL_EXEC
*/
enum process_type_t type;