bin/sh/nodes.c.pat

   1 /*-
   2  * Copyright (c) 1991, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Kenneth Almquist.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by the University of
  19  *      California, Berkeley and its contributors.
  20  * 4. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  *      @(#)nodes.c.pat 8.2 (Berkeley) 5/4/95
  37  * $FreeBSD: src/bin/sh/nodes.c.pat,v 1.7.2.1 2002/07/19 04:38:52 tjr Exp $
  38  */
  39
  40 #include <stdlib.h>
  41 /*
  42  * Routine for dealing with parsed shell commands.
  43  */
  44
  45 #include "shell.h"
  46 #include "nodes.h"
  47 #include "memalloc.h"
  48 #include "machdep.h"
  49 #include "mystring.h"
  50
  51
  52 int     funcblocksize;          /* size of structures in function */
  53 int     funcstringsize;         /* size of strings in node */
  54 pointer funcblock;              /* block to allocate function from */
  55 char   *funcstring;             /* block to allocate strings from */
  56
  57 %SIZES
  58
  59
  60 STATIC void calcsize(union node *);
  61 STATIC void sizenodelist(struct nodelist *);
  62 STATIC union node *copynode(union node *);
  63 STATIC struct nodelist *copynodelist(struct nodelist *);
  64 STATIC char *nodesavestr(char *);
  65
  66
  67
  68 /*
  69  * Make a copy of a parse tree.
  70  */
  71
  72 union node *
  73 copyfunc(union node *n)
  74 {
  75         if (n == NULL)
  76                 return NULL;
  77         funcblocksize = 0;
  78         funcstringsize = 0;
  79         calcsize(n);
  80         funcblock = ckmalloc(funcblocksize + funcstringsize);
  81         funcstring = (char *)funcblock + funcblocksize;
  82         return copynode(n);
  83 }
  84
  85
  86
  87 STATIC void
  88 calcsize(union node *n)
  89 {
  90         %CALCSIZE
  91 }
  92
  93
  94
  95 STATIC void
  96 sizenodelist(struct nodelist *lp)
  97 {
  98         while (lp) {
  99                 funcblocksize += ALIGN(sizeof(struct nodelist));
 100                 calcsize(lp->n);
 101                 lp = lp->next;
 102         }
 103 }
 104
 105
 106
 107 STATIC union node *
 108 copynode(union node *n)
 109 {
 110         union node *new;
 111
 112         %COPY
 113         return new;
 114 }
 115
 116
 117 STATIC struct nodelist *
 118 copynodelist(struct nodelist *lp)
 119 {
 120         struct nodelist *start;
 121         struct nodelist **lpp;
 122
 123         lpp = &start;
 124         while (lp) {
 125                 *lpp = funcblock;
 126                 funcblock = (char *)funcblock + ALIGN(sizeof(struct nodelist));
 127                 (*lpp)->n = copynode(lp->n);
 128                 lp = lp->next;
 129                 lpp = &(*lpp)->next;
 130         }
 131         *lpp = NULL;
 132         return start;
 133 }
 134
 135
 136
 137 STATIC char *
 138 nodesavestr(char *s)
 139 {
 140         char *p = s;
 141         char *q = funcstring;
 142         char   *rtn = funcstring;
 143
 144         while ((*q++ = *p++) != '\0')
 145                 continue;
 146         funcstring = q;
 147         return rtn;
 148 }
 149
 150
 151
 152 /*
 153  * Free a parse tree.
 154  */
 155
 156 void
 157 freefunc(union node *n)
 158 {
 159         if (n)
 160                 ckfree(n);
 161 }