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  * $DragonFly: src/bin/sh/nodes.c.pat,v 1.2 2003/06/17 04:22:50 dillon Exp $
  39  */
  40
  41 #include <stdlib.h>
  42 /*
  43  * Routine for dealing with parsed shell commands.
  44  */
  45
  46 #include "shell.h"
  47 #include "nodes.h"
  48 #include "memalloc.h"
  49 #include "machdep.h"
  50 #include "mystring.h"
  51
  52
  53 int     funcblocksize;          /* size of structures in function */
  54 int     funcstringsize;         /* size of strings in node */
  55 pointer funcblock;              /* block to allocate function from */
  56 char   *funcstring;             /* block to allocate strings from */
  57
  58 %SIZES
  59
  60
  61 STATIC void calcsize(union node *);
  62 STATIC void sizenodelist(struct nodelist *);
  63 STATIC union node *copynode(union node *);
  64 STATIC struct nodelist *copynodelist(struct nodelist *);
  65 STATIC char *nodesavestr(char *);
  66
  67
  68
  69 /*
  70  * Make a copy of a parse tree.
  71  */
  72
  73 union node *
  74 copyfunc(union node *n)
  75 {
  76         if (n == NULL)
  77                 return NULL;
  78         funcblocksize = 0;
  79         funcstringsize = 0;
  80         calcsize(n);
  81         funcblock = ckmalloc(funcblocksize + funcstringsize);
  82         funcstring = (char *)funcblock + funcblocksize;
  83         return copynode(n);
  84 }
  85
  86
  87
  88 STATIC void
  89 calcsize(union node *n)
  90 {
  91         %CALCSIZE
  92 }
  93
  94
  95
  96 STATIC void
  97 sizenodelist(struct nodelist *lp)
  98 {
  99         while (lp) {
 100                 funcblocksize += ALIGN(sizeof(struct nodelist));
 101                 calcsize(lp->n);
 102                 lp = lp->next;
 103         }
 104 }
 105
 106
 107
 108 STATIC union node *
 109 copynode(union node *n)
 110 {
 111         union node *new;
 112
 113         %COPY
 114         return new;
 115 }
 116
 117
 118 STATIC struct nodelist *
 119 copynodelist(struct nodelist *lp)
 120 {
 121         struct nodelist *start;
 122         struct nodelist **lpp;
 123
 124         lpp = &start;
 125         while (lp) {
 126                 *lpp = funcblock;
 127                 funcblock = (char *)funcblock + ALIGN(sizeof(struct nodelist));
 128                 (*lpp)->n = copynode(lp->n);
 129                 lp = lp->next;
 130                 lpp = &(*lpp)->next;
 131         }
 132         *lpp = NULL;
 133         return start;
 134 }
 135
 136
 137
 138 STATIC char *
 139 nodesavestr(char *s)
 140 {
 141         char *p = s;
 142         char *q = funcstring;
 143         char   *rtn = funcstring;
 144
 145         while ((*q++ = *p++) != '\0')
 146                 continue;
 147         funcstring = q;
 148         return rtn;
 149 }
 150
 151
 152
 153 /*
 154  * Free a parse tree.
 155  */
 156
 157 void
 158 freefunc(union node *n)
 159 {
 160         if (n)
 161                 ckfree(n);
 162 }