xref: /freebsd/bin/sh/var.c (revision 7850fa71f55a16f414bb21163d80a03a5ab34522) 
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 
33 #ifndef lint
34 #if 0
35 static char sccsid[] = "@(#)var.c	8.3 (Berkeley) 5/4/95";
36 #endif
37 #endif /* not lint */
38 #include <sys/cdefs.h>
39 __FBSDID("$FreeBSD$");
40 
41 #include <unistd.h>
42 #include <stdlib.h>
43 #include <paths.h>
44 
45 /*
46  * Shell variables.
47  */
48 
49 #include <locale.h>
50 
51 #include "shell.h"
52 #include "output.h"
53 #include "expand.h"
54 #include "nodes.h"	/* for other headers */
55 #include "eval.h"	/* defines cmdenviron */
56 #include "exec.h"
57 #include "syntax.h"
58 #include "options.h"
59 #include "mail.h"
60 #include "var.h"
61 #include "memalloc.h"
62 #include "error.h"
63 #include "mystring.h"
64 #include "parser.h"
65 #ifndef NO_HISTORY
66 #include "myhistedit.h"
67 #endif
68 
69 
70 #define VTABSIZE 39
71 
72 
73 struct varinit {
74 	struct var *var;
75 	int flags;
76 	char *text;
77 	void (*func)(const char *);
78 };
79 
80 
81 #ifndef NO_HISTORY
82 struct var vhistsize;
83 #endif
84 struct var vifs;
85 struct var vmail;
86 struct var vmpath;
87 struct var vpath;
88 struct var vppid;
89 struct var vps1;
90 struct var vps2;
91 struct var vps4;
92 struct var vvers;
93 STATIC struct var voptind;
94 
95 STATIC const struct varinit varinit[] = {
96 #ifndef NO_HISTORY
97 	{ &vhistsize,	VSTRFIXED|VTEXTFIXED|VUNSET,	"HISTSIZE=",
98 	  sethistsize },
99 #endif
100 	{ &vifs,	VSTRFIXED|VTEXTFIXED,		"IFS= \t\n",
101 	  NULL },
102 	{ &vmail,	VSTRFIXED|VTEXTFIXED|VUNSET,	"MAIL=",
103 	  NULL },
104 	{ &vmpath,	VSTRFIXED|VTEXTFIXED|VUNSET,	"MAILPATH=",
105 	  NULL },
106 	{ &vpath,	VSTRFIXED|VTEXTFIXED,		"PATH=" _PATH_DEFPATH,
107 	  changepath },
108 	{ &vppid,	VSTRFIXED|VTEXTFIXED|VUNSET,	"PPID=",
109 	  NULL },
110 	/*
111 	 * vps1 depends on uid
112 	 */
113 	{ &vps2,	VSTRFIXED|VTEXTFIXED,		"PS2=> ",
114 	  NULL },
115 	{ &vps4,	VSTRFIXED|VTEXTFIXED,		"PS4=+ ",
116 	  NULL },
117 	{ &voptind,	VSTRFIXED|VTEXTFIXED,		"OPTIND=1",
118 	  getoptsreset },
119 	{ NULL,	0,				NULL,
120 	  NULL }
121 };
122 
123 STATIC struct var *vartab[VTABSIZE];
124 
125 STATIC struct var **hashvar(char *);
126 STATIC int varequal(char *, char *);
127 STATIC int localevar(char *);
128 
129 /*
130  * Initialize the variable symbol tables and import the environment.
131  */
132 
133 #ifdef mkinit
134 INCLUDE "var.h"
135 INIT {
136 	char **envp;
137 	extern char **environ;
138 
139 	initvar();
140 	for (envp = environ ; *envp ; envp++) {
141 		if (strchr(*envp, '=')) {
142 			setvareq(*envp, VEXPORT|VTEXTFIXED);
143 		}
144 	}
145 }
146 #endif
147 
148 
149 /*
150  * This routine initializes the builtin variables.  It is called when the
151  * shell is initialized and again when a shell procedure is spawned.
152  */
153 
154 void
155 initvar(void)
156 {
157 	char ppid[20];
158 	const struct varinit *ip;
159 	struct var *vp;
160 	struct var **vpp;
161 
162 	for (ip = varinit ; (vp = ip->var) != NULL ; ip++) {
163 		if ((vp->flags & VEXPORT) == 0) {
164 			vpp = hashvar(ip->text);
165 			vp->next = *vpp;
166 			*vpp = vp;
167 			vp->text = ip->text;
168 			vp->flags = ip->flags;
169 			vp->func = ip->func;
170 		}
171 	}
172 	/*
173 	 * PS1 depends on uid
174 	 */
175 	if ((vps1.flags & VEXPORT) == 0) {
176 		vpp = hashvar("PS1=");
177 		vps1.next = *vpp;
178 		*vpp = &vps1;
179 		vps1.text = geteuid() ? "PS1=$ " : "PS1=# ";
180 		vps1.flags = VSTRFIXED|VTEXTFIXED;
181 	}
182 	if ((vppid.flags & VEXPORT) == 0) {
183 		fmtstr(ppid, sizeof(ppid), "%d", (int)getppid());
184 		setvarsafe("PPID", ppid, 0);
185 	}
186 }
187 
188 /*
189  * Safe version of setvar, returns 1 on success 0 on failure.
190  */
191 
192 int
193 setvarsafe(char *name, char *val, int flags)
194 {
195 	struct jmploc jmploc;
196 	struct jmploc *const savehandler = handler;
197 	int err = 0;
198 
199 	if (setjmp(jmploc.loc))
200 		err = 1;
201 	else {
202 		handler = &jmploc;
203 		setvar(name, val, flags);
204 	}
205 	handler = savehandler;
206 	return err;
207 }
208 
209 /*
210  * Set the value of a variable.  The flags argument is stored with the
211  * flags of the variable.  If val is NULL, the variable is unset.
212  */
213 
214 void
215 setvar(char *name, char *val, int flags)
216 {
217 	char *p, *q;
218 	int len;
219 	int namelen;
220 	char *nameeq;
221 	int isbad;
222 
223 	isbad = 0;
224 	p = name;
225 	if (! is_name(*p))
226 		isbad = 1;
227 	p++;
228 	for (;;) {
229 		if (! is_in_name(*p)) {
230 			if (*p == '\0' || *p == '=')
231 				break;
232 			isbad = 1;
233 		}
234 		p++;
235 	}
236 	namelen = p - name;
237 	if (isbad)
238 		error("%.*s: bad variable name", namelen, name);
239 	len = namelen + 2;		/* 2 is space for '=' and '\0' */
240 	if (val == NULL) {
241 		flags |= VUNSET;
242 	} else {
243 		len += strlen(val);
244 	}
245 	p = nameeq = ckmalloc(len);
246 	q = name;
247 	while (--namelen >= 0)
248 		*p++ = *q++;
249 	*p++ = '=';
250 	*p = '\0';
251 	if (val)
252 		scopy(val, p);
253 	setvareq(nameeq, flags);
254 }
255 
256 STATIC int
257 localevar(char *s)
258 {
259 	static char *lnames[7] = {
260 		"ALL", "COLLATE", "CTYPE", "MONETARY",
261 		"NUMERIC", "TIME", NULL
262 	};
263 	char **ss;
264 
265 	if (*s != 'L')
266 		return 0;
267 	if (varequal(s + 1, "ANG"))
268 		return 1;
269 	if (strncmp(s + 1, "C_", 2) != 0)
270 		return 0;
271 	for (ss = lnames; *ss ; ss++)
272 		if (varequal(s + 3, *ss))
273 			return 1;
274 	return 0;
275 }
276 
277 
278 /*
279  * Sets/unsets an environment variable from a pointer that may actually be a
280  * pointer into environ where the string should not be manipulated.
281  */
282 static void
283 change_env(char *s, int set)
284 {
285 	char *eqp;
286 	char *ss;
287 
288 	ss = savestr(s);
289 	if ((eqp = strchr(ss, '=')) != NULL)
290 		*eqp = '\0';
291 	if (set && eqp != NULL)
292 		(void) setenv(ss, eqp + 1, 1);
293 	else
294 		(void) unsetenv(ss);
295 	ckfree(ss);
296 
297 	return;
298 }
299 
300 
301 /*
302  * Same as setvar except that the variable and value are passed in
303  * the first argument as name=value.  Since the first argument will
304  * be actually stored in the table, it should not be a string that
305  * will go away.
306  */
307 
308 void
309 setvareq(char *s, int flags)
310 {
311 	struct var *vp, **vpp;
312 	int len;
313 
314 	if (aflag)
315 		flags |= VEXPORT;
316 	vpp = hashvar(s);
317 	for (vp = *vpp ; vp ; vp = vp->next) {
318 		if (varequal(s, vp->text)) {
319 			if (vp->flags & VREADONLY) {
320 				len = strchr(s, '=') - s;
321 				error("%.*s: is read only", len, s);
322 			}
323 			INTOFF;
324 
325 			if (vp->func && (flags & VNOFUNC) == 0)
326 				(*vp->func)(strchr(s, '=') + 1);
327 
328 			if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
329 				ckfree(vp->text);
330 
331 			vp->flags &= ~(VTEXTFIXED|VSTACK|VUNSET);
332 			vp->flags |= flags;
333 			vp->text = s;
334 
335 			/*
336 			 * We could roll this to a function, to handle it as
337 			 * a regular variable function callback, but why bother?
338 			 */
339 			if (vp == &vmpath || (vp == &vmail && ! mpathset()))
340 				chkmail(1);
341 			if ((vp->flags & VEXPORT) && localevar(s)) {
342 				change_env(s, 1);
343 				(void) setlocale(LC_ALL, "");
344 			}
345 			INTON;
346 			return;
347 		}
348 	}
349 	/* not found */
350 	vp = ckmalloc(sizeof (*vp));
351 	vp->flags = flags;
352 	vp->text = s;
353 	vp->next = *vpp;
354 	vp->func = NULL;
355 	INTOFF;
356 	*vpp = vp;
357 	if ((vp->flags & VEXPORT) && localevar(s)) {
358 		change_env(s, 1);
359 		(void) setlocale(LC_ALL, "");
360 	}
361 	INTON;
362 }
363 
364 
365 
366 /*
367  * Process a linked list of variable assignments.
368  */
369 
370 void
371 listsetvar(struct strlist *list)
372 {
373 	struct strlist *lp;
374 
375 	INTOFF;
376 	for (lp = list ; lp ; lp = lp->next) {
377 		setvareq(savestr(lp->text), 0);
378 	}
379 	INTON;
380 }
381 
382 
383 
384 /*
385  * Find the value of a variable.  Returns NULL if not set.
386  */
387 
388 char *
389 lookupvar(char *name)
390 {
391 	struct var *v;
392 
393 	for (v = *hashvar(name) ; v ; v = v->next) {
394 		if (varequal(v->text, name)) {
395 			if (v->flags & VUNSET)
396 				return NULL;
397 			return strchr(v->text, '=') + 1;
398 		}
399 	}
400 	return NULL;
401 }
402 
403 
404 
405 /*
406  * Search the environment of a builtin command.  If the second argument
407  * is nonzero, return the value of a variable even if it hasn't been
408  * exported.
409  */
410 
411 char *
412 bltinlookup(char *name, int doall)
413 {
414 	struct strlist *sp;
415 	struct var *v;
416 
417 	for (sp = cmdenviron ; sp ; sp = sp->next) {
418 		if (varequal(sp->text, name))
419 			return strchr(sp->text, '=') + 1;
420 	}
421 	for (v = *hashvar(name) ; v ; v = v->next) {
422 		if (varequal(v->text, name)) {
423 			if ((v->flags & VUNSET)
424 			 || (!doall && (v->flags & VEXPORT) == 0))
425 				return NULL;
426 			return strchr(v->text, '=') + 1;
427 		}
428 	}
429 	return NULL;
430 }
431 
432 
433 
434 /*
435  * Generate a list of exported variables.  This routine is used to construct
436  * the third argument to execve when executing a program.
437  */
438 
439 char **
440 environment(void)
441 {
442 	int nenv;
443 	struct var **vpp;
444 	struct var *vp;
445 	char **env, **ep;
446 
447 	nenv = 0;
448 	for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
449 		for (vp = *vpp ; vp ; vp = vp->next)
450 			if (vp->flags & VEXPORT)
451 				nenv++;
452 	}
453 	ep = env = stalloc((nenv + 1) * sizeof *env);
454 	for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
455 		for (vp = *vpp ; vp ; vp = vp->next)
456 			if (vp->flags & VEXPORT)
457 				*ep++ = vp->text;
458 	}
459 	*ep = NULL;
460 	return env;
461 }
462 
463 
464 /*
465  * Called when a shell procedure is invoked to clear out nonexported
466  * variables.  It is also necessary to reallocate variables of with
467  * VSTACK set since these are currently allocated on the stack.
468  */
469 
470 #ifdef mkinit
471 MKINIT void shprocvar(void);
472 
473 SHELLPROC {
474 	shprocvar();
475 }
476 #endif
477 
478 void
479 shprocvar(void)
480 {
481 	struct var **vpp;
482 	struct var *vp, **prev;
483 
484 	for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
485 		for (prev = vpp ; (vp = *prev) != NULL ; ) {
486 			if ((vp->flags & VEXPORT) == 0) {
487 				*prev = vp->next;
488 				if ((vp->flags & VTEXTFIXED) == 0)
489 					ckfree(vp->text);
490 				if ((vp->flags & VSTRFIXED) == 0)
491 					ckfree(vp);
492 			} else {
493 				if (vp->flags & VSTACK) {
494 					vp->text = savestr(vp->text);
495 					vp->flags &=~ VSTACK;
496 				}
497 				prev = &vp->next;
498 			}
499 		}
500 	}
501 	initvar();
502 }
503 
504 
505 static int
506 var_compare(const void *a, const void *b)
507 {
508 	const char *const *sa, *const *sb;
509 
510 	sa = a;
511 	sb = b;
512 	/*
513 	 * This compares two var=value strings which creates a different
514 	 * order from what you would probably expect.  POSIX is somewhat
515 	 * ambiguous on what should be sorted exactly.
516 	 */
517 	return strcoll(*sa, *sb);
518 }
519 
520 
521 /*
522  * Command to list all variables which are set.  Currently this command
523  * is invoked from the set command when the set command is called without
524  * any variables.
525  */
526 
527 int
528 showvarscmd(int argc __unused, char **argv __unused)
529 {
530 	struct var **vpp;
531 	struct var *vp;
532 	const char *s;
533 	const char **vars;
534 	int i, n;
535 
536 	/*
537 	 * POSIX requires us to sort the variables.
538 	 */
539 	n = 0;
540 	for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) {
541 		for (vp = *vpp; vp; vp = vp->next) {
542 			if (!(vp->flags & VUNSET))
543 				n++;
544 		}
545 	}
546 
547 	INTON;
548 	vars = ckmalloc(n * sizeof(*vars));
549 	i = 0;
550 	for (vpp = vartab; vpp < vartab + VTABSIZE; vpp++) {
551 		for (vp = *vpp; vp; vp = vp->next) {
552 			if (!(vp->flags & VUNSET))
553 				vars[i++] = vp->text;
554 		}
555 	}
556 
557 	qsort(vars, n, sizeof(*vars), var_compare);
558 	for (i = 0; i < n; i++) {
559 		for (s = vars[i]; *s != '='; s++)
560 			out1c(*s);
561 		out1c('=');
562 		out1qstr(s + 1);
563 		out1c('\n');
564 	}
565 	ckfree(vars);
566 	INTOFF;
567 
568 	return 0;
569 }
570 
571 
572 
573 /*
574  * The export and readonly commands.
575  */
576 
577 int
578 exportcmd(int argc, char **argv)
579 {
580 	struct var **vpp;
581 	struct var *vp;
582 	char *name;
583 	char *p;
584 	char *cmdname;
585 	int ch, values;
586 	int flag = argv[0][0] == 'r'? VREADONLY : VEXPORT;
587 
588 	cmdname = argv[0];
589 	optreset = optind = 1;
590 	opterr = 0;
591 	values = 0;
592 	while ((ch = getopt(argc, argv, "p")) != -1) {
593 		switch (ch) {
594 		case 'p':
595 			values = 1;
596 			break;
597 		case '?':
598 		default:
599 			error("unknown option: -%c", optopt);
600 		}
601 	}
602 	argc -= optind;
603 	argv += optind;
604 
605 	if (values && argc != 0)
606 		error("-p requires no arguments");
607 	listsetvar(cmdenviron);
608 	if (argc != 0) {
609 		while ((name = *argv++) != NULL) {
610 			if ((p = strchr(name, '=')) != NULL) {
611 				p++;
612 			} else {
613 				vpp = hashvar(name);
614 				for (vp = *vpp ; vp ; vp = vp->next) {
615 					if (varequal(vp->text, name)) {
616 
617 						vp->flags |= flag;
618 						if ((vp->flags & VEXPORT) && localevar(vp->text)) {
619 							change_env(vp->text, 1);
620 							(void) setlocale(LC_ALL, "");
621 						}
622 						goto found;
623 					}
624 				}
625 			}
626 			setvar(name, p, flag);
627 found:;
628 		}
629 	} else {
630 		for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
631 			for (vp = *vpp ; vp ; vp = vp->next) {
632 				if (vp->flags & flag) {
633 					if (values) {
634 						out1str(cmdname);
635 						out1c(' ');
636 					}
637 					for (p = vp->text ; *p != '=' ; p++)
638 						out1c(*p);
639 					if (values && !(vp->flags & VUNSET)) {
640 						out1c('=');
641 						out1qstr(p + 1);
642 					}
643 					out1c('\n');
644 				}
645 			}
646 		}
647 	}
648 	return 0;
649 }
650 
651 
652 /*
653  * The "local" command.
654  */
655 
656 int
657 localcmd(int argc __unused, char **argv __unused)
658 {
659 	char *name;
660 
661 	if (! in_function())
662 		error("Not in a function");
663 	while ((name = *argptr++) != NULL) {
664 		mklocal(name);
665 	}
666 	return 0;
667 }
668 
669 
670 /*
671  * Make a variable a local variable.  When a variable is made local, it's
672  * value and flags are saved in a localvar structure.  The saved values
673  * will be restored when the shell function returns.  We handle the name
674  * "-" as a special case.
675  */
676 
677 void
678 mklocal(char *name)
679 {
680 	struct localvar *lvp;
681 	struct var **vpp;
682 	struct var *vp;
683 
684 	INTOFF;
685 	lvp = ckmalloc(sizeof (struct localvar));
686 	if (name[0] == '-' && name[1] == '\0') {
687 		lvp->text = ckmalloc(sizeof optlist);
688 		memcpy(lvp->text, optlist, sizeof optlist);
689 		vp = NULL;
690 	} else {
691 		vpp = hashvar(name);
692 		for (vp = *vpp ; vp && ! varequal(vp->text, name) ; vp = vp->next);
693 		if (vp == NULL) {
694 			if (strchr(name, '='))
695 				setvareq(savestr(name), VSTRFIXED);
696 			else
697 				setvar(name, NULL, VSTRFIXED);
698 			vp = *vpp;	/* the new variable */
699 			lvp->text = NULL;
700 			lvp->flags = VUNSET;
701 		} else {
702 			lvp->text = vp->text;
703 			lvp->flags = vp->flags;
704 			vp->flags |= VSTRFIXED|VTEXTFIXED;
705 			if (strchr(name, '='))
706 				setvareq(savestr(name), 0);
707 		}
708 	}
709 	lvp->vp = vp;
710 	lvp->next = localvars;
711 	localvars = lvp;
712 	INTON;
713 }
714 
715 
716 /*
717  * Called after a function returns.
718  */
719 
720 void
721 poplocalvars(void)
722 {
723 	struct localvar *lvp;
724 	struct var *vp;
725 
726 	while ((lvp = localvars) != NULL) {
727 		localvars = lvp->next;
728 		vp = lvp->vp;
729 		if (vp == NULL) {	/* $- saved */
730 			memcpy(optlist, lvp->text, sizeof optlist);
731 			ckfree(lvp->text);
732 		} else if ((lvp->flags & (VUNSET|VSTRFIXED)) == VUNSET) {
733 			(void)unsetvar(vp->text);
734 		} else {
735 			if ((vp->flags & VTEXTFIXED) == 0)
736 				ckfree(vp->text);
737 			vp->flags = lvp->flags;
738 			vp->text = lvp->text;
739 		}
740 		ckfree(lvp);
741 	}
742 }
743 
744 
745 int
746 setvarcmd(int argc, char **argv)
747 {
748 	if (argc <= 2)
749 		return unsetcmd(argc, argv);
750 	else if (argc == 3)
751 		setvar(argv[1], argv[2], 0);
752 	else
753 		error("List assignment not implemented");
754 	return 0;
755 }
756 
757 
758 /*
759  * The unset builtin command.  We unset the function before we unset the
760  * variable to allow a function to be unset when there is a readonly variable
761  * with the same name.
762  */
763 
764 int
765 unsetcmd(int argc __unused, char **argv __unused)
766 {
767 	char **ap;
768 	int i;
769 	int flg_func = 0;
770 	int flg_var = 0;
771 	int ret = 0;
772 
773 	while ((i = nextopt("vf")) != '\0') {
774 		if (i == 'f')
775 			flg_func = 1;
776 		else
777 			flg_var = 1;
778 	}
779 	if (flg_func == 0 && flg_var == 0)
780 		flg_var = 1;
781 
782 	for (ap = argptr; *ap ; ap++) {
783 		if (flg_func)
784 			ret |= unsetfunc(*ap);
785 		if (flg_var)
786 			ret |= unsetvar(*ap);
787 	}
788 	return ret;
789 }
790 
791 
792 /*
793  * Unset the specified variable.
794  */
795 
796 int
797 unsetvar(char *s)
798 {
799 	struct var **vpp;
800 	struct var *vp;
801 
802 	vpp = hashvar(s);
803 	for (vp = *vpp ; vp ; vpp = &vp->next, vp = *vpp) {
804 		if (varequal(vp->text, s)) {
805 			if (vp->flags & VREADONLY)
806 				return (1);
807 			INTOFF;
808 			if (*(strchr(vp->text, '=') + 1) != '\0')
809 				setvar(s, nullstr, 0);
810 			if ((vp->flags & VEXPORT) && localevar(vp->text)) {
811 				change_env(s, 0);
812 				setlocale(LC_ALL, "");
813 			}
814 			vp->flags &= ~VEXPORT;
815 			vp->flags |= VUNSET;
816 			if ((vp->flags & VSTRFIXED) == 0) {
817 				if ((vp->flags & VTEXTFIXED) == 0)
818 					ckfree(vp->text);
819 				*vpp = vp->next;
820 				ckfree(vp);
821 			}
822 			INTON;
823 			return (0);
824 		}
825 	}
826 
827 	return (0);
828 }
829 
830 
831 
832 /*
833  * Find the appropriate entry in the hash table from the name.
834  */
835 
836 STATIC struct var **
837 hashvar(char *p)
838 {
839 	unsigned int hashval;
840 
841 	hashval = ((unsigned char) *p) << 4;
842 	while (*p && *p != '=')
843 		hashval += (unsigned char) *p++;
844 	return &vartab[hashval % VTABSIZE];
845 }
846 
847 
848 
849 /*
850  * Returns true if the two strings specify the same varable.  The first
851  * variable name is terminated by '='; the second may be terminated by
852  * either '=' or '\0'.
853  */
854 
855 STATIC int
856 varequal(char *p, char *q)
857 {
858 	while (*p == *q++) {
859 		if (*p++ == '=')
860 			return 1;
861 	}
862 	if (*p == '=' && *(q - 1) == '\0')
863 		return 1;
864 	return 0;
865 }
866