# 2.11BSD#431 - /usr/src/ucb/rdist/lookup.c

##### Functions

    define            X
    lookup            X

##### Macros

    CONST             X
    VAR               X

##### struct's

    syment            X

       1: /*
       2:  * Copyright (c) 1983 Regents of the University of California.
       3:  * All rights reserved.  The Berkeley software License Agreement
       4:  * specifies the terms and conditions for redistribution.
       5:  */
       6:
       7: #if !defined(lint) && defined(DOSCCS)
       8: static char sccsid[] = "@(#)lookup.c	5.1.1 (2.11BSD) 1995/05/09";
       9: #endif
      10:
      11: #include "defs.h"
      12:
      13:     /* symbol types */
      14: #define VAR 1
      15: #define CONST   2
      16:
      17: struct syment {
      18:     int s_type;
      19:     char    *s_name;
      20:     struct  namelist *s_value;
      21:     struct  syment *s_next;
      22: };
      23:
      24: static struct syment *hashtab[HASHSIZE];
      25:
      26: /*
      27:  * Define a variable from a command line argument.
      28:  */
      29: define(name)
      30:     char *name;
      31: {
      32:     register char *cp, *s;
      33:     register struct namelist *nl;
      34:     struct namelist *value;
      35:
      36:     if (debug)
      37:         printf("define(%s)\n", name);
      38:
      39:     cp = index(name, '=');
      40:     if (cp == NULL)
      41:         value = NULL;
      42:     else if (cp[1] == '\0') {
      43:         *cp = '\0';
      44:         value = NULL;
      45:     } else if (cp[1] != '(') {
      46:         *cp++ = '\0';
      47:         value = makenl(cp);
      48:     } else {
      49:         nl = NULL;
      50:         *cp++ = '\0';
      51:         do
      52:             cp++;
      53:         while (*cp == ' ' || *cp == '\t');
      54:         for (s = cp; ; s++) {
      55:             switch (*s) {
      56:             case ')':
      57:                 *s = '\0';
      58:             case '\0':
      59:                 break;
      60:             case ' ':
      61:             case '\t':
      62:                 *s++ = '\0';
      63:                 while (*s == ' ' || *s == '\t')
      64:                     s++;
      65:                 if (*s == ')')
      66:                     *s = '\0';
      67:                 break;
      68:             default:
      69:                 continue;
      70:             }
      71:             if (nl == NULL)
      72:                 value = nl = makenl(cp);
      73:             else {
      74:                 nl->n_next = makenl(cp);
      75:                 nl = nl->n_next;
      76:             }
      77:             if (*s == '\0')
      78:                 break;
      79:             cp = s;
      80:         }
      81:     }
      82:     (void) lookup(name, REPLACE, value);
      83: }
      84:
      85: /*
      86:  * Lookup name in the table and return a pointer to it.
      87:  * LOOKUP - just do lookup, return NULL if not found.
      88:  * INSERT - insert name with value, error if already defined.
      89:  * REPLACE - insert or replace name with value.
      90:  */
      91:
      92: struct namelist *
      93: lookup(name, action, value)
      94:     char *name;
      95:     int action;
      96:     struct namelist *value;
      97: {
      98:     register unsigned n;
      99:     register char *cp;
     100:     register struct syment *s;
     101:     char buf[256];
     102:
     103:     if (debug)
     104:         printf("lookup(%s, %d, %x)\n", name, action, value);
     105:
     106:     n = 0;
     107:     for (cp = name; *cp; )
     108:         n += *cp++;
     109:     n %= HASHSIZE;
     110:
     111:     for (s = hashtab[n]; s != NULL; s = s->s_next) {
     112:         if (strcmp(name, s->s_name))
     113:             continue;
     114:         if (action != LOOKUP) {
     115:             if (action != INSERT || s->s_type != CONST) {
     116:                 sprintf(buf, "%s redefined", name);
     117:                 yyerror(buf);
     118:             }
     119:         }
     120:         return(s->s_value);
     121:     }
     122:
     123:     if (action == LOOKUP) {
     124:         yyerror(sprintf(buf, "%s undefined", name));
     125:         return(NULL);
     126:     }
     127:
     128:     s = ALLOC(syment);
     129:     if (s == NULL)
     130:         fatal("ran out of memory\n");
     131:     s->s_next = hashtab[n];
     132:     hashtab[n] = s;
     133:     s->s_type = action == INSERT ? VAR : CONST;
     134:     s->s_name = name;
     135:     s->s_value = value;
     136:     return(value);
     137: }

#### Defined functions

define defined in line 29; used 1 times

- in /usr/src/ucb/rdist/main.c line 102

lookup defined in line 92; used 4 times

- in line 82
- in /usr/src/ucb/rdist/defs.h line 124
- in /usr/src/ucb/rdist/expand.c line 142
- in /usr/src/ucb/rdist/gram.y line 56

#### Defined variables

hashtab defined in line 24; used 3 times

- in line 111, 131-132(2)

sccsid defined in line 8; never used

#### Defined struct's

syment defined in line 17; used 6 times

- in line 21-24(4), 100(2)

#### Defined macros

CONST defined in line 15; used 2 times

- in line 115, 133

VAR defined in line 14; used 1 times

- in line 133

Last modified: 1995-05-10 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1148 |