var.c@ 2017

Last change on this file since 2017 was 887, checked in by bird, 18 years ago
Fixed unterminated LIBPATHSTRICT value.
Property svn:eol-style set to `native`
File size: 19.2 KB

Line
1	/* $NetBSD: var.c,v 1.36 2004/10/06 10:23:43 enami Exp $ */
2
3	/*-
4	* Copyright (c) 1991, 1993
5	* The Regents of the University of California. All rights reserved.
6	*
7	* This code is derived from software contributed to Berkeley by
8	* Kenneth Almquist.
9	*
10	* Redistribution and use in source and binary forms, with or without
11	* modification, are permitted provided that the following conditions
12	* are met:
13	* 1. Redistributions of source code must retain the above copyright
14	* notice, this list of conditions and the following disclaimer.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice, this list of conditions and the following disclaimer in the
17	* documentation and/or other materials provided with the distribution.
18	* 3. Neither the name of the University nor the names of its contributors
19	* may be used to endorse or promote products derived from this software
20	* without specific prior written permission.
21	*
22	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32	* SUCH DAMAGE.
33	*/
34
35	#ifdef HAVE_SYS_CDEFS_H
36	#include <sys/cdefs.h>
37	#endif
38	#ifndef lint
39	#if 0
40	static char sccsid[] = "@(#)var.c 8.3 (Berkeley) 5/4/95";
41	#else
42	__RCSID("$NetBSD: var.c,v 1.36 2004/10/06 10:23:43 enami Exp $");
43	#endif
44	#endif /* not lint */
45
46	#include <unistd.h>
47	#include <stdlib.h>
48	#include <strings.h>
49	#ifndef __sun__
50	#include <paths.h>
51	#else
52	#define _PATH_DEFPATH "/usr/bin:/usr/sbin"
53	#include <iso/limits_iso.h>
54	#endif
55
56	#ifdef PC_OS2_LIBPATHS
57	#define INCL_BASE
58	#include <os2.h>
59
60	#ifndef LIBPATHSTRICT
61	#define LIBPATHSTRICT 3
62	#endif
63
64	extern APIRET
65	#ifdef APIENTRY
66	APIENTRY
67	#endif
68	DosQueryHeaderInfo(HMODULE hmod, ULONG ulIndex, PVOID pvBuffer, ULONG cbBuffer, ULONG ulSubFunction);
69	#define QHINF_EXEINFO 1 /* NE exeinfo. */
70	#define QHINF_READRSRCTBL 2 /* Reads from the resource table. */
71	#define QHINF_READFILE 3 /* Reads from the executable file. */
72	#define QHINF_LIBPATHLENGTH 4 /* Gets the libpath length. */
73	#define QHINF_LIBPATH 5 /* Gets the entire libpath. */
74	#define QHINF_FIXENTRY 6 /* NE only */
75	#define QHINF_STE 7 /* NE only */
76	#define QHINF_MAPSEL 8 /* NE only */
77
78	#endif
79
80
81	/*
82	* Shell variables.
83	*/
84
85	#include "shell.h"
86	#include "output.h"
87	#include "expand.h"
88	#include "nodes.h" /* for other headers */
89	#include "eval.h" /* defines cmdenviron */
90	#include "exec.h"
91	#include "syntax.h"
92	#include "options.h"
93	#include "mail.h"
94	#include "var.h"
95	#include "memalloc.h"
96	#include "error.h"
97	#include "mystring.h"
98	#include "parser.h"
99	#include "show.h"
100	#ifndef SMALL
101	#include "myhistedit.h"
102	#endif
103
104	#ifdef SMALL
105	#define VTABSIZE 39
106	#else
107	#define VTABSIZE 517
108	#endif
109
110
111	struct varinit {
112	struct var *var;
113	int flags;
114	const char *text;
115	void (func)(const char );
116	};
117
118
119	#if ATTY
120	struct var vatty;
121	#endif
122	#ifndef SMALL
123	struct var vhistsize;
124	struct var vterm;
125	#endif
126	struct var vifs;
127	struct var vmail;
128	struct var vmpath;
129	struct var vpath;
130	#ifdef _MSC_VER
131	struct var vpath2;
132	#endif
133	struct var vps1;
134	struct var vps2;
135	struct var vps4;
136	struct var vvers;
137	struct var voptind;
138
139	#ifdef PC_OS2_LIBPATHS
140	static struct var libpath_vars[4];
141	static const char *libpath_envs[4] = {"LIBPATH=", "BEGINLIBPATH=", "ENDLIBPATH=", "LIBPATHSTRICT="};
142	#endif
143
144	const struct varinit varinit[] = {
145	#if ATTY
146	{ &vatty, VSTRFIXED\|VTEXTFIXED\|VUNSET, "ATTY=",
147	NULL },
148	#endif
149	#ifndef SMALL
150	{ &vhistsize, VSTRFIXED\|VTEXTFIXED\|VUNSET, "HISTSIZE=",
151	sethistsize },
152	#endif
153	{ &vifs, VSTRFIXED\|VTEXTFIXED, "IFS= \t\n",
154	NULL },
155	{ &vmail, VSTRFIXED\|VTEXTFIXED\|VUNSET, "MAIL=",
156	NULL },
157	{ &vmpath, VSTRFIXED\|VTEXTFIXED\|VUNSET, "MAILPATH=",
158	NULL },
159	{ &vpath, VSTRFIXED\|VTEXTFIXED, "PATH=" _PATH_DEFPATH,
160	changepath },
161	#ifdef _MSC_VER
162	{ &vpath2, VSTRFIXED\|VTEXTFIXED, "Path=",
163	changepath },
164	#endif
165	/*
166	* vps1 depends on uid
167	*/
168	{ &vps2, VSTRFIXED\|VTEXTFIXED, "PS2=> ",
169	NULL },
170	{ &vps4, VSTRFIXED\|VTEXTFIXED, "PS4=+ ",
171	NULL },
172	#ifndef SMALL
173	{ &vterm, VSTRFIXED\|VTEXTFIXED\|VUNSET, "TERM=",
174	setterm },
175	#endif
176	{ &voptind, VSTRFIXED\|VTEXTFIXED\|VNOFUNC, "OPTIND=1",
177	getoptsreset },
178	{ NULL, 0, NULL,
179	NULL }
180	};
181
182	struct var *vartab[VTABSIZE];
183
184	STATIC int strequal(const char , const char );
185	STATIC struct var find_var(const char , struct var **, int );
186
187	/*
188	* Initialize the varable symbol tables and import the environment
189	*/
190
191	#ifdef mkinit
192	INCLUDE "var.h"
193	MKINIT char **environ;
194	INIT {
195	char **envp;
196
197	initvar();
198	for (envp = environ ; *envp ; envp++) {
199	if (strchr(*envp, '=')) {
200	setvareq(*envp, VEXPORT\|VTEXTFIXED);
201	}
202	}
203	}
204	#endif
205
206
207	/*
208	* This routine initializes the builtin variables. It is called when the
209	* shell is initialized and again when a shell procedure is spawned.
210	*/
211
212	void
213	initvar(void)
214	{
215	const struct varinit *ip;
216	struct var *vp;
217	struct var **vpp;
218
219	#ifdef PC_OS2_LIBPATHS
220	char *psz = ckmalloc(2048);
221	int rc;
222	int i;
223	for (i = 0; i < 4; i++)
224	{
225	libpath_vars[i].flags = VSTRFIXED \| VOS2LIBPATH;
226	libpath_vars[i].func = NULL;
227
228	if (i > 0)
229	{
230	psz[0] = psz[1] = psz[2] = psz[3] = '\0';
231	rc = DosQueryExtLIBPATH(psz, i);
232	}
233	else
234	{
235	rc = DosQueryHeaderInfo(NULLHANDLE, 0, psz, 2048, QHINF_LIBPATH);
236	libpath_vars[i].flags \|= VREADONLY;
237	}
238	if (!rc && *psz)
239	{
240	int cch1 = strlen(libpath_envs[i]);
241	int cch2 = strlen(psz) + 1;
242	libpath_vars[i].text = ckmalloc(cch1 + cch2);
243	memcpy(libpath_vars[i].text, libpath_envs[i], cch1);
244	memcpy(libpath_vars[i].text + cch1, psz, cch2);
245	}
246	else
247	{
248	libpath_vars[i].flags \|= VUNSET \| VTEXTFIXED;
249	libpath_vars[i].text = (char*)libpath_envs[i];
250	}
251	if (find_var(libpath_vars[i].text, &vpp, &libpath_vars[i].name_len) != NULL)
252	continue;
253	libpath_vars[i].next = *vpp;
254	*vpp = &libpath_vars[i];
255	}
256	free(psz);
257	#endif
258
259	for (ip = varinit ; (vp = ip->var) != NULL ; ip++) {
260	if (find_var(ip->text, &vpp, &vp->name_len) != NULL)
261	continue;
262	vp->next = *vpp;
263	*vpp = vp;
264	vp->text = strdup(ip->text);
265	vp->flags = ip->flags;
266	vp->func = ip->func;
267	}
268	/*
269	* PS1 depends on uid
270	*/
271	if (find_var("PS1", &vpp, &vps1.name_len) == NULL) {
272	vps1.next = *vpp;
273	*vpp = &vps1;
274	vps1.text = strdup(geteuid() ? "PS1=$ " : "PS1=# ");
275	vps1.flags = VSTRFIXED\|VTEXTFIXED;
276	}
277	}
278
279	/*
280	* Safe version of setvar, returns 1 on success 0 on failure.
281	*/
282
283	int
284	setvarsafe(const char name, const char val, int flags)
285	{
286	struct jmploc jmploc;
287	struct jmploc *volatile savehandler = handler;
288	int err = 0;
289	#ifdef __GNUC__
290	(void) &err;
291	#endif
292
293	if (setjmp(jmploc.loc))
294	err = 1;
295	else {
296	handler = &jmploc;
297	setvar(name, val, flags);
298	}
299	handler = savehandler;
300	return err;
301	}
302
303	/*
304	* Set the value of a variable. The flags argument is ored with the
305	* flags of the variable. If val is NULL, the variable is unset.
306	*/
307
308	void
309	setvar(const char name, const char val, int flags)
310	{
311	const char *p;
312	const char *q;
313	char *d;
314	int len;
315	int namelen;
316	char *nameeq;
317	int isbad;
318
319	isbad = 0;
320	p = name;
321	if (! is_name(*p))
322	isbad = 1;
323	p++;
324	for (;;) {
325	if (! is_in_name(*p)) {
326	if (p == '\0' \|\| p == '=')
327	break;
328	isbad = 1;
329	}
330	p++;
331	}
332	namelen = p - name;
333	if (isbad)
334	error("%.*s: bad variable name", namelen, name);
335	len = namelen + 2; /* 2 is space for '=' and '\0' */
336	if (val == NULL) {
337	flags \|= VUNSET;
338	} else {
339	len += strlen(val);
340	}
341	d = nameeq = ckmalloc(len);
342	q = name;
343	while (--namelen >= 0)
344	d++ = q++;
345	*d++ = '=';
346	*d = '\0';
347	if (val)
348	scopy(val, d);
349	setvareq(nameeq, flags);
350	}
351
352
353
354	/*
355	* Same as setvar except that the variable and value are passed in
356	* the first argument as name=value. Since the first argument will
357	* be actually stored in the table, it should not be a string that
358	* will go away.
359	*/
360
361	void
362	setvareq(char *s, int flags)
363	{
364	struct var vp, *vpp;
365	int nlen;
366
367	if (aflag)
368	flags \|= VEXPORT;
369	vp = find_var(s, &vpp, &nlen);
370	if (vp != NULL) {
371	if (vp->flags & VREADONLY)
372	error("%.*s: is read only", vp->name_len, s);
373	if (flags & VNOSET)
374	return;
375	INTOFF;
376
377	if (vp->func && (flags & VNOFUNC) == 0)
378	(*vp->func)(s + vp->name_len + 1);
379
380	if ((vp->flags & (VTEXTFIXED\|VSTACK)) == 0)
381	ckfree(vp->text);
382
383	vp->flags &= ~(VTEXTFIXED\|VSTACK\|VUNSET);
384	vp->flags \|= flags & ~VNOFUNC;
385	vp->text = s;
386	#ifdef PC_OS2_LIBPATHS
387	if ((vp->flags & VOS2LIBPATH) && (vp->flags & VEXPORT))
388	vp->flags &= ~VEXPORT;
389	#endif
390
391	/*
392	* We could roll this to a function, to handle it as
393	* a regular variable function callback, but why bother?
394	*/
395	if (vp == &vmpath \|\| (vp == &vmail && ! mpathset()))
396	chkmail(1);
397	INTON;
398	return;
399	}
400	/* not found */
401	if (flags & VNOSET)
402	return;
403	vp = ckmalloc(sizeof (*vp));
404	vp->flags = flags & ~VNOFUNC;
405	vp->text = s;
406	vp->name_len = nlen;
407	vp->next = *vpp;
408	vp->func = NULL;
409	*vpp = vp;
410	}
411
412
413
414	/*
415	* Process a linked list of variable assignments.
416	*/
417
418	void
419	listsetvar(struct strlist *list, int flags)
420	{
421	struct strlist *lp;
422
423	INTOFF;
424	for (lp = list ; lp ; lp = lp->next) {
425	setvareq(savestr(lp->text), flags);
426	}
427	INTON;
428	}
429
430	void
431	listmklocal(struct strlist *list, int flags)
432	{
433	struct strlist *lp;
434
435	for (lp = list ; lp ; lp = lp->next)
436	mklocal(lp->text, flags);
437	}
438
439
440	/*
441	* Find the value of a variable. Returns NULL if not set.
442	*/
443
444	char *
445	lookupvar(const char *name)
446	{
447	struct var *v;
448
449	v = find_var(name, NULL, NULL);
450	if (v == NULL \|\| v->flags & VUNSET)
451	return NULL;
452	return v->text + v->name_len + 1;
453	}
454
455
456
457	/*
458	* Search the environment of a builtin command. If the second argument
459	* is nonzero, return the value of a variable even if it hasn't been
460	* exported.
461	*/
462
463	char *
464	bltinlookup(const char *name, int doall)
465	{
466	struct strlist *sp;
467	struct var *v;
468
469	for (sp = cmdenviron ; sp ; sp = sp->next) {
470	if (strequal(sp->text, name))
471	return strchr(sp->text, '=') + 1;
472	}
473
474	v = find_var(name, NULL, NULL);
475
476	if (v == NULL \|\| v->flags & VUNSET \|\| (!doall && !(v->flags & VEXPORT)))
477	return NULL;
478	return v->text + v->name_len + 1;
479	}
480
481
482
483	/*
484	* Generate a list of exported variables. This routine is used to construct
485	* the third argument to execve when executing a program.
486	*/
487
488	char **
489	environment(void)
490	{
491	int nenv;
492	struct var **vpp;
493	struct var *vp;
494	char **env;
495	char **ep;
496
497	nenv = 0;
498	for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
499	for (vp = *vpp ; vp ; vp = vp->next)
500	if (vp->flags & VEXPORT)
501	nenv++;
502	}
503	ep = env = stalloc((nenv + 1) * sizeof *env);
504	for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
505	for (vp = *vpp ; vp ; vp = vp->next)
506	if (vp->flags & VEXPORT)
507	*ep++ = vp->text;
508	}
509	*ep = NULL;
510
511	#ifdef PC_OS2_LIBPATHS
512	/*
513	* Set the libpaths now as this is exec() time.
514	*/
515	for (nenv = 0; nenv < 3; nenv++)
516	DosSetExtLIBPATH(strchr(libpath_vars[nenv].text, '=') + 1, nenv);
517	#endif
518
519	return env;
520	}
521
522
523	/*
524	* Called when a shell procedure is invoked to clear out nonexported
525	* variables. It is also necessary to reallocate variables of with
526	* VSTACK set since these are currently allocated on the stack.
527	*/
528
529	#ifdef mkinit
530	void shprocvar(void);
531
532	SHELLPROC {
533	shprocvar();
534	}
535	#endif
536
537	void
538	shprocvar(void)
539	{
540	struct var **vpp;
541	struct var vp, *prev;
542
543	for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
544	for (prev = vpp ; (vp = *prev) != NULL ; ) {
545	if ((vp->flags & VEXPORT) == 0) {
546	*prev = vp->next;
547	if ((vp->flags & VTEXTFIXED) == 0)
548	ckfree(vp->text);
549	if ((vp->flags & VSTRFIXED) == 0)
550	ckfree(vp);
551	} else {
552	if (vp->flags & VSTACK) {
553	vp->text = savestr(vp->text);
554	vp->flags &=~ VSTACK;
555	}
556	prev = &vp->next;
557	}
558	}
559	}
560	initvar();
561	}
562
563
564
565	/*
566	* Command to list all variables which are set. Currently this command
567	* is invoked from the set command when the set command is called without
568	* any variables.
569	*/
570
571	void
572	print_quoted(const char *p)
573	{
574	const char *q;
575
576	if (strcspn(p, "\|&;<>()$`\\\"' \t\n*?[]#~=%") == strlen(p)) {
577	out1fmt("%s", p);
578	return;
579	}
580	while (*p) {
581	if (*p == '\'') {
582	out1fmt("\\'");
583	p++;
584	continue;
585	}
586	q = index(p, '\'');
587	if (!q) {
588	out1fmt("'%s'", p );
589	return;
590	}
591	out1fmt("'%.*s'", (int)(q - p), p );
592	p = q;
593	}
594	}
595
596	static int
597	sort_var(const void v_v1, const void v_v2)
598	{
599	const struct var * const *v1 = v_v1;
600	const struct var * const *v2 = v_v2;
601
602	/* XXX Will anyone notice we include the '=' of the shorter name? */
603	return strcoll((v1)->text, (v2)->text);
604	}
605
606	/*
607	* POSIX requires that 'set' (but not export or readonly) output the
608	* variables in lexicographic order - by the locale's collating order (sigh).
609	* Maybe we could keep them in an ordered balanced binary tree
610	* instead of hashed lists.
611	* For now just roll 'em through qsort for printing...
612	*/
613
614	int
615	showvars(const char *name, int flag, int show_value)
616	{
617	struct var **vpp;
618	struct var *vp;
619	const char *p;
620
621	static struct var *list; / static in case we are interrupted */
622	static int list_len;
623	int count = 0;
624
625	if (!list) {
626	list_len = 32;
627	list = ckmalloc(list_len * sizeof *list);
628	}
629
630	for (vpp = vartab ; vpp < vartab + VTABSIZE ; vpp++) {
631	for (vp = *vpp ; vp ; vp = vp->next) {
632	if (flag && !(vp->flags & flag))
633	continue;
634	if (vp->flags & VUNSET && !(show_value & 2))
635	continue;
636	if (count >= list_len) {
637	list = ckrealloc(list,
638	(list_len << 1) * sizeof *list);
639	list_len <<= 1;
640	}
641	list[count++] = vp;
642	}
643	}
644
645	qsort(list, count, sizeof *list, sort_var);
646
647	for (vpp = list; count--; vpp++) {
648	vp = *vpp;
649	if (name)
650	out1fmt("%s ", name);
651	for (p = vp->text ; *p != '=' ; p++)
652	out1c(*p);
653	if (!(vp->flags & VUNSET) && show_value) {
654	out1fmt("=");
655	print_quoted(++p);
656	}
657	out1c('\n');
658	}
659	return 0;
660	}
661
662
663
664	/*
665	* The export and readonly commands.
666	*/
667
668	int
669	exportcmd(int argc, char **argv)
670	{
671	struct var *vp;
672	char *name;
673	const char *p;
674	int flag = argv[0][0] == 'r'? VREADONLY : VEXPORT;
675	int pflag;
676
677	pflag = nextopt("p") == 'p' ? 3 : 0;
678	if (argc <= 1 \|\| pflag) {
679	showvars( pflag ? argv[0] : 0, flag, pflag );
680	return 0;
681	}
682
683	while ((name = *argptr++) != NULL) {
684	if ((p = strchr(name, '=')) != NULL) {
685	p++;
686	} else {
687	vp = find_var(name, NULL, NULL);
688	if (vp != NULL) {
689	vp->flags \|= flag;
690	continue;
691	}
692	}
693	setvar(name, p, flag);
694	}
695	return 0;
696	}
697
698
699	/*
700	* The "local" command.
701	*/
702
703	int
704	localcmd(int argc, char **argv)
705	{
706	char *name;
707
708	if (! in_function())
709	error("Not in a function");
710	while ((name = *argptr++) != NULL) {
711	mklocal(name, 0);
712	}
713	return 0;
714	}
715
716
717	/*
718	* Make a variable a local variable. When a variable is made local, it's
719	* value and flags are saved in a localvar structure. The saved values
720	* will be restored when the shell function returns. We handle the name
721	* "-" as a special case.
722	*/
723
724	void
725	mklocal(const char *name, int flags)
726	{
727	struct localvar *lvp;
728	struct var **vpp;
729	struct var *vp;
730
731	INTOFF;
732	lvp = ckmalloc(sizeof (struct localvar));
733	if (name[0] == '-' && name[1] == '\0') {
734	char *p;
735	p = ckmalloc(sizeof_optlist);
736	lvp->text = memcpy(p, optlist, sizeof_optlist);
737	vp = NULL;
738	} else {
739	vp = find_var(name, &vpp, NULL);
740	if (vp == NULL) {
741	if (strchr(name, '='))
742	setvareq(savestr(name), VSTRFIXED\|flags);
743	else
744	setvar(name, NULL, VSTRFIXED\|flags);
745	vp = vpp; / the new variable */
746	lvp->text = NULL;
747	lvp->flags = VUNSET;
748	} else {
749	lvp->text = vp->text;
750	lvp->flags = vp->flags;
751	vp->flags \|= VSTRFIXED\|VTEXTFIXED;
752	if (name[vp->name_len] == '=')
753	setvareq(savestr(name), flags);
754	}
755	}
756	lvp->vp = vp;
757	lvp->next = localvars;
758	localvars = lvp;
759	INTON;
760	}
761
762
763	/*
764	* Called after a function returns.
765	*/
766
767	void
768	poplocalvars(void)
769	{
770	struct localvar *lvp;
771	struct var *vp;
772
773	while ((lvp = localvars) != NULL) {
774	localvars = lvp->next;
775	vp = lvp->vp;
776	TRACE(("poplocalvar %s", vp ? vp->text : "-"));
777	if (vp == NULL) { /* $- saved */
778	memcpy(optlist, lvp->text, sizeof_optlist);
779	ckfree(lvp->text);
780	} else if ((lvp->flags & (VUNSET\|VSTRFIXED)) == VUNSET) {
781	(void)unsetvar(vp->text, 0);
782	} else {
783	if (vp->func && (vp->flags & VNOFUNC) == 0)
784	(*vp->func)(lvp->text + vp->name_len + 1);
785	if ((vp->flags & VTEXTFIXED) == 0)
786	ckfree(vp->text);
787	vp->flags = lvp->flags;
788	vp->text = lvp->text;
789	}
790	ckfree(lvp);
791	}
792	}
793
794
795	int
796	setvarcmd(int argc, char **argv)
797	{
798	if (argc <= 2)
799	return unsetcmd(argc, argv);
800	else if (argc == 3)
801	setvar(argv[1], argv[2], 0);
802	else
803	error("List assignment not implemented");
804	return 0;
805	}
806
807
808	/*
809	* The unset builtin command. We unset the function before we unset the
810	* variable to allow a function to be unset when there is a readonly variable
811	* with the same name.
812	*/
813
814	int
815	unsetcmd(int argc, char **argv)
816	{
817	char **ap;
818	int i;
819	int flg_func = 0;
820	int flg_var = 0;
821	int ret = 0;
822
823	while ((i = nextopt("evf")) != '\0') {
824	if (i == 'f')
825	flg_func = 1;
826	else
827	flg_var = i;
828	}
829	if (flg_func == 0 && flg_var == 0)
830	flg_var = 1;
831
832	for (ap = argptr; *ap ; ap++) {
833	if (flg_func)
834	ret \|= unsetfunc(*ap);
835	if (flg_var)
836	ret \|= unsetvar(*ap, flg_var == 'e');
837	}
838	return ret;
839	}
840
841
842	/*
843	* Unset the specified variable.
844	*/
845
846	int
847	unsetvar(const char *s, int unexport)
848	{
849	struct var **vpp;
850	struct var *vp;
851
852	vp = find_var(s, &vpp, NULL);
853	if (vp == NULL)
854	return 1;
855
856	if (vp->flags & VREADONLY)
857	return (1);
858
859	INTOFF;
860	if (unexport) {
861	vp->flags &= ~VEXPORT;
862	} else {
863	if (vp->text[vp->name_len + 1] != '\0')
864	setvar(s, nullstr, 0);
865	vp->flags &= ~VEXPORT;
866	vp->flags \|= VUNSET;
867	if ((vp->flags & VSTRFIXED) == 0) {
868	if ((vp->flags & VTEXTFIXED) == 0)
869	ckfree(vp->text);
870	*vpp = vp->next;
871	ckfree(vp);
872	}
873	}
874	INTON;
875	return 0;
876	}
877
878
879	/*
880	* Returns true if the two strings specify the same varable. The first
881	* variable name is terminated by '='; the second may be terminated by
882	* either '=' or '\0'.
883	*/
884
885	STATIC int
886	strequal(const char p, const char q)
887	{
888	while (p == q++) {
889	if (*p++ == '=')
890	return 1;
891	}
892	if (p == '=' && (q - 1) == '\0')
893	return 1;
894	return 0;
895	}
896
897	/*
898	* Search for a variable.
899	* 'name' may be terminated by '=' or a NUL.
900	* vppp is set to the pointer to vp, or the list head if vp isn't found
901	* lenp is set to the number of charactets in 'name'
902	*/
903
904	STATIC struct var *
905	find_var(const char name, struct var *vppp, int lenp)
906	{
907	unsigned int hashval;
908	int len;
909	struct var vp, *vpp;
910	const char *p = name;
911
912	hashval = 0;
913	while (p && p != '=')
914	hashval = 2 * hashval + (unsigned char)*p++;
915	len = p - name;
916
917	if (lenp)
918	*lenp = len;
919	vpp = &vartab[hashval % VTABSIZE];
920	if (vppp)
921	*vppp = vpp;
922
923	for (vp = vpp ; vp ; vpp = &vp->next, vp = vpp) {
924	if (vp->name_len != len)
925	continue;
926	if (memcmp(vp->text, name, len) != 0)
927	continue;
928	if (vppp)
929	*vppp = vpp;
930	return vp;
931	}
932	return NULL;
933	}

Note: See TracBrowser for help on using the repository browser.

source: kBuild/trunk/src/ash/var.c@ 2017

Download in other formats: