# 2.11BSD#431 - /usr/src/bin/tcsh/tw.init.c

##### Functions

    Getenv            X
    tw_aliases_add    X
    tw_builtins_add   X
    tw_clear_comm_listX
    tw_comm_name_add  X
    tw_env_list_start X
    tw_n_env_var      X
    tw_n_shell_var    X
    tw_shell_list_startX
    tw_sort_comms     X

       1: /* $Header: /home/hyperion/mu/christos/src/sys/tcsh-6.00/RCS/tw.init.c,v 3.0 1991/07/04 21:49:28 christos Exp $ */
       2: /*
       3:  * tw.init.c: TwENEX initializations
       4:  */
       5: /*-
       6:  * Copyright (c) 1980, 1991 The Regents of the University of California.
       7:  * All rights reserved.
       8:  *
       9:  * Redistribution and use in source and binary forms, with or without
      10:  * modification, are permitted provided that the following conditions
      11:  * are met:
      12:  * 1. Redistributions of source code must retain the above copyright
      13:  *    notice, this list of conditions and the following disclaimer.
      14:  * 2. Redistributions in binary form must reproduce the above copyright
      15:  *    notice, this list of conditions and the following disclaimer in the
      16:  *    documentation and/or other materials provided with the distribution.
      17:  * 3. All advertising materials mentioning features or use of this software
      18:  *    must display the following acknowledgement:
      19:  *	This product includes software developed by the University of
      20:  *	California, Berkeley and its contributors.
      21:  * 4. Neither the name of the University nor the names of its contributors
      22:  *    may be used to endorse or promote products derived from this software
      23:  *    without specific prior written permission.
      24:  *
      25:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
      26:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      27:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
      28:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
      29:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
      30:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
      31:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
      32:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
      33:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
      34:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
      35:  * SUCH DAMAGE.
      36:  */
      37: #include "config.h"
      38: #if !defined(lint) && !defined(pdp11)
      39: static char *rcsid()
      40:     { return "$Id: tw.init.c,v 3.0 1991/07/04 21:49:28 christos Exp $"; }
      41: #endif
      42:
      43: #include "sh.h"
      44: #include "tw.h"
      45:
      46: /*
      47:  * Build the command name list (and print the results).  This is a HACK until
      48:  * I can get the rehash command to include its results in the command list.
      49:  */
      50:
      51: static int maxcommands = 0;
      52:
      53:
      54: void
      55: tw_clear_comm_list()
      56: {
      57:     register int i;
      58:
      59:     have_sorted = 0;
      60:     if (numcommands != 0) {
      61: /*        for (i = 0; com_list[i]; i++) { */
      62:     for (i = 0; i < numcommands; i++) {
      63:         xfree((ptr_t) com_list[i]);
      64:         com_list[i] = NULL;
      65:     }
      66:     numcommands = 0;
      67:     }
      68: }
      69:
      70: void
      71: tw_sort_comms()
      72: {               /* could be re-written */
      73:     register int i, forward;
      74:
      75:     /* sort the list. */
      76:     qsort((ptr_t) com_list, (size_t) numcommands, sizeof(com_list[0]),
      77:       (int (*) __P((const void *, const void *))) fcompare);
      78:
      79:     /* get rid of multiple entries */
      80:     for (i = 0, forward = 0; i < numcommands - 1; i++) {
      81:     if (Strcmp(com_list[i], com_list[i + 1]) == 0) {    /* garbage */
      82:         xfree((ptr_t) com_list[i]);
      83:         forward++;      /* increase the forward ref. count */
      84:     }
      85:     else if (forward) {
      86:         com_list[i - forward] = com_list[i];
      87:     }
      88:     }
      89:     /* Fix fencepost error -- Theodore Ts'o <tytso@athena.mit.edu> */
      90:     if (forward)
      91:     com_list[i - forward] = com_list[i];
      92:     numcommands -= forward;
      93:     com_list[numcommands] = (Char *) NULL;
      94:
      95:     have_sorted = 1;
      96: }
      97:
      98: void
      99: tw_comm_name_add(name)      /* this is going to be called a LOT at startup */
     100:     Char   *name;
     101: {
     102:     register int length;
     103:     register long i;
     104:     register Char **ncl, **p1, **p2;
     105:
     106:     if (maxcommands == 0) {
     107:     com_list = (Char **) xmalloc((size_t) (NUMCMDS_START *
     108:                            sizeof(com_list[0])));
     109:     maxcommands = NUMCMDS_START;
     110:     for (i = 0, p2 = com_list; i < maxcommands; i++)
     111:         *p2++ = NULL;  /* jpn: if need to loop, might as well do it all */
     112:     }
     113:     else if (numcommands >= maxcommands) {
     114:     ncl = (Char **) xmalloc((size_t) ((maxcommands + NUMCMDS_INCR) *
     115:                       sizeof(com_list[0])));
     116:     for (i = 0, p1 = com_list, p2 = ncl; i < numcommands; i++)
     117:         *p2++ = *p1++;
     118:     for (; i < maxcommands + NUMCMDS_INCR; i++)
     119:         *p2++ = NULL;
     120:     xfree((ptr_t) com_list);
     121:     com_list = ncl;
     122: #ifdef COMMENT
     123:     com_list = (Char **) xrealloc(com_list, (maxcommands +
     124:                      NUMCMDS_INCR) * sizeof(com_list[0]));
     125: #endif
     126:     maxcommands += NUMCMDS_INCR;
     127:     }
     128:
     129:     if (name[0] == '.')
     130:     return;         /* no dot commands... */
     131:     if (name[0] == '#')
     132:     return;         /* no Emacs buffer checkpoints */
     133:
     134:     length = Strlen(name) + 1;
     135:
     136:     if (name[length - 2] == '~')
     137:     return;         /* and no Emacs backups either */
     138:
     139:     com_list[numcommands] = (Char *) xmalloc((size_t) (length *
     140:                                sizeof(Char)));
     141:
     142:     copyn(com_list[numcommands], name, MAXNAMLEN);
     143:     numcommands++;
     144: }
     145:
     146: void
     147: tw_builtins_add()
     148: {
     149:     register struct biltins *bptr;
     150:
     151:     for (bptr = bfunc; bptr < &bfunc[nbfunc]; bptr++) {
     152:     if (bptr->bname)
     153:         tw_comm_name_add(str2short(bptr->bname));
     154:     }
     155: }
     156:
     157: void
     158: tw_aliases_add()
     159: {
     160:     register struct varent *p;
     161:     register struct varent *c;
     162:
     163:     p = &aliases;
     164:     for (;;) {
     165:     while (p->v_left)
     166:         p = p->v_left;
     167: x:
     168:     if (p->v_parent == 0)   /* is it the header? */
     169:         return;
     170:     if (p->v_name)
     171:         tw_comm_name_add(p->v_name);
     172:     if (p->v_right) {
     173:         p = p->v_right;
     174:         continue;
     175:     }
     176:     do {
     177:         c = p;
     178:         p = p->v_parent;
     179:     } while (p->v_right == c);
     180:     goto x;
     181:     }
     182:
     183: }
     184:
     185: struct varent *
     186: tw_shell_list_start()
     187: {
     188:     register struct varent *p;
     189:     register struct varent *c;
     190:
     191:     p = &shvhed;        /* start at beginning of variable list */
     192:
     193:     for (;;) {
     194:     while (p->v_left)
     195:         p = p->v_left;
     196: x:
     197:     if (p->v_parent == 0)   /* is it the header? */
     198:         return (NULL);
     199:     if (p->v_name)
     200:         return (p);     /* found first one */
     201:     if (p->v_right) {
     202:         p = p->v_right;
     203:         continue;
     204:     }
     205:     do {
     206:         c = p;
     207:         p = p->v_parent;
     208:     } while (p->v_right == c);
     209:     goto x;
     210:     }
     211: }
     212:
     213: Char   *
     214: tw_n_shell_var(vptr)
     215:     struct varent **vptr;
     216: {
     217:     register struct varent *p;
     218:     register struct varent *c;
     219:     register Char *cp;
     220:
     221:     if ((p = *vptr) == NULL)
     222:     return (NULL);      /* just in case */
     223:
     224:     cp = p->v_name;     /* we know that this name is here now */
     225:
     226:     /* now find the next one */
     227:     for (;;) {
     228:     if (p->v_right) {   /* if we can go right */
     229:         p = p->v_right;
     230:         while (p->v_left)
     231:         p = p->v_left;
     232:     }
     233:     else {          /* else go up */
     234:         do {
     235:         c = p;
     236:         p = p->v_parent;
     237:         } while (p->v_right == c);
     238:     }
     239:     if (p->v_parent == 0) { /* is it the header? */
     240:         *vptr = NULL;
     241:         return (cp);
     242:     }
     243:     if (p->v_name) {
     244:         *vptr = p;      /* save state for the next call */
     245:         return (cp);
     246:     }
     247:     }
     248:
     249: }
     250:
     251: Char  **
     252: tw_env_list_start()
     253: {
     254:     return (STR_environ);
     255: }
     256:
     257: Char   *
     258: Getenv(str)
     259:     Char   *str;
     260: {
     261:     Char  **var;
     262:     int     len, res;
     263:
     264:     len = Strlen(str);
     265:     for (var = STR_environ; var != NULL && *var != NULL; var++)
     266:     if ((*var)[len] == '=') {
     267:         (*var)[len] = '\0';
     268:         res = StrQcmp(*var, str);
     269:         (*var)[len] = '=';
     270:         if (res == 0)
     271:         return (&((*var)[len + 1]));
     272:     }
     273:     return (NULL);
     274: }
     275:
     276: Char   *
     277: tw_n_env_var(evp)
     278:     Char ***evp;
     279: {
     280:     static Char buffer[MAXVARLEN + 1];
     281:     Char   *ps, *pd;
     282:
     283:     if (*evp == NULL || **evp == NULL)
     284:     return (NULL);
     285:     for (ps = **evp, pd = buffer;
     286:      *ps && *ps != '=' && pd <= &buffer[MAXVARLEN]; *pd++ = *ps++);
     287:     *pd = '\0';
     288:     (*evp)++;
     289:     return (buffer);
     290: }

#### Defined functions

Getenv defined in line 257; used 3 times

- in /usr/src/bin/tcsh/tc.os.c line 933
- in /usr/src/bin/tcsh/tw.parse.c line 951, 1172

rcsid defined in line 39; never used
tw_aliases_add defined in line 157; used 1 times

- in /usr/src/bin/tcsh/tw.parse.c line 711

tw_builtins_add defined in line 146; used 1 times

- in /usr/src/bin/tcsh/tw.parse.c line 710

tw_clear_comm_list defined in line 54; used 1 times

- in /usr/src/bin/tcsh/tw.parse.c line 1458

tw_comm_name_add defined in line 98; used 6 times

- in line 153, 171
- in /usr/src/bin/tcsh/tw.init.c line 153, 171
- in /usr/src/bin/tcsh/tw.parse.c line 1477, 1495

tw_env_list_start defined in line 251; used 1 times

- in /usr/src/bin/tcsh/tw.parse.c line 657

tw_n_env_var defined in line 276; used 1 times

- in /usr/src/bin/tcsh/tw.parse.c line 730

tw_n_shell_var defined in line 213; used 1 times

- in /usr/src/bin/tcsh/tw.parse.c line 729

tw_shell_list_start defined in line 185; used 1 times

- in /usr/src/bin/tcsh/tw.parse.c line 656

tw_sort_comms defined in line 70; used 1 times

- in /usr/src/bin/tcsh/tw.parse.c line 712

#### Defined variables

maxcommands defined in line 51; used 8 times

- in line 106-126(8)

Last modified: 1991-08-20 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1057 |