[micropolis] / src / tcl / tclenv.c

/* 
 * tclEnv.c --
 *
 *	Tcl support for environment variables, including a setenv
 *	procedure.
 *
 * Copyright 1991 Regents of the University of California
 * Permission to use, copy, modify, and distribute this
 * software and its documentation for any purpose and without
 * fee is hereby granted, provided that this copyright
 * notice appears in all copies.  The University of California
 * makes no representations about the suitability of this
 * software for any purpose.  It is provided "as is" without
 * express or implied warranty.
 */

#ifndef lint
static char rcsid[] = "$Header: /user6/ouster/tcl/RCS/tclEnv.c,v 1.7 91/09/23 11:22:21 ouster Exp $ SPRITE (Berkeley)";
#endif /* not lint */

#include "tclint.h"
#include "tclunix.h"

/*
 * The structure below is used to keep track of all of the interpereters
 * for which we're managing the "env" array.  It's needed so that they
 * can all be updated whenever an environment variable is changed
 * anywhere.
 */

typedef struct EnvInterp {
    Tcl_Interp *interp;		/* Interpreter for which we're managing
				 * the env array. */
    struct EnvInterp *nextPtr;	/* Next in list of all such interpreters,
				 * or zero. */
} EnvInterp;

static EnvInterp *firstInterpPtr;
				/* First in list of all managed interpreters,
				 * or NULL if none. */

static int environSize = 0;	/* Non-zero means that the all of the
				 * environ-related information is malloc-ed
				 * and the environ array itself has this
				 * many total entries allocated to it (not
				 * all may be in use at once).  Zero means
				 * that the environment array is in its
				 * original static state. */

/*
 * Declarations for local procedures defined in this file:
 */

static void		EnvInit _ANSI_ARGS_((void));
static char *		EnvTraceProc _ANSI_ARGS_((ClientData clientData,
			    Tcl_Interp *interp, char *name1, char *name2,
			    int flags));
static int		FindVariable _ANSI_ARGS_((char *name, int *lengthPtr));

#ifdef IS_LINUX
int			setenv _ANSI_ARGS_((const char *name, const char *value, int replace));
int			unsetenv _ANSI_ARGS_((const char *name));
#else
void			setenv _ANSI_ARGS_((char *name, char *value));
void			unsetenv _ANSI_ARGS_((char *name));
#endif

\f
/*
 *----------------------------------------------------------------------
 *
 * TclSetupEnv --
 *
 *	This procedure is invoked for an interpreter to make environment
 *	variables accessible from that interpreter via the "env"
 *	associative array.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The interpreter is added to a list of interpreters managed
 *	by us, so that its view of envariables can be kept consistent
 *	with the view in other interpreters.  If this is the first
 *	call to Tcl_SetupEnv, then additional initialization happens,
 *	such as copying the environment to dynamically-allocated space
 *	for ease of management.
 *
 *----------------------------------------------------------------------
 */

void
TclSetupEnv(interp)
    Tcl_Interp *interp;		/* Interpreter whose "env" array is to be
				 * managed. */
{
    EnvInterp *eiPtr;
    int i;

    /*
     * First, initialize our environment-related information, if
     * necessary.
     */

    if (environSize == 0) {
	EnvInit();
    }

    /*
     * Next, add the interpreter to the list of those that we manage.
     */

    eiPtr = (EnvInterp *) ckalloc(sizeof(EnvInterp));
    eiPtr->interp = interp;
    eiPtr->nextPtr = firstInterpPtr;
    firstInterpPtr = eiPtr;

    /*
     * Store the environment variable values into the interpreter's
     * "env" array, and arrange for us to be notified on future
     * writes and unsets to that array.
     */

    (void) Tcl_UnsetVar2(interp, "env", (char *) NULL, TCL_GLOBAL_ONLY);
    for (i = 0; ; i++) {
	char *p, *p2;

	p = environ[i];
	if (p == NULL) {
	    break;
	}
	for (p2 = p; *p2 != '='; p2++) {
	    /* Empty loop body. */
	}
	*p2 = 0;
	(void) Tcl_SetVar2(interp, "env", p, p2+1, TCL_GLOBAL_ONLY);
	*p2 = '=';
    }
    Tcl_TraceVar2(interp, "env", (char *) NULL,
	    TCL_GLOBAL_ONLY | TCL_TRACE_WRITES | TCL_TRACE_UNSETS,
	    EnvTraceProc, (ClientData) NULL);
}
\f
/*
 *----------------------------------------------------------------------
 *
 * FindVariable --
 *
 *	Locate the entry in environ for a given name.
 *
 * Results:
 *	The return value is the index in environ of an entry with the
 *	name "name", or -1 if there is no such entry.   The integer at
 *	*lengthPtr is filled in with the length of name (if a matching
 *	entry is found) or the length of the environ array (if no matching
 *	entry is found).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

static int
FindVariable(name, lengthPtr)
    char *name;			/* Name of desired environment variable. */
    int *lengthPtr;		/* Used to return length of name (for
				 * successful searches) or number of non-NULL
				 * entries in environ (for unsuccessful
				 * searches). */
{
    int i;
    register char *p1, *p2;

    for (i = 0, p1 = environ[i]; p1 != NULL; i++, p1 = environ[i]) {
	for (p2 = name; *p2 == *p1; p1++, p2++) {
	    /* NULL loop body. */
	}
	if ((*p1 == '=') && (*p2 == '\0')) {
	    *lengthPtr = p2-name;
	    return i;
	}
    }
    *lengthPtr = i;
    return -1;
}
\f
/*
 *----------------------------------------------------------------------
 *
 * setenv --
 *
 *	Set an environment variable, replacing an existing value
 *	or creating a new variable if there doesn't exist a variable
 *	by the given name.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The environ array gets updated, as do all of the interpreters
 *	that we manage.
 *
 *----------------------------------------------------------------------
 */

#ifdef IS_LINUX
int
setenv(name, value, replace)
    const char *name;		/* Name of variable whose value is to be
				 * set. */
    const char *value;		/* New value for variable. */
    int replace;
#else
void
setenv(name, value)
    char *name;			/* Name of variable whose value is to be
				 * set. */
    char *value;		/* New value for variable. */
#endif
{
    int index, length, nameLength;
    char *p;
    EnvInterp *eiPtr;

    if (environSize == 0) {
	EnvInit();
    }

    /*
     * Figure out where the entry is going to go.  If the name doesn't
     * already exist, enlarge the array if necessary to make room.  If
     * the name exists, free its old entry.
     */

    index = FindVariable((char *)name, &length);
    if (index == -1) {
	if ((length+2) > environSize) {
	    char **newEnviron;

	    newEnviron = (char **) ckalloc((unsigned)
		    ((length+5) * sizeof(char *)));
	    memcpy((VOID *) newEnviron, (VOID *) environ,
		    length*sizeof(char *));
	    ckfree((char *) environ);
	    environ = newEnviron;
	    environSize = length+5;
	}
	index = length;
	environ[index+1] = NULL;
	nameLength = strlen(name);
    } else {
	ckfree(environ[index]);
	nameLength = length;
    }

    /*
     * Create a new entry and enter it into the table.
     */

    p = (char *) ckalloc((unsigned) (nameLength + strlen(value) + 2));
    environ[index] = p;
    strcpy(p, name);
    p += nameLength;
    *p = '=';
    strcpy(p+1, value);

    /*
     * Update all of the interpreters.
     */

    for (eiPtr= firstInterpPtr; eiPtr != NULL; eiPtr = eiPtr->nextPtr) {
	(void) Tcl_SetVar2(eiPtr->interp, "env", (char *)name, p+1, TCL_GLOBAL_ONLY);
    }

#ifdef IS_LINUX
    return 0;
#endif

}
\f
/*
 *----------------------------------------------------------------------
 *
 * unsetenv --
 *
 *	Remove an environment variable, updating the "env" arrays
 *	in all interpreters managed by us.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Interpreters are updated, as is environ.
 *
 *----------------------------------------------------------------------
 */

int
unsetenv(name)
#ifdef IS_LINUX
    const char *name;			/* Name of variable to remove. */
#else
    char *name;			/* Name of variable to remove. */
#endif
{
    int index, dummy;
    char **envPtr;
    EnvInterp *eiPtr;

    if (environSize == 0) {
	EnvInit();
    }

    /*
     * Update the environ array.
     */

    index = FindVariable((char *)name, &dummy);
    if (index == -1) {
	return;
    }
    ckfree(environ[index]);
    for (envPtr = environ+index+1; ; envPtr++) {
	envPtr[-1] = *envPtr;
	if (*envPtr == NULL) {
	    break;
       }
    }

    /*
     * Update all of the interpreters.
     */

    for (eiPtr = firstInterpPtr; eiPtr != NULL; eiPtr = eiPtr->nextPtr) {
	(void) Tcl_UnsetVar2(eiPtr->interp, "env", (char *)name, TCL_GLOBAL_ONLY);
    }
}
\f
/*
 *----------------------------------------------------------------------
 *
 * EnvTraceProc --
 *
 *	This procedure is invoked whenever an environment variable
 *	is modified or deleted.  It propagates the change to the
 *	"environ" array and to any other interpreters for whom
 *	we're managing an "env" array.
 *
 * Results:
 *	Always returns NULL to indicate success.
 *
 * Side effects:
 *	Environment variable changes get propagated.  If the whole
 *	"env" array is deleted, then we stop managing things for
 *	this interpreter (usually this happens because the whole
 *	interpreter is being deleted).
 *
 *----------------------------------------------------------------------
 */

	/* ARGSUSED */
static char *
EnvTraceProc(clientData, interp, name1, name2, flags)
    ClientData clientData;	/* Not used. */
    Tcl_Interp *interp;		/* Interpreter whose "env" variable is
				 * being modified. */
    char *name1;		/* Better be "env". */
    char *name2;		/* Name of variable being modified, or
				 * NULL if whole array is being deleted. */
    int flags;			/* Indicates what's happening. */
{
    /*
     * First see if the whole "env" variable is being deleted.  If
     * so, just forget about this interpreter.
     */

    if (name2 == NULL) {
	register EnvInterp *eiPtr, *prevPtr;

	if ((flags & (TCL_TRACE_UNSETS|TCL_TRACE_DESTROYED))
		!= (TCL_TRACE_UNSETS|TCL_TRACE_DESTROYED)) {
	    panic("EnvTraceProc called with confusing arguments");
	}
	eiPtr = firstInterpPtr;
	if (eiPtr->interp == interp) {
	    firstInterpPtr = eiPtr->nextPtr;
	} else {
	    for (prevPtr = eiPtr, eiPtr = eiPtr->nextPtr; ;
		    prevPtr = eiPtr, eiPtr = eiPtr->nextPtr) {
		if (eiPtr == NULL) {
		    panic("EnvTraceProc couldn't find interpreter");
		}
		if (eiPtr->interp == interp) {
		    prevPtr->nextPtr = eiPtr->nextPtr;
		    break;
		}
	    }
	}
	ckfree((char *) eiPtr);
	return NULL;
    }

    /*
     * If a value is being set, call setenv to do all of the work.
     */

    if (flags & TCL_TRACE_WRITES) {
	setenv(name2, Tcl_GetVar2(interp, "env", name2, TCL_GLOBAL_ONLY), 0);
    }

    if (flags & TCL_TRACE_UNSETS) {
	unsetenv(name2);
    }
    return NULL;
}
\f
/*
 *----------------------------------------------------------------------
 *
 * EnvInit --
 *
 *	This procedure is called to initialize our management
 *	of the environ array.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Environ gets copied to malloc-ed storage, so that in
 *	the future we don't have to worry about which entries
 *	are malloc-ed and which are static.
 *
 *----------------------------------------------------------------------
 */

static void
EnvInit()
{
    char **newEnviron;
    int i, length;

    if (environSize != 0) {
	return;
    }
    for (length = 0; environ[length] != NULL; length++) {
	/* Empty loop body. */
    }
    environSize = length+5;
    newEnviron = (char **) ckalloc((unsigned)
		(environSize * sizeof(char *)));
    for (i = 0; i < length; i++) {
	newEnviron[i] = (char *) ckalloc((unsigned) (strlen(environ[i]) + 1));
	strcpy(newEnviron[i], environ[i]);
    }
    newEnviron[length] = NULL;
    environ = newEnviron;
}
Commit	Line	Data
6a5fa4e0 MG	1	/*
	2	* tclEnv.c --
	3	*
	4	* Tcl support for environment variables, including a setenv
	5	* procedure.
	6	*
	7	* Copyright 1991 Regents of the University of California
	8	* Permission to use, copy, modify, and distribute this
	9	* software and its documentation for any purpose and without
	10	* fee is hereby granted, provided that this copyright
	11	* notice appears in all copies. The University of California
	12	* makes no representations about the suitability of this
	13	* software for any purpose. It is provided "as is" without
	14	* express or implied warranty.
	15	*/
	16
	17	#ifndef lint
	18	static char rcsid[] = "$Header: /user6/ouster/tcl/RCS/tclEnv.c,v 1.7 91/09/23 11:22:21 ouster Exp $ SPRITE (Berkeley)";
	19	#endif /* not lint */
	20
	21	#include "tclint.h"
	22	#include "tclunix.h"
	23
	24	/*
	25	* The structure below is used to keep track of all of the interpereters
	26	* for which we're managing the "env" array. It's needed so that they
	27	* can all be updated whenever an environment variable is changed
	28	* anywhere.
	29	*/
	30
	31	typedef struct EnvInterp {
	32	Tcl_Interp interp; / Interpreter for which we're managing
	33	* the env array. */
	34	struct EnvInterp nextPtr; / Next in list of all such interpreters,
	35	* or zero. */
	36	} EnvInterp;
	37
	38	static EnvInterp *firstInterpPtr;
	39	/* First in list of all managed interpreters,
	40	* or NULL if none. */
	41
	42	static int environSize = 0; /* Non-zero means that the all of the
	43	* environ-related information is malloc-ed
	44	* and the environ array itself has this
	45	* many total entries allocated to it (not
	46	* all may be in use at once). Zero means
	47	* that the environment array is in its
	48	* original static state. */
	49
	50	/*
	51	* Declarations for local procedures defined in this file:
	52	*/
	53
	54	static void EnvInit _ANSI_ARGS_((void));
	55	static char * EnvTraceProc _ANSI_ARGS_((ClientData clientData,
	56	Tcl_Interp interp, char name1, char *name2,
	57	int flags));
	58	static int FindVariable _ANSI_ARGS_((char name, int lengthPtr));
	59
	60	#ifdef IS_LINUX
	61	int setenv _ANSI_ARGS_((const char name, const char value, int replace));
	62	int unsetenv _ANSI_ARGS_((const char *name));
	63	#else
	64	void setenv _ANSI_ARGS_((char name, char value));
65	void unsetenv _ANSI_ARGS_((char *name));
66	#endif
67
68	\f
69	/*
70	*----------------------------------------------------------------------
71	*
72	* TclSetupEnv --
73	*
74	* This procedure is invoked for an interpreter to make environment
75	* variables accessible from that interpreter via the "env"
76	* associative array.
77	*
78	* Results:
79	* None.
80	*
81	* Side effects:
82	* The interpreter is added to a list of interpreters managed
83	* by us, so that its view of envariables can be kept consistent
84	* with the view in other interpreters. If this is the first
85	* call to Tcl_SetupEnv, then additional initialization happens,
86	* such as copying the environment to dynamically-allocated space
87	* for ease of management.
88	*
89	*----------------------------------------------------------------------
90	*/
91
92	void
93	TclSetupEnv(interp)
94	Tcl_Interp interp; / Interpreter whose "env" array is to be
95	* managed. */
96	{
97	EnvInterp *eiPtr;
98	int i;
99
100	/*
101	* First, initialize our environment-related information, if
102	* necessary.
103	*/
104
105	if (environSize == 0) {
106	EnvInit();
107	}
108
109	/*
110	* Next, add the interpreter to the list of those that we manage.
111	*/
112
113	eiPtr = (EnvInterp *) ckalloc(sizeof(EnvInterp));
114	eiPtr->interp = interp;
115	eiPtr->nextPtr = firstInterpPtr;
116	firstInterpPtr = eiPtr;
117
118	/*
119	* Store the environment variable values into the interpreter's
120	* "env" array, and arrange for us to be notified on future
121	* writes and unsets to that array.
122	*/
123
124	(void) Tcl_UnsetVar2(interp, "env", (char *) NULL, TCL_GLOBAL_ONLY);
125	for (i = 0; ; i++) {
126	char p, p2;
127
128	p = environ[i];
129	if (p == NULL) {
130	break;
131	}
132	for (p2 = p; *p2 != '='; p2++) {
133	/* Empty loop body. */
134	}
135	*p2 = 0;
136	(void) Tcl_SetVar2(interp, "env", p, p2+1, TCL_GLOBAL_ONLY);
137	*p2 = '=';
138	}
139	Tcl_TraceVar2(interp, "env", (char *) NULL,
140	TCL_GLOBAL_ONLY \| TCL_TRACE_WRITES \| TCL_TRACE_UNSETS,
141	EnvTraceProc, (ClientData) NULL);
142	}
143	\f
144	/*
145	*----------------------------------------------------------------------
146	*
147	* FindVariable --
148	*
149	* Locate the entry in environ for a given name.
150	*
151	* Results:
152	* The return value is the index in environ of an entry with the
153	* name "name", or -1 if there is no such entry. The integer at
154	* *lengthPtr is filled in with the length of name (if a matching
155	* entry is found) or the length of the environ array (if no matching
156	* entry is found).
157	*
158	* Side effects:
159	* None.
160	*
161	*----------------------------------------------------------------------
162	*/
163
164	static int
165	FindVariable(name, lengthPtr)
166	char name; / Name of desired environment variable. */
167	int lengthPtr; / Used to return length of name (for
168	* successful searches) or number of non-NULL
169	* entries in environ (for unsuccessful
170	* searches). */
171	{
172	int i;
173	register char p1, p2;
174
175	for (i = 0, p1 = environ[i]; p1 != NULL; i++, p1 = environ[i]) {
176	for (p2 = name; p2 == p1; p1++, p2++) {
177	/* NULL loop body. */
178	}
179	if ((p1 == '=') && (p2 == '\0')) {
180	*lengthPtr = p2-name;
181	return i;
182	}
183	}
184	*lengthPtr = i;
185	return -1;
186	}
187	\f
188	/*
189	*----------------------------------------------------------------------
190	*
191	* setenv --
192	*
193	* Set an environment variable, replacing an existing value
194	* or creating a new variable if there doesn't exist a variable
195	* by the given name.
196	*
197	* Results:
198	* None.
199	*
200	* Side effects:
201	* The environ array gets updated, as do all of the interpreters
202	* that we manage.
203	*
204	*----------------------------------------------------------------------
205	*/
206
207	#ifdef IS_LINUX
208	int
209	setenv(name, value, replace)
210	const char name; / Name of variable whose value is to be
211	* set. */
212	const char value; / New value for variable. */
213	int replace;
214	#else
215	void
216	setenv(name, value)
217	char name; / Name of variable whose value is to be
218	* set. */
219	char value; / New value for variable. */
220	#endif
221	{
222	int index, length, nameLength;
223	char *p;
224	EnvInterp *eiPtr;
225
226	if (environSize == 0) {
227	EnvInit();
228	}
229
230	/*
231	* Figure out where the entry is going to go. If the name doesn't
232	* already exist, enlarge the array if necessary to make room. If
233	* the name exists, free its old entry.
234	*/
235
236	index = FindVariable((char *)name, &length);
237	if (index == -1) {
238	if ((length+2) > environSize) {
239	char **newEnviron;
240
241	newEnviron = (char **) ckalloc((unsigned)
242	((length+5) * sizeof(char *)));
243	memcpy((VOID ) newEnviron, (VOID ) environ,
244	lengthsizeof(char ));
245	ckfree((char *) environ);
246	environ = newEnviron;
247	environSize = length+5;
248	}
249	index = length;
250	environ[index+1] = NULL;
251	nameLength = strlen(name);
252	} else {
253	ckfree(environ[index]);
254	nameLength = length;
255	}
256
257	/*
258	* Create a new entry and enter it into the table.
259	*/
260
261	p = (char *) ckalloc((unsigned) (nameLength + strlen(value) + 2));
262	environ[index] = p;
263	strcpy(p, name);
264	p += nameLength;
265	*p = '=';
266	strcpy(p+1, value);
267
268	/*
269	* Update all of the interpreters.
270	*/
271
272	for (eiPtr= firstInterpPtr; eiPtr != NULL; eiPtr = eiPtr->nextPtr) {
273	(void) Tcl_SetVar2(eiPtr->interp, "env", (char *)name, p+1, TCL_GLOBAL_ONLY);
274	}
275
276	#ifdef IS_LINUX
277	return 0;
278	#endif
279
280	}
281	\f
282	/*
283	*----------------------------------------------------------------------
284	*
285	* unsetenv --
286	*
287	* Remove an environment variable, updating the "env" arrays
288	* in all interpreters managed by us.
289	*
290	* Results:
291	* None.
292	*
293	* Side effects:
294	* Interpreters are updated, as is environ.
295	*
296	*----------------------------------------------------------------------
297	*/
298
299	int
300	unsetenv(name)
301	#ifdef IS_LINUX
302	const char name; / Name of variable to remove. */
303	#else
304	char name; / Name of variable to remove. */
305	#endif
306	{
307	int index, dummy;
308	char **envPtr;
309	EnvInterp *eiPtr;
310
311	if (environSize == 0) {
312	EnvInit();
313	}
314
315	/*
316	* Update the environ array.
317	*/
318
319	index = FindVariable((char *)name, &dummy);
320	if (index == -1) {
321	return;
322	}
323	ckfree(environ[index]);
324	for (envPtr = environ+index+1; ; envPtr++) {
325	envPtr[-1] = *envPtr;
326	if (*envPtr == NULL) {
327	break;
328	}
329	}
330
331	/*
332	* Update all of the interpreters.
333	*/
334
335	for (eiPtr = firstInterpPtr; eiPtr != NULL; eiPtr = eiPtr->nextPtr) {
336	(void) Tcl_UnsetVar2(eiPtr->interp, "env", (char *)name, TCL_GLOBAL_ONLY);
337	}
338	}
339	\f
340	/*
341	*----------------------------------------------------------------------
342	*
343	* EnvTraceProc --
344	*
345	* This procedure is invoked whenever an environment variable
346	* is modified or deleted. It propagates the change to the
347	* "environ" array and to any other interpreters for whom
348	* we're managing an "env" array.
349	*
350	* Results:
351	* Always returns NULL to indicate success.
352	*
353	* Side effects:
354	* Environment variable changes get propagated. If the whole
355	* "env" array is deleted, then we stop managing things for
356	* this interpreter (usually this happens because the whole
357	* interpreter is being deleted).
358	*
359	*----------------------------------------------------------------------
360	*/
361
362	/* ARGSUSED */
363	static char *
364	EnvTraceProc(clientData, interp, name1, name2, flags)
365	ClientData clientData; /* Not used. */
366	Tcl_Interp interp; / Interpreter whose "env" variable is
367	* being modified. */
368	char name1; / Better be "env". */
369	char name2; / Name of variable being modified, or
370	* NULL if whole array is being deleted. */
371	int flags; /* Indicates what's happening. */
372	{
373	/*
374	* First see if the whole "env" variable is being deleted. If
375	* so, just forget about this interpreter.
376	*/
377
378	if (name2 == NULL) {
379	register EnvInterp eiPtr, prevPtr;
380
381	if ((flags & (TCL_TRACE_UNSETS\|TCL_TRACE_DESTROYED))
382	!= (TCL_TRACE_UNSETS\|TCL_TRACE_DESTROYED)) {
383	panic("EnvTraceProc called with confusing arguments");
384	}
385	eiPtr = firstInterpPtr;
386	if (eiPtr->interp == interp) {
387	firstInterpPtr = eiPtr->nextPtr;
388	} else {
389	for (prevPtr = eiPtr, eiPtr = eiPtr->nextPtr; ;
390	prevPtr = eiPtr, eiPtr = eiPtr->nextPtr) {
391	if (eiPtr == NULL) {
392	panic("EnvTraceProc couldn't find interpreter");
393	}
394	if (eiPtr->interp == interp) {
395	prevPtr->nextPtr = eiPtr->nextPtr;
396	break;
397	}
398	}
399	}
400	ckfree((char *) eiPtr);
401	return NULL;
402	}
403
404	/*
405	* If a value is being set, call setenv to do all of the work.
406	*/
407
408	if (flags & TCL_TRACE_WRITES) {
409	setenv(name2, Tcl_GetVar2(interp, "env", name2, TCL_GLOBAL_ONLY), 0);
410	}
411
412	if (flags & TCL_TRACE_UNSETS) {
413	unsetenv(name2);
414	}
415	return NULL;
416	}
417	\f
418	/*
419	*----------------------------------------------------------------------
420	*
421	* EnvInit --
422	*
423	* This procedure is called to initialize our management
424	* of the environ array.
425	*
426	* Results:
427	* None.
428	*
429	* Side effects:
430	* Environ gets copied to malloc-ed storage, so that in
431	* the future we don't have to worry about which entries
432	* are malloc-ed and which are static.
433	*
434	*----------------------------------------------------------------------
435	*/
436
437	static void
438	EnvInit()
439	{
440	char **newEnviron;
441	int i, length;
442
443	if (environSize != 0) {
444	return;
445	}
446	for (length = 0; environ[length] != NULL; length++) {
447	/* Empty loop body. */
448	}
449	environSize = length+5;
450	newEnviron = (char **) ckalloc((unsigned)
451	(environSize * sizeof(char *)));
452	for (i = 0; i < length; i++) {
453	newEnviron[i] = (char *) ckalloc((unsigned) (strlen(environ[i]) + 1));
454	strcpy(newEnviron[i], environ[i]);
455	}
456	newEnviron[length] = NULL;
457	environ = newEnviron;
458	}