[unix-history] / usr / src / usr.bin / mail / vars.c

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
static char *sccsid = "@(#)vars.c	5.2 (Berkeley) %G%";
#endif not lint

#include "rcv.h"

/*
 * Mail -- a mail program
 *
 * Variable handling stuff.
 */

/*
 * Assign a value to a variable.
 */

assign(name, value)
	char name[], value[];
{
	register struct var *vp;
	register int h;

	h = hash(name);
	vp = lookup(name);
	if (vp == NOVAR) {
		vp = (struct var *) calloc(sizeof *vp, 1);
		vp->v_name = vcopy(name);
		vp->v_link = variables[h];
		variables[h] = vp;
	}
	else
		vfree(vp->v_value);
	vp->v_value = vcopy(value);
}

/*
 * Free up a variable string.  We do not bother to allocate
 * strings whose value is "" since they are expected to be frequent.
 * Thus, we cannot free same!
 */

vfree(cp)
	register char *cp;
{
	if (!equal(cp, ""))
		cfree(cp);
}

/*
 * Copy a variable value into permanent (ie, not collected after each
 * command) space.  Do not bother to alloc space for ""
 */

char *
vcopy(str)
	char str[];
{
	register char *top, *cp, *cp2;

	if (equal(str, ""))
		return("");
	if ((top = calloc(strlen(str)+1, 1)) == NULL)
		panic ("Out of memory");
	cp = top;
	cp2 = str;
	while (*cp++ = *cp2++)
		;
	return(top);
}

/*
 * Get the value of a variable and return it.
 * Look in the environment if its not available locally.
 */

char *
value(name)
	char name[];
{
	register struct var *vp;

	if ((vp = lookup(name)) == NOVAR)
		return(getenv(name));
	return(vp->v_value);
}

/*
 * Locate a variable and return its variable
 * node.
 */

struct var *
lookup(name)
	char name[];
{
	register struct var *vp;
	register int h;

	h = hash(name);
	for (vp = variables[h]; vp != NOVAR; vp = vp->v_link)
		if (equal(vp->v_name, name))
			return(vp);
	return(NOVAR);
}

/*
 * Locate a group name and return it.
 */

struct grouphead *
findgroup(name)
	char name[];
{
	register struct grouphead *gh;
	register int h;

	h = hash(name);
	for (gh = groups[h]; gh != NOGRP; gh = gh->g_link)
		if (equal(gh->g_name, name))
			return(gh);
	return(NOGRP);
}

/*
 * Print a group out on stdout
 */

printgroup(name)
	char name[];
{
	register struct grouphead *gh;
	register struct group *gp;

	if ((gh = findgroup(name)) == NOGRP) {
		printf("\"%s\": not a group\n", name);
		return;
	}
	printf("%s\t", gh->g_name);
	for (gp = gh->g_list; gp != NOGE; gp = gp->ge_link)
		printf(" %s", gp->ge_name);
	printf("\n");
}

/*
 * Hash the passed string and return an index into
 * the variable or group hash table.
 */

hash(name)
	char name[];
{
	register unsigned h;
	register char *cp;

	for (cp = name, h = 0; *cp; h = (h << 2) + *cp++)
		;
	if (h < 0)
		h = -h;
	if (h < 0)
		h = 0;
	return(h % HSHSIZE);
}
Commit	Line	Data
761330fe DF	1	/*
	2	* Copyright (c) 1980 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
2ae9f53f	7	#ifndef lint
2fd8b883	8	static char *sccsid = "@(#)vars.c 5.2 (Berkeley) %G%";
761330fe	9	#endif not lint
2e4ee99d KS	10
	11	#include "rcv.h"
	12
	13	/*
	14	* Mail -- a mail program
	15	*
	16	* Variable handling stuff.
	17	*/
	18
2e4ee99d KS	19	/*
	20	* Assign a value to a variable.
	21	*/
	22
	23	assign(name, value)
	24	char name[], value[];
	25	{
	26	register struct var *vp;
	27	register int h;
	28
	29	h = hash(name);
	30	vp = lookup(name);
	31	if (vp == NOVAR) {
	32	vp = (struct var ) calloc(sizeof vp, 1);
	33	vp->v_name = vcopy(name);
	34	vp->v_link = variables[h];
	35	variables[h] = vp;
	36	}
	37	else
	38	vfree(vp->v_value);
	39	vp->v_value = vcopy(value);
	40	}
	41
	42	/*
	43	* Free up a variable string. We do not bother to allocate
	44	* strings whose value is "" since they are expected to be frequent.
	45	* Thus, we cannot free same!
	46	*/
	47
	48	vfree(cp)
	49	register char *cp;
	50	{
	51	if (!equal(cp, ""))
	52	cfree(cp);
	53	}
	54
	55	/*
	56	* Copy a variable value into permanent (ie, not collected after each
	57	* command) space. Do not bother to alloc space for ""
	58	*/
	59
	60	char *
	61	vcopy(str)
	62	char str[];
	63	{
	64	register char top, cp, *cp2;
	65
	66	if (equal(str, ""))
	67	return("");
733d2f97 CS	68	if ((top = calloc(strlen(str)+1, 1)) == NULL)
733d2f97 CS	69	panic ("Out of memory");
2e4ee99d KS	70	cp = top;
	71	cp2 = str;
	72	while (cp++ = cp2++)
	73	;
	74	return(top);
	75	}
	76
	77	/*
	78	* Get the value of a variable and return it.
	79	* Look in the environment if its not available locally.
	80	*/
	81
	82	char *
	83	value(name)
	84	char name[];
	85	{
	86	register struct var *vp;
	87
	88	if ((vp = lookup(name)) == NOVAR)
	89	return(getenv(name));
	90	return(vp->v_value);
	91	}
	92
	93	/*
	94	* Locate a variable and return its variable
	95	* node.
	96	*/
	97
	98	struct var *
	99	lookup(name)
	100	char name[];
	101	{
	102	register struct var *vp;
	103	register int h;
	104
	105	h = hash(name);
	106	for (vp = variables[h]; vp != NOVAR; vp = vp->v_link)
	107	if (equal(vp->v_name, name))
	108	return(vp);
	109	return(NOVAR);
	110	}
	111
	112	/*
	113	* Locate a group name and return it.
	114	*/
	115
	116	struct grouphead *
	117	findgroup(name)
	118	char name[];
	119	{
	120	register struct grouphead *gh;
	121	register int h;
	122
	123	h = hash(name);
	124	for (gh = groups[h]; gh != NOGRP; gh = gh->g_link)
	125	if (equal(gh->g_name, name))
	126	return(gh);
	127	return(NOGRP);
	128	}
	129
	130	/*
	131	* Print a group out on stdout
	132	*/
	133
134	printgroup(name)
135	char name[];
136	{
137	register struct grouphead *gh;
138	register struct group *gp;
139
140	if ((gh = findgroup(name)) == NOGRP) {
141	printf("\"%s\": not a group\n", name);
142	return;
143	}
144	printf("%s\t", gh->g_name);
145	for (gp = gh->g_list; gp != NOGE; gp = gp->ge_link)
146	printf(" %s", gp->ge_name);
147	printf("\n");
148	}
149
150	/*
151	* Hash the passed string and return an index into
152	* the variable or group hash table.
153	*/
154
155	hash(name)
156	char name[];
157	{
ca8907b2	158	register unsigned h;
2e4ee99d KS	159	register char *cp;
	160
	161	for (cp = name, h = 0; cp; h = (h << 2) + cp++)
	162	;
46691008 KS	163	if (h < 0)
	164	h = -h;
	165	if (h < 0)
	166	h = 0;
2e4ee99d KS	167	return(h % HSHSIZE);
2e4ee99d KS	168	}