[thirdparty/bash.git] / copy_cmd.c

/* copy_command.c -- copy a COMMAND structure.  This is needed
   primarily for making function definitions, but I'm not sure
   that anyone else will need it.  */

/* Copyright (C) 1987-2009 Free Software Foundation, Inc.

   This file is part of GNU Bash, the Bourne Again SHell.

   Bash 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 3 of the License, or
   (at your option) any later version.

   Bash 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 Bash.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "config.h"

#include "bashtypes.h"

#if defined (HAVE_UNISTD_H)
#  include <unistd.h>
#endif

#include <stdio.h>

#include "shell.h"

static PATTERN_LIST *copy_case_clause __P((PATTERN_LIST *));
static PATTERN_LIST *copy_case_clauses __P((PATTERN_LIST *));
static FOR_COM *copy_for_command __P((FOR_COM *));
#if defined (ARITH_FOR_COMMAND)
static ARITH_FOR_COM *copy_arith_for_command __P((ARITH_FOR_COM *));
#endif
static GROUP_COM *copy_group_command __P((GROUP_COM *));
static SUBSHELL_COM *copy_subshell_command __P((SUBSHELL_COM *));
static COPROC_COM *copy_coproc_command __P((COPROC_COM *));
static CASE_COM *copy_case_command __P((CASE_COM *));
static WHILE_COM *copy_while_command __P((WHILE_COM *));
static IF_COM *copy_if_command __P((IF_COM *));
#if defined (DPAREN_ARITHMETIC)
static ARITH_COM *copy_arith_command __P((ARITH_COM *));
#endif
#if defined (COND_COMMAND)
static COND_COM *copy_cond_command __P((COND_COM *));
#endif
static SIMPLE_COM *copy_simple_command __P((SIMPLE_COM *));

WORD_DESC *
copy_word (w)
     WORD_DESC *w;
{
  WORD_DESC *new_word;

  new_word = make_bare_word (w->word);
  new_word->flags = w->flags;
  return (new_word);
}

/* Copy the chain of words in LIST.  Return a pointer to
   the new chain. */
WORD_LIST *
copy_word_list (list)
     WORD_LIST *list;
{
  WORD_LIST *new_list;

  for (new_list = (WORD_LIST *)NULL; list; list = list->next)
    new_list = make_word_list (copy_word (list->word), new_list);

  return (REVERSE_LIST (new_list, WORD_LIST *));
}

static PATTERN_LIST *
copy_case_clause (clause)
     PATTERN_LIST *clause;
{
  PATTERN_LIST *new_clause;

  new_clause = (PATTERN_LIST *)xmalloc (sizeof (PATTERN_LIST));
  new_clause->patterns = copy_word_list (clause->patterns);
  new_clause->action = copy_command (clause->action);
  new_clause->flags = clause->flags;
  return (new_clause);
}

static PATTERN_LIST *
copy_case_clauses (clauses)
     PATTERN_LIST *clauses;
{
  PATTERN_LIST *new_list, *new_clause;

  for (new_list = (PATTERN_LIST *)NULL; clauses; clauses = clauses->next)
    {
      new_clause = copy_case_clause (clauses);
      new_clause->next = new_list;
      new_list = new_clause;
    }
  return (REVERSE_LIST (new_list, PATTERN_LIST *));
}

/* Copy a single redirect. */
REDIRECT *
copy_redirect (redirect)
     REDIRECT *redirect;
{
  REDIRECT *new_redirect;

  new_redirect = (REDIRECT *)xmalloc (sizeof (REDIRECT));
#if 0
  FASTCOPY ((char *)redirect, (char *)new_redirect, (sizeof (REDIRECT)));
#else
  *new_redirect = *redirect;	/* let the compiler do the fast structure copy */
#endif

  if (redirect->rflags & REDIR_VARASSIGN)
    new_redirect->redirector.filename = copy_word (redirect->redirector.filename);

  switch (redirect->instruction)
    {
    case r_reading_until:
    case r_deblank_reading_until:
      new_redirect->here_doc_eof = redirect->here_doc_eof ? savestring (redirect->here_doc_eof) : 0;
      /*FALLTHROUGH*/
    case r_reading_string:
    case r_appending_to:
    case r_output_direction:
    case r_input_direction:
    case r_inputa_direction:
    case r_err_and_out:
    case r_append_err_and_out:
    case r_input_output:
    case r_output_force:
    case r_duplicating_input_word:
    case r_duplicating_output_word:
    case r_move_input_word:
    case r_move_output_word:
      new_redirect->redirectee.filename = copy_word (redirect->redirectee.filename);
      break;
    case r_duplicating_input:
    case r_duplicating_output:
    case r_move_input:
    case r_move_output:
    case r_close_this:
      break;
    }
  return (new_redirect);
}

REDIRECT *
copy_redirects (list)
     REDIRECT *list;
{
  REDIRECT *new_list, *temp;

  for (new_list = (REDIRECT *)NULL; list; list = list->next)
    {
      temp = copy_redirect (list);
      temp->next = new_list;
      new_list = temp;
    }
  return (REVERSE_LIST (new_list, REDIRECT *));
}

static FOR_COM *
copy_for_command (com)
     FOR_COM *com;
{
  FOR_COM *new_for;

  new_for = (FOR_COM *)xmalloc (sizeof (FOR_COM));
  new_for->flags = com->flags;
  new_for->line = com->line;
  new_for->name = copy_word (com->name);
  new_for->map_list = copy_word_list (com->map_list);
  new_for->action = copy_command (com->action);
  return (new_for);
}

#if defined (ARITH_FOR_COMMAND)
static ARITH_FOR_COM *
copy_arith_for_command (com)
     ARITH_FOR_COM *com;
{
  ARITH_FOR_COM *new_arith_for;

  new_arith_for = (ARITH_FOR_COM *)xmalloc (sizeof (ARITH_FOR_COM));
  new_arith_for->flags = com->flags;
  new_arith_for->line = com->line;
  new_arith_for->init = copy_word_list (com->init);
  new_arith_for->test = copy_word_list (com->test);
  new_arith_for->step = copy_word_list (com->step);
  new_arith_for->action = copy_command (com->action);
  return (new_arith_for);
}
#endif /* ARITH_FOR_COMMAND */

static GROUP_COM *
copy_group_command (com)
     GROUP_COM *com;
{
  GROUP_COM *new_group;

  new_group = (GROUP_COM *)xmalloc (sizeof (GROUP_COM));
  new_group->command = copy_command (com->command);
  return (new_group);
}

static SUBSHELL_COM *
copy_subshell_command (com)
     SUBSHELL_COM *com;
{
  SUBSHELL_COM *new_subshell;

  new_subshell = (SUBSHELL_COM *)xmalloc (sizeof (SUBSHELL_COM));
  new_subshell->command = copy_command (com->command);
  new_subshell->flags = com->flags;
  return (new_subshell);
}

static COPROC_COM *
copy_coproc_command (com)
     COPROC_COM *com;
{
  COPROC_COM *new_coproc;

  new_coproc = (COPROC_COM *)xmalloc (sizeof (COPROC_COM));
  new_coproc->name = savestring (com->name);
  new_coproc->command = copy_command (com->command);
  new_coproc->flags = com->flags;
  return (new_coproc);
}

static CASE_COM *
copy_case_command (com)
     CASE_COM *com;
{
  CASE_COM *new_case;

  new_case = (CASE_COM *)xmalloc (sizeof (CASE_COM));
  new_case->flags = com->flags;
  new_case->line = com->line;
  new_case->word = copy_word (com->word);
  new_case->clauses = copy_case_clauses (com->clauses);
  return (new_case);
}

static WHILE_COM *
copy_while_command (com)
     WHILE_COM *com;
{
  WHILE_COM *new_while;

  new_while = (WHILE_COM *)xmalloc (sizeof (WHILE_COM));
  new_while->flags = com->flags;
  new_while->test = copy_command (com->test);
  new_while->action = copy_command (com->action);
  return (new_while);
}

static IF_COM *
copy_if_command (com)
     IF_COM *com;
{
  IF_COM *new_if;

  new_if = (IF_COM *)xmalloc (sizeof (IF_COM));
  new_if->flags = com->flags;
  new_if->test = copy_command (com->test);
  new_if->true_case = copy_command (com->true_case);
  new_if->false_case = com->false_case ? copy_command (com->false_case) : com->false_case;
  return (new_if);
}

#if defined (DPAREN_ARITHMETIC)
static ARITH_COM *
copy_arith_command (com)
     ARITH_COM *com;
{
  ARITH_COM *new_arith;

  new_arith = (ARITH_COM *)xmalloc (sizeof (ARITH_COM));
  new_arith->flags = com->flags;
  new_arith->exp = copy_word_list (com->exp);
  new_arith->line = com->line;

  return (new_arith);
}
#endif

#if defined (COND_COMMAND)
static COND_COM *
copy_cond_command (com)
     COND_COM *com;
{
  COND_COM *new_cond;

  new_cond = (COND_COM *)xmalloc (sizeof (COND_COM));
  new_cond->flags = com->flags;
  new_cond->line = com->line;
  new_cond->type = com->type;
  new_cond->op = com->op ? copy_word (com->op) : com->op;
  new_cond->left = com->left ? copy_cond_command (com->left) : (COND_COM *)NULL;
  new_cond->right = com->right ? copy_cond_command (com->right) : (COND_COM *)NULL;

  return (new_cond);
}
#endif

static SIMPLE_COM *
copy_simple_command (com)
     SIMPLE_COM *com;
{
  SIMPLE_COM *new_simple;

  new_simple = (SIMPLE_COM *)xmalloc (sizeof (SIMPLE_COM));
  new_simple->flags = com->flags;
  new_simple->words = copy_word_list (com->words);
  new_simple->redirects = com->redirects ? copy_redirects (com->redirects) : (REDIRECT *)NULL;
  new_simple->line = com->line;
  return (new_simple);
}

FUNCTION_DEF *
copy_function_def_contents (old, new_def)
     FUNCTION_DEF *old, *new_def;
{
  new_def->name = copy_word (old->name);
  new_def->command = old->command ? copy_command (old->command) : old->command;
  new_def->flags = old->flags;
  new_def->line = old->line;
  new_def->source_file = old->source_file ? savestring (old->source_file) : old->source_file;
  return (new_def);
}

FUNCTION_DEF *
copy_function_def (com)
     FUNCTION_DEF *com;
{
  FUNCTION_DEF *new_def;

  new_def = (FUNCTION_DEF *)xmalloc (sizeof (FUNCTION_DEF));
  new_def = copy_function_def_contents (com, new_def);
  return (new_def);
}

/* Copy the command structure in COMMAND.  Return a pointer to the
   copy.  Don't you forget to dispose_command () on this pointer
   later! */
COMMAND *
copy_command (command)
     COMMAND *command;
{
  COMMAND *new_command;

  if (command == NULL)
    return (command);

  new_command = (COMMAND *)xmalloc (sizeof (COMMAND));
  FASTCOPY ((char *)command, (char *)new_command, sizeof (COMMAND));
  new_command->flags = command->flags;
  new_command->line = command->line;

  if (command->redirects)
    new_command->redirects = copy_redirects (command->redirects);

  switch (command->type)
    {
      case cm_for:
	new_command->value.For = copy_for_command (command->value.For);
	break;

#if defined (ARITH_FOR_COMMAND)
      case cm_arith_for:
	new_command->value.ArithFor = copy_arith_for_command (command->value.ArithFor);
	break;
#endif

#if defined (SELECT_COMMAND)
      case cm_select:
	new_command->value.Select =
	  (SELECT_COM *)copy_for_command ((FOR_COM *)command->value.Select);
	break;
#endif

      case cm_group:
	new_command->value.Group = copy_group_command (command->value.Group);
	break;

      case cm_subshell:
	new_command->value.Subshell = copy_subshell_command (command->value.Subshell);
	break;

      case cm_coproc:
	new_command->value.Coproc = copy_coproc_command (command->value.Coproc);
	break;

      case cm_case:
	new_command->value.Case = copy_case_command (command->value.Case);
	break;

      case cm_until:
      case cm_while:
	new_command->value.While = copy_while_command (command->value.While);
	break;

      case cm_if:
	new_command->value.If = copy_if_command (command->value.If);
	break;

#if defined (DPAREN_ARITHMETIC)
      case cm_arith:
	new_command->value.Arith = copy_arith_command (command->value.Arith);
	break;
#endif

#if defined (COND_COMMAND)
      case cm_cond:
	new_command->value.Cond = copy_cond_command (command->value.Cond);
	break;
#endif

      case cm_simple:
	new_command->value.Simple = copy_simple_command (command->value.Simple);
	break;

      case cm_connection:
	{
	  CONNECTION *new_connection;

	  new_connection = (CONNECTION *)xmalloc (sizeof (CONNECTION));
	  new_connection->connector = command->value.Connection->connector;
	  new_connection->first = copy_command (command->value.Connection->first);
	  new_connection->second = copy_command (command->value.Connection->second);
	  new_command->value.Connection = new_connection;
	  break;
	}

      case cm_function_def:
	new_command->value.Function_def = copy_function_def (command->value.Function_def);
	break;
    }
  return (new_command);
}
Commit	Line	Data
726f6388 JA	1	/* copy_command.c -- copy a COMMAND structure. This is needed
	2	primarily for making function definitions, but I'm not sure
	3	that anyone else will need it. */
	4
3185942a	5	/* Copyright (C) 1987-2009 Free Software Foundation, Inc.
726f6388 JA	6
	7	This file is part of GNU Bash, the Bourne Again SHell.
	8
3185942a JA	9	Bash is free software: you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation, either version 3 of the License, or
	12	(at your option) any later version.
726f6388	13
3185942a JA	14	Bash is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
726f6388 JA	18
726f6388 JA	19	You should have received a copy of the GNU General Public License
3185942a JA	20	along with Bash. If not, see <http://www.gnu.org/licenses/>.
3185942a JA	21	*/
726f6388	22
ccc6cda3 JA	23	#include "config.h"
ccc6cda3 JA	24
cce855bc	25	#include "bashtypes.h"
726f6388	26
ccc6cda3 JA	27	#if defined (HAVE_UNISTD_H)
	28	# include <unistd.h>
	29	#endif
	30
cce855bc JA	31	#include <stdio.h>
cce855bc JA	32
726f6388 JA	33	#include "shell.h"
726f6388 JA	34
f73dda09 JA	35	static PATTERN_LIST copy_case_clause __P((PATTERN_LIST ));
	36	static PATTERN_LIST copy_case_clauses __P((PATTERN_LIST ));
	37	static FOR_COM copy_for_command __P((FOR_COM ));
	38	#if defined (ARITH_FOR_COMMAND)
	39	static ARITH_FOR_COM copy_arith_for_command __P((ARITH_FOR_COM ));
	40	#endif
	41	static GROUP_COM copy_group_command __P((GROUP_COM ));
	42	static SUBSHELL_COM copy_subshell_command __P((SUBSHELL_COM ));
3185942a	43	static COPROC_COM copy_coproc_command __P((COPROC_COM ));
f73dda09 JA	44	static CASE_COM copy_case_command __P((CASE_COM ));
	45	static WHILE_COM copy_while_command __P((WHILE_COM ));
	46	static IF_COM copy_if_command __P((IF_COM ));
	47	#if defined (DPAREN_ARITHMETIC)
	48	static ARITH_COM copy_arith_command __P((ARITH_COM ));
	49	#endif
	50	#if defined (COND_COMMAND)
	51	static COND_COM copy_cond_command __P((COND_COM ));
	52	#endif
	53	static SIMPLE_COM copy_simple_command __P((SIMPLE_COM ));
f73dda09	54
726f6388	55	WORD_DESC *
cce855bc JA	56	copy_word (w)
cce855bc JA	57	WORD_DESC *w;
726f6388	58	{
ccc6cda3 JA	59	WORD_DESC *new_word;
ccc6cda3 JA	60
7117c2d2	61	new_word = make_bare_word (w->word);
28ef6c31	62	new_word->flags = w->flags;
726f6388 JA	63	return (new_word);
	64	}
	65
ccc6cda3	66	/* Copy the chain of words in LIST. Return a pointer to
726f6388 JA	67	the new chain. */
	68	WORD_LIST *
	69	copy_word_list (list)
	70	WORD_LIST *list;
	71	{
7117c2d2	72	WORD_LIST *new_list;
726f6388	73
ccc6cda3	74	for (new_list = (WORD_LIST *)NULL; list; list = list->next)
7117c2d2 JA	75	new_list = make_word_list (copy_word (list->word), new_list);
7117c2d2 JA	76
726f6388 JA	77	return (REVERSE_LIST (new_list, WORD_LIST *));
	78	}
	79
	80	static PATTERN_LIST *
	81	copy_case_clause (clause)
	82	PATTERN_LIST *clause;
	83	{
ccc6cda3 JA	84	PATTERN_LIST *new_clause;
	85
	86	new_clause = (PATTERN_LIST *)xmalloc (sizeof (PATTERN_LIST));
726f6388 JA	87	new_clause->patterns = copy_word_list (clause->patterns);
726f6388 JA	88	new_clause->action = copy_command (clause->action);
3185942a	89	new_clause->flags = clause->flags;
726f6388 JA	90	return (new_clause);
	91	}
	92
	93	static PATTERN_LIST *
	94	copy_case_clauses (clauses)
	95	PATTERN_LIST *clauses;
	96	{
ccc6cda3	97	PATTERN_LIST new_list, new_clause;
726f6388	98
ccc6cda3	99	for (new_list = (PATTERN_LIST *)NULL; clauses; clauses = clauses->next)
726f6388	100	{
ccc6cda3	101	new_clause = copy_case_clause (clauses);
726f6388 JA	102	new_clause->next = new_list;
726f6388 JA	103	new_list = new_clause;
726f6388 JA	104	}
	105	return (REVERSE_LIST (new_list, PATTERN_LIST *));
	106	}
	107
	108	/* Copy a single redirect. */
	109	REDIRECT *
	110	copy_redirect (redirect)
	111	REDIRECT *redirect;
	112	{
ccc6cda3 JA	113	REDIRECT *new_redirect;
	114
	115	new_redirect = (REDIRECT *)xmalloc (sizeof (REDIRECT));
0001803f	116	#if 0
726f6388	117	FASTCOPY ((char )redirect, (char )new_redirect, (sizeof (REDIRECT)));
0001803f CR	118	#else
	119	new_redirect = redirect; /* let the compiler do the fast structure copy */
	120	#endif
	121
	122	if (redirect->rflags & REDIR_VARASSIGN)
	123	new_redirect->redirector.filename = copy_word (redirect->redirector.filename);
	124
726f6388 JA	125	switch (redirect->instruction)
	126	{
	127	case r_reading_until:
	128	case r_deblank_reading_until:
13db572a	129	new_redirect->here_doc_eof = redirect->here_doc_eof ? savestring (redirect->here_doc_eof) : 0;
ccc6cda3	130	/FALLTHROUGH/
7117c2d2	131	case r_reading_string:
726f6388 JA	132	case r_appending_to:
	133	case r_output_direction:
	134	case r_input_direction:
	135	case r_inputa_direction:
	136	case r_err_and_out:
3185942a	137	case r_append_err_and_out:
726f6388 JA	138	case r_input_output:
	139	case r_output_force:
	140	case r_duplicating_input_word:
	141	case r_duplicating_output_word:
7117c2d2 JA	142	case r_move_input_word:
7117c2d2 JA	143	case r_move_output_word:
ccc6cda3	144	new_redirect->redirectee.filename = copy_word (redirect->redirectee.filename);
726f6388	145	break;
d166f048 JA	146	case r_duplicating_input:
d166f048 JA	147	case r_duplicating_output:
7117c2d2 JA	148	case r_move_input:
7117c2d2 JA	149	case r_move_output:
d166f048 JA	150	case r_close_this:
d166f048 JA	151	break;
726f6388 JA	152	}
	153	return (new_redirect);
	154	}
ccc6cda3	155
726f6388 JA	156	REDIRECT *
	157	copy_redirects (list)
	158	REDIRECT *list;
	159	{
ccc6cda3	160	REDIRECT new_list, temp;
726f6388	161
ccc6cda3	162	for (new_list = (REDIRECT *)NULL; list; list = list->next)
726f6388	163	{
ccc6cda3	164	temp = copy_redirect (list);
726f6388 JA	165	temp->next = new_list;
726f6388 JA	166	new_list = temp;
726f6388 JA	167	}
	168	return (REVERSE_LIST (new_list, REDIRECT *));
	169	}
ccc6cda3	170
726f6388 JA	171	static FOR_COM *
	172	copy_for_command (com)
	173	FOR_COM *com;
	174	{
ccc6cda3 JA	175	FOR_COM *new_for;
	176
	177	new_for = (FOR_COM *)xmalloc (sizeof (FOR_COM));
726f6388	178	new_for->flags = com->flags;
b80f6443	179	new_for->line = com->line;
726f6388 JA	180	new_for->name = copy_word (com->name);
	181	new_for->map_list = copy_word_list (com->map_list);
	182	new_for->action = copy_command (com->action);
	183	return (new_for);
	184	}
	185
bb70624e JA	186	#if defined (ARITH_FOR_COMMAND)
	187	static ARITH_FOR_COM *
	188	copy_arith_for_command (com)
	189	ARITH_FOR_COM *com;
	190	{
	191	ARITH_FOR_COM *new_arith_for;
	192
	193	new_arith_for = (ARITH_FOR_COM *)xmalloc (sizeof (ARITH_FOR_COM));
	194	new_arith_for->flags = com->flags;
	195	new_arith_for->line = com->line;
	196	new_arith_for->init = copy_word_list (com->init);
	197	new_arith_for->test = copy_word_list (com->test);
	198	new_arith_for->step = copy_word_list (com->step);
	199	new_arith_for->action = copy_command (com->action);
	200	return (new_arith_for);
	201	}
	202	#endif /* ARITH_FOR_COMMAND */
	203
726f6388 JA	204	static GROUP_COM *
	205	copy_group_command (com)
	206	GROUP_COM *com;
	207	{
ccc6cda3	208	GROUP_COM *new_group;
726f6388	209
ccc6cda3	210	new_group = (GROUP_COM *)xmalloc (sizeof (GROUP_COM));
726f6388 JA	211	new_group->command = copy_command (com->command);
	212	return (new_group);
	213	}
	214
bb70624e JA	215	static SUBSHELL_COM *
	216	copy_subshell_command (com)
	217	SUBSHELL_COM *com;
	218	{
	219	SUBSHELL_COM *new_subshell;
	220
	221	new_subshell = (SUBSHELL_COM *)xmalloc (sizeof (SUBSHELL_COM));
	222	new_subshell->command = copy_command (com->command);
	223	new_subshell->flags = com->flags;
	224	return (new_subshell);
	225	}
	226
3185942a JA	227	static COPROC_COM *
	228	copy_coproc_command (com)
	229	COPROC_COM *com;
	230	{
	231	COPROC_COM *new_coproc;
	232
	233	new_coproc = (COPROC_COM *)xmalloc (sizeof (COPROC_COM));
	234	new_coproc->name = savestring (com->name);
	235	new_coproc->command = copy_command (com->command);
	236	new_coproc->flags = com->flags;
	237	return (new_coproc);
	238	}
	239
726f6388 JA	240	static CASE_COM *
	241	copy_case_command (com)
	242	CASE_COM *com;
	243	{
ccc6cda3	244	CASE_COM *new_case;
726f6388	245
ccc6cda3	246	new_case = (CASE_COM *)xmalloc (sizeof (CASE_COM));
726f6388	247	new_case->flags = com->flags;
b80f6443	248	new_case->line = com->line;
726f6388 JA	249	new_case->word = copy_word (com->word);
	250	new_case->clauses = copy_case_clauses (com->clauses);
	251	return (new_case);
	252	}
	253
	254	static WHILE_COM *
	255	copy_while_command (com)
	256	WHILE_COM *com;
	257	{
ccc6cda3	258	WHILE_COM *new_while;
726f6388	259
ccc6cda3	260	new_while = (WHILE_COM *)xmalloc (sizeof (WHILE_COM));
726f6388 JA	261	new_while->flags = com->flags;
	262	new_while->test = copy_command (com->test);
	263	new_while->action = copy_command (com->action);
	264	return (new_while);
	265	}
	266
	267	static IF_COM *
	268	copy_if_command (com)
	269	IF_COM *com;
	270	{
ccc6cda3	271	IF_COM *new_if;
726f6388	272
ccc6cda3	273	new_if = (IF_COM *)xmalloc (sizeof (IF_COM));
726f6388 JA	274	new_if->flags = com->flags;
	275	new_if->test = copy_command (com->test);
	276	new_if->true_case = copy_command (com->true_case);
7117c2d2	277	new_if->false_case = com->false_case ? copy_command (com->false_case) : com->false_case;
726f6388 JA	278	return (new_if);
	279	}
	280
cce855bc JA	281	#if defined (DPAREN_ARITHMETIC)
	282	static ARITH_COM *
	283	copy_arith_command (com)
	284	ARITH_COM *com;
	285	{
	286	ARITH_COM *new_arith;
	287
	288	new_arith = (ARITH_COM *)xmalloc (sizeof (ARITH_COM));
	289	new_arith->flags = com->flags;
	290	new_arith->exp = copy_word_list (com->exp);
	291	new_arith->line = com->line;
	292
	293	return (new_arith);
	294	}
	295	#endif
	296
	297	#if defined (COND_COMMAND)
	298	static COND_COM *
	299	copy_cond_command (com)
	300	COND_COM *com;
	301	{
	302	COND_COM *new_cond;
	303
	304	new_cond = (COND_COM *)xmalloc (sizeof (COND_COM));
	305	new_cond->flags = com->flags;
	306	new_cond->line = com->line;
bc4cd23c JA	307	new_cond->type = com->type;
bc4cd23c JA	308	new_cond->op = com->op ? copy_word (com->op) : com->op;
cce855bc JA	309	new_cond->left = com->left ? copy_cond_command (com->left) : (COND_COM *)NULL;
	310	new_cond->right = com->right ? copy_cond_command (com->right) : (COND_COM *)NULL;
	311
	312	return (new_cond);
	313	}
	314	#endif
	315
726f6388 JA	316	static SIMPLE_COM *
	317	copy_simple_command (com)
	318	SIMPLE_COM *com;
	319	{
cce855bc	320	SIMPLE_COM *new_simple;
726f6388	321
cce855bc	322	new_simple = (SIMPLE_COM *)xmalloc (sizeof (SIMPLE_COM));
726f6388 JA	323	new_simple->flags = com->flags;
726f6388 JA	324	new_simple->words = copy_word_list (com->words);
7117c2d2	325	new_simple->redirects = com->redirects ? copy_redirects (com->redirects) : (REDIRECT *)NULL;
726f6388 JA	326	new_simple->line = com->line;
	327	return (new_simple);
	328	}
	329
b80f6443 JA	330	FUNCTION_DEF *
	331	copy_function_def_contents (old, new_def)
	332	FUNCTION_DEF old, new_def;
	333	{
	334	new_def->name = copy_word (old->name);
	335	new_def->command = old->command ? copy_command (old->command) : old->command;
	336	new_def->flags = old->flags;
	337	new_def->line = old->line;
	338	new_def->source_file = old->source_file ? savestring (old->source_file) : old->source_file;
	339	return (new_def);
	340	}
	341
	342	FUNCTION_DEF *
726f6388 JA	343	copy_function_def (com)
	344	FUNCTION_DEF *com;
	345	{
ccc6cda3	346	FUNCTION_DEF *new_def;
726f6388	347
ccc6cda3	348	new_def = (FUNCTION_DEF *)xmalloc (sizeof (FUNCTION_DEF));
b80f6443	349	new_def = copy_function_def_contents (com, new_def);
726f6388 JA	350	return (new_def);
	351	}
	352
	353	/* Copy the command structure in COMMAND. Return a pointer to the
	354	copy. Don't you forget to dispose_command () on this pointer
	355	later! */
	356	COMMAND *
	357	copy_command (command)
	358	COMMAND *command;
	359	{
ccc6cda3	360	COMMAND *new_command;
726f6388	361
ccc6cda3 JA	362	if (command == NULL)
ccc6cda3 JA	363	return (command);
726f6388	364
ccc6cda3 JA	365	new_command = (COMMAND *)xmalloc (sizeof (COMMAND));
	366	FASTCOPY ((char )command, (char )new_command, sizeof (COMMAND));
	367	new_command->flags = command->flags;
	368	new_command->line = command->line;
726f6388	369
ccc6cda3 JA	370	if (command->redirects)
	371	new_command->redirects = copy_redirects (command->redirects);
	372
	373	switch (command->type)
	374	{
	375	case cm_for:
	376	new_command->value.For = copy_for_command (command->value.For);
	377	break;
726f6388	378
bb70624e JA	379	#if defined (ARITH_FOR_COMMAND)
	380	case cm_arith_for:
	381	new_command->value.ArithFor = copy_arith_for_command (command->value.ArithFor);
	382	break;
	383	#endif
	384
726f6388	385	#if defined (SELECT_COMMAND)
ccc6cda3 JA	386	case cm_select:
	387	new_command->value.Select =
	388	(SELECT_COM )copy_for_command ((FOR_COM )command->value.Select);
	389	break;
726f6388 JA	390	#endif
726f6388 JA	391
ccc6cda3 JA	392	case cm_group:
	393	new_command->value.Group = copy_group_command (command->value.Group);
	394	break;
726f6388	395
bb70624e	396	case cm_subshell:
28ef6c31 JA	397	new_command->value.Subshell = copy_subshell_command (command->value.Subshell);
28ef6c31 JA	398	break;
bb70624e	399
3185942a JA	400	case cm_coproc:
	401	new_command->value.Coproc = copy_coproc_command (command->value.Coproc);
	402	break;
	403
ccc6cda3 JA	404	case cm_case:
	405	new_command->value.Case = copy_case_command (command->value.Case);
	406	break;
	407
	408	case cm_until:
	409	case cm_while:
	410	new_command->value.While = copy_while_command (command->value.While);
	411	break;
	412
	413	case cm_if:
	414	new_command->value.If = copy_if_command (command->value.If);
	415	break;
	416
cce855bc JA	417	#if defined (DPAREN_ARITHMETIC)
cce855bc JA	418	case cm_arith:
28ef6c31 JA	419	new_command->value.Arith = copy_arith_command (command->value.Arith);
28ef6c31 JA	420	break;
cce855bc JA	421	#endif
	422
	423	#if defined (COND_COMMAND)
	424	case cm_cond:
	425	new_command->value.Cond = copy_cond_command (command->value.Cond);
	426	break;
	427	#endif
	428
ccc6cda3 JA	429	case cm_simple:
	430	new_command->value.Simple = copy_simple_command (command->value.Simple);
	431	break;
	432
	433	case cm_connection:
	434	{
	435	CONNECTION *new_connection;
	436
	437	new_connection = (CONNECTION *)xmalloc (sizeof (CONNECTION));
	438	new_connection->connector = command->value.Connection->connector;
	439	new_connection->first = copy_command (command->value.Connection->first);
	440	new_connection->second = copy_command (command->value.Connection->second);
	441	new_command->value.Connection = new_connection;
726f6388 JA	442	break;
726f6388 JA	443	}
ccc6cda3 JA	444
	445	case cm_function_def:
	446	new_command->value.Function_def = copy_function_def (command->value.Function_def);
	447	break;
726f6388 JA	448	}
	449	return (new_command);
	450	}