usr/dash/alias.c

/*-
 * Copyright (c) 1993
 *	The Regents of the University of California.  All rights reserved.
 * Copyright (c) 1997-2005
 *	Herbert Xu <herbert@gondor.apana.org.au>.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Kenneth Almquist.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <stdlib.h>
#include "shell.h"
#include "input.h"
#include "output.h"
#include "error.h"
#include "memalloc.h"
#include "mystring.h"
#include "alias.h"
#include "options.h"	/* XXX for argptr (should remove?) */

#define ATABSIZE 39

struct alias *atab[ATABSIZE];

STATIC void setalias(const char *, const char *);
STATIC struct alias *freealias(struct alias *);
STATIC struct alias **__lookupalias(const char *);

STATIC
void
setalias(const char *name, const char *val)
{
	struct alias *ap, **app;

	app = __lookupalias(name);
	ap = *app;
	INTOFF;
	if (ap) {
		if (!(ap->flag & ALIASINUSE)) {
			ckfree(ap->val);
		}
		ap->val	= savestr(val);
		ap->flag &= ~ALIASDEAD;
	} else {
		/* not found */
		ap = ckmalloc(sizeof (struct alias));
		ap->name = savestr(name);
		ap->val = savestr(val);
		ap->flag = 0;
		ap->next = 0;
		*app = ap;
	}
	INTON;
}

int
unalias(const char *name)
{
	struct alias **app;

	app = __lookupalias(name);

	if (*app) {
		INTOFF;
		*app = freealias(*app);
		INTON;
		return (0);
	}

	return (1);
}

void
rmaliases(void)
{
	struct alias *ap, **app;
	int i;

	INTOFF;
	for (i = 0; i < ATABSIZE; i++) {
		app = &atab[i];
		for (ap = *app; ap; ap = *app) {
			*app = freealias(*app);
			if (ap == *app) {
				app = &ap->next;
			}
		}
	}
	INTON;
}

struct alias *
lookupalias(const char *name, int check)
{
	struct alias *ap = *__lookupalias(name);

	if (check && ap && (ap->flag & ALIASINUSE))
		return (NULL);
	return (ap);
}

/*
 * TODO - sort output
 */
int
aliascmd(int argc, char **argv)
{
	char *n, *v;
	int ret = 0;
	struct alias *ap;

	if (argc == 1) {
		int i;

		for (i = 0; i < ATABSIZE; i++)
			for (ap = atab[i]; ap; ap = ap->next) {
				printalias(ap);
			}
		return (0);
	}
	while ((n = *++argv) != NULL) {
		if ((v = strchr(n+1, '=')) == NULL) { /* n+1: funny ksh stuff */
			if ((ap = *__lookupalias(n)) == NULL) {
				outfmt(out2, "%s: %s not found\n", "alias", n);
				ret = 1;
			} else
				printalias(ap);
		} else {
			*v++ = '\0';
			setalias(n, v);
		}
	}

	return (ret);
}

int
unaliascmd(int argc, char **argv)
{
	int i;

	while ((i = nextopt("a")) != '\0') {
		if (i == 'a') {
			rmaliases();
			return (0);
		}
	}
	for (i = 0; *argptr; argptr++) {
		if (unalias(*argptr)) {
			outfmt(out2, "%s: %s not found\n", "unalias", *argptr);
			i = 1;
		}
	}

	return (i);
}

STATIC struct alias *
freealias(struct alias *ap) {
	struct alias *next;

	if (ap->flag & ALIASINUSE) {
		ap->flag |= ALIASDEAD;
		return ap;
	}

	next = ap->next;
	ckfree(ap->name);
	ckfree(ap->val);
	ckfree(ap);
	return next;
}

void
printalias(const struct alias *ap) {
	out1fmt("%s=%s\n", ap->name, single_quote(ap->val));
}

STATIC struct alias **
__lookupalias(const char *name) {
	unsigned int hashval;
	struct alias **app;
	const char *p;
	unsigned int ch;

	p = name;

	ch = (unsigned char)*p;
	hashval = ch << 4;
	while (ch) {
		hashval += ch;
		ch = (unsigned char)*++p;
	}
	app = &atab[hashval % ATABSIZE];

	for (; *app; app = &(*app)->next) {
		if (equal(name, (*app)->name)) {
			break;
		}
	}

	return app;
}
1	niro	532	/*-
2			* Copyright (c) 1993
3			* The Regents of the University of California. All rights reserved.
4			* Copyright (c) 1997-2005
5			* Herbert Xu <herbert@gondor.apana.org.au>. 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			#include <stdlib.h>
36			#include "shell.h"
37			#include "input.h"
38			#include "output.h"
39			#include "error.h"
40			#include "memalloc.h"
41			#include "mystring.h"
42			#include "alias.h"
43			#include "options.h" /* XXX for argptr (should remove?) */
44
45			#define ATABSIZE 39
46
47			struct alias *atab[ATABSIZE];
48
49			STATIC void setalias(const char , const char );
50			STATIC struct alias freealias(struct alias );
51			STATIC struct alias *__lookupalias(const char );
52
53			STATIC
54			void
55			setalias(const char name, const char val)
56			{
57			struct alias ap, *app;
58
59			app = __lookupalias(name);
60			ap = *app;
61			INTOFF;
62			if (ap) {
63			if (!(ap->flag & ALIASINUSE)) {
64			ckfree(ap->val);
65			}
66			ap->val = savestr(val);
67			ap->flag &= ~ALIASDEAD;
68			} else {
69			/* not found */
70			ap = ckmalloc(sizeof (struct alias));
71			ap->name = savestr(name);
72			ap->val = savestr(val);
73			ap->flag = 0;
74			ap->next = 0;
75			*app = ap;
76			}
77			INTON;
78			}
79
80			int
81			unalias(const char *name)
82			{
83			struct alias **app;
84
85			app = __lookupalias(name);
86
87			if (*app) {
88			INTOFF;
89			app = freealias(app);
90			INTON;
91			return (0);
92			}
93
94			return (1);
95			}
96
97			void
98			rmaliases(void)
99			{
100			struct alias ap, *app;
101			int i;
102
103			INTOFF;
104			for (i = 0; i < ATABSIZE; i++) {
105			app = &atab[i];
106			for (ap = app; ap; ap = app) {
107			app = freealias(app);
108			if (ap == *app) {
109			app = &ap->next;
110			}
111			}
112			}
113			INTON;
114			}
115
116			struct alias *
117			lookupalias(const char *name, int check)
118			{
119			struct alias ap = __lookupalias(name);
120
121			if (check && ap && (ap->flag & ALIASINUSE))
122			return (NULL);
123			return (ap);
124			}
125
126			/*
127			* TODO - sort output
128			*/
129			int
130			aliascmd(int argc, char **argv)
131			{
132			char n, v;
133			int ret = 0;
134			struct alias *ap;
135
136			if (argc == 1) {
137			int i;
138
139			for (i = 0; i < ATABSIZE; i++)
140			for (ap = atab[i]; ap; ap = ap->next) {
141			printalias(ap);
142			}
143			return (0);
144			}
145			while ((n = *++argv) != NULL) {
146			if ((v = strchr(n+1, '=')) == NULL) { /* n+1: funny ksh stuff */
147			if ((ap = *__lookupalias(n)) == NULL) {
148			outfmt(out2, "%s: %s not found\n", "alias", n);
149			ret = 1;
150			} else
151			printalias(ap);
152			} else {
153			*v++ = '\0';
154			setalias(n, v);
155			}
156			}
157
158			return (ret);
159			}
160
161			int
162			unaliascmd(int argc, char **argv)
163			{
164			int i;
165
166			while ((i = nextopt("a")) != '\0') {
167			if (i == 'a') {
168			rmaliases();
169			return (0);
170			}
171			}
172			for (i = 0; *argptr; argptr++) {
173			if (unalias(*argptr)) {
174			outfmt(out2, "%s: %s not found\n", "unalias", *argptr);
175			i = 1;
176			}
177			}
178
179			return (i);
180			}
181
182			STATIC struct alias *
183			freealias(struct alias *ap) {
184			struct alias *next;
185
186			if (ap->flag & ALIASINUSE) {
187			ap->flag \|= ALIASDEAD;
188			return ap;
189			}
190
191			next = ap->next;
192			ckfree(ap->name);
193			ckfree(ap->val);
194			ckfree(ap);
195			return next;
196			}
197
198			void
199			printalias(const struct alias *ap) {
200			out1fmt("%s=%s\n", ap->name, single_quote(ap->val));
201			}
202
203			STATIC struct alias **
204			__lookupalias(const char *name) {
205			unsigned int hashval;
206			struct alias **app;
207			const char *p;
208			unsigned int ch;
209
210			p = name;
211
212			ch = (unsigned char)*p;
213			hashval = ch << 4;
214			while (ch) {
215			hashval += ch;
216			ch = (unsigned char)*++p;
217			}
218			app = &atab[hashval % ATABSIZE];
219
220			for (; app; app = &(app)->next) {
221			if (equal(name, (*app)->name)) {
222			break;
223			}
224			}
225
226			return app;
227			}