![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tclenv.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Micropolis - Activity] / micropolis / src / tcl|
Return to tclenv.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tcl |
1.1 root 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:
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:
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:
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: length*sizeof(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:
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:
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:
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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.