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  * 4. Neither the name of the University nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  *      @(#)nodes.c.pat 8.2 (Berkeley) 5/4/95
  33  * $FreeBSD$
  34  */
  35
  36 #include <sys/param.h>
  37 #include <stdlib.h>
  38 /*
  39  * Routine for dealing with parsed shell commands.
  40  */
  41
  42 #include "shell.h"
  43 #include "nodes.h"
  44 #include "memalloc.h"
  45 #include "mystring.h"
  46
  47
  48 STATIC int     funcblocksize;   /* size of structures in function */
  49 STATIC int     funcstringsize;  /* size of strings in node */
  50 STATIC pointer funcblock;       /* block to allocate function from */
  51 STATIC char   *funcstring;      /* block to allocate strings from */
  52
  53 %SIZES
  54
  55
  56 STATIC void calcsize(union node *);
  57 STATIC void sizenodelist(struct nodelist *);
  58 STATIC union node *copynode(union node *);
  59 STATIC struct nodelist *copynodelist(struct nodelist *);
  60 STATIC char *nodesavestr(char *);
  61
  62
  63
  64 /*
  65  * Make a copy of a parse tree.
  66  */
  67
  68 union node *
  69 copyfunc(union node *n)
  70 {
  71         if (n == NULL)
  72                 return NULL;
  73         funcblocksize = 0;
  74         funcstringsize = 0;
  75         calcsize(n);
  76         funcblock = ckmalloc(funcblocksize + funcstringsize);
  77         funcstring = (char *)funcblock + funcblocksize;
  78         return copynode(n);
  79 }
  80
  81
  82
  83 STATIC void
  84 calcsize(union node *n)
  85 {
  86         %CALCSIZE
  87 }
  88
  89
  90
  91 STATIC void
  92 sizenodelist(struct nodelist *lp)
  93 {
  94         while (lp) {
  95                 funcblocksize += ALIGN(sizeof(struct nodelist));
  96                 calcsize(lp->n);
  97                 lp = lp->next;
  98         }
  99 }
 100
 101
 102
 103 STATIC union node *
 104 copynode(union node *n)
 105 {
 106         union node *new;
 107
 108         %COPY
 109         return new;
 110 }
 111
 112
 113 STATIC struct nodelist *
 114 copynodelist(struct nodelist *lp)
 115 {
 116         struct nodelist *start;
 117         struct nodelist **lpp;
 118
 119         lpp = &start;
 120         while (lp) {
 121                 *lpp = funcblock;
 122                 funcblock = (char *)funcblock + ALIGN(sizeof(struct nodelist));
 123                 (*lpp)->n = copynode(lp->n);
 124                 lp = lp->next;
 125                 lpp = &(*lpp)->next;
 126         }
 127         *lpp = NULL;
 128         return start;
 129 }
 130
 131
 132
 133 STATIC char *
 134 nodesavestr(char *s)
 135 {
 136         char *p = s;
 137         char *q = funcstring;
 138         char   *rtn = funcstring;
 139
 140         while ((*q++ = *p++) != '\0')
 141                 continue;
 142         funcstring = q;
 143         return rtn;
 144 }
 145
 146
 147
 148 /*
 149  * Free a parse tree.
 150  */
 151
 152 void
 153 freefunc(union node *n)
 154 {
 155         if (n)
 156                 ckfree(n);
 157 }