home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / bash-1.12 / dispose_cmd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-20  |  3.8 KB  |  185 lines
  1. /* dispose_command.c -- dispose of a COMMAND structure. */
  2.  
  3. /* Copyright (C) 1987,1991 Free Software Foundation, Inc.
  4.  
  5.    This file is part of GNU Bash, the Bourne Again SHell.
  6.  
  7.    Bash is free software; you can redistribute it and/or modify it
  8.    under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 1, or (at your option)
  10.    any later version.
  11.  
  12.    Bash is distributed in the hope that it will be useful, but WITHOUT
  13.    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14.    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  15.    License for more details.
  16.  
  17.    You should have received a copy of the GNU General Public License
  18.    along with Bash; see the file COPYING.  If not, write to the Free
  19.    Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  20.  
  21. #include "shell.h"
  22.  
  23. /* Dispose of the command structure passed. */
  24. void
  25. dispose_command (command)
  26.      register COMMAND *command;
  27. {
  28.   if (!command) return;
  29.  
  30.   if (command->redirects)
  31.     dispose_redirects (command->redirects);
  32.  
  33.   switch (command->type)
  34.     {
  35.     case cm_for:
  36.       {
  37.     register FOR_COM *c = command->value.For;
  38.     dispose_word (c->name);
  39.     dispose_words (c->map_list);
  40.     dispose_command (c->action);
  41.     free (c);
  42.     break;
  43.       }
  44.     
  45.     case cm_group:
  46.       {
  47.     dispose_command (command->value.Group->command);
  48.     break;
  49.       }
  50.  
  51.     case cm_case:
  52.       {
  53.     register CASE_COM *c = command->value.Case;
  54.     PATTERN_LIST *t, *p = c->clauses;
  55.     dispose_word (c->word);
  56.     while (p) {
  57.       dispose_words (p->patterns);
  58.       dispose_command (p->action);
  59.       t = p;
  60.       p = p->next;
  61.       free (t);
  62.     }
  63.     break;
  64.       }
  65.  
  66.     case cm_until:
  67.     case cm_while:
  68.       {
  69.     register WHILE_COM *c = command->value.While;
  70.     dispose_command (c->test);
  71.     dispose_command (c->action);
  72.     free (c);
  73.     break;
  74.       }
  75.  
  76.     case cm_if:
  77.       {
  78.     register IF_COM *c = command->value.If;
  79.     dispose_command (c->test);
  80.     dispose_command (c->true_case);
  81.     dispose_command (c->false_case);
  82.     free (c);
  83.     break;
  84.       }
  85.  
  86.     case cm_simple:
  87.       {
  88.     register SIMPLE_COM *c = command->value.Simple;
  89.     dispose_words (c->words);
  90.     dispose_redirects (c->redirects);
  91.     free (c);
  92.     break;
  93.       }
  94.  
  95.     case cm_connection:
  96.       {
  97.     register CONNECTION *c = command->value.Connection;
  98.     dispose_command (c->first);
  99.     dispose_command (c->second);
  100.     free (c);
  101.     break;
  102.       }
  103.  
  104.     case cm_function_def:
  105.       {
  106.     register FUNCTION_DEF *c = command->value.Function_def;
  107.     dispose_word (c->name);
  108.     dispose_command (c->command);
  109.     free (c);
  110.     break;
  111.       }
  112.  
  113.     default:
  114.       report_error ("Attempt to free unknown command type `%d'.\n", command->type);
  115.       break;
  116.     }
  117.   free (command);
  118. }
  119.  
  120. /* How to free a WORD_DESC. */
  121. dispose_word (word)
  122.      WORD_DESC *word;
  123. {
  124.   free (word->word);
  125.   free (word);
  126. }
  127.  
  128. /* How to get rid of a linked list of words.  A WORD_LIST. */
  129. dispose_words (list)
  130.      WORD_LIST *list;
  131. {
  132.   WORD_LIST *t;
  133.   while (list)
  134.     {
  135.       t = list;
  136.       list = list->next;
  137.       dispose_word (t->word);
  138.       free (t);
  139.     }
  140. }
  141.  
  142. /* How to dispose of an array of pointers to char. */
  143. dispose_word_array (array)
  144.      char **array;
  145. {
  146.   register int count;
  147.  
  148.   for (count = 0; array[count]; count++)
  149.     free (array[count]);
  150.  
  151.   free (array);
  152. }
  153.  
  154. /* How to dispose of an list of redirections.  A REDIRECT. */
  155. dispose_redirects (list)
  156.      REDIRECT *list;
  157. {
  158.   register REDIRECT *t;
  159.  
  160.   while (list)
  161.     {
  162.       t = list;
  163.       list = list->next;
  164.       switch (t->instruction)
  165.     {
  166.     case r_reading_until:
  167.     case r_deblank_reading_until:
  168.       free (t->here_doc_eof);
  169.       /* ... */
  170.     case r_output_direction:
  171.     case r_input_direction:
  172.     case r_inputa_direction:
  173.     case r_appending_to:
  174.     case r_err_and_out:
  175.     case r_input_output:
  176.     case r_output_force:
  177.     case r_duplicating_input_word:
  178.     case r_duplicating_output_word:
  179.       dispose_word (t->redirectee.filename);
  180.       break;
  181.     }
  182.       free (t);
  183.     }
  184. }
  185.