[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,1991 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 2, 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; see the file COPYING.  If not, write to the Free
   Software Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */

#include "config.h"

#include "bashtypes.h"

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

#include <stdio.h>

#include "shell.h"

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

  new_word = (WORD_DESC *)xmalloc (sizeof (WORD_DESC));
  FASTCOPY ((char *)w, (char *)new_word, sizeof (WORD_DESC));
  new_word->word = savestring (w->word);
  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, *temp;

  for (new_list = (WORD_LIST *)NULL; list; list = list->next)
    {
      temp = (WORD_LIST *)xmalloc (sizeof (WORD_LIST));
      temp->next = new_list;
      new_list = temp;
      new_list->word = copy_word (list->word);
    }
  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);
  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));
  FASTCOPY ((char *)redirect, (char *)new_redirect, (sizeof (REDIRECT)));
  switch (redirect->instruction)
    {
    case r_reading_until:
    case r_deblank_reading_until:
      new_redirect->here_doc_eof = savestring (redirect->here_doc_eof);
      /*FALLTHROUGH*/
    case r_appending_to:
    case r_output_direction:
    case r_input_direction:
    case r_inputa_direction:
    case r_err_and_out:
    case r_input_output:
    case r_output_force:
    case r_duplicating_input_word:
    case r_duplicating_output_word:
      new_redirect->redirectee.filename = copy_word (redirect->redirectee.filename);
      break;
    case r_duplicating_input:
    case r_duplicating_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->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 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->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 = copy_command (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 = copy_redirects (com->redirects);
  new_simple->line = com->line;
  return (new_simple);
}

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

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