/*  * tclMacEnv.c -- * *	Implements the "environment" on a Macintosh. * * Copyright (c) 1995-1996 Sun Microsystems, Inc. * * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * * RCS: @(#) $Id: tclMacEnv.c,v 1.2 1998/09/14 18:40:04 stanton Exp $ */#include <Gestalt.h>#include <Folders.h>#include <TextUtils.h>#include <Resources.h>#include <string.h>#include "tcl.h"#include "tclInt.h"#include "tclMacInt.h"#include "tclPort.h"#define kMaxEnvStringSize 	255#define kMaxEnvVarSize 		100#define kLoginnameTag 		"LOGIN="#define kUsernameTag 		"USER="#define kDefaultDirTag 		"HOME="/*  * The following specifies a text file where additional environment variables  * can be set.  The file must reside in the preferences folder.  If the file  * doesn't exist NO error will occur.  Commet out the difinition if you do  * NOT want to use an environment variables file.  */#define kPrefsFile	 		"Tcl Environment Variables"/*  * The following specifies the Name of a 'STR#' resource in the application  * where additional environment variables may be set.  If the resource doesn't * exist no errors will occur.  Commet it out if you don't want it. */#define REZ_ENV "\pTcl Environment Variables"/* Globals */char **environ = NULL;/* * Declarations for local procedures defined in this file: */static char ** RezRCVariables _ANSI_ARGS_((void));static char ** FileRCVariables _ANSI_ARGS_((void));static char ** PathVariables _ANSI_ARGS_((void));static char ** SystemVariables _ANSI_ARGS_((void));static char * MakeFolderEnvVar _ANSI_ARGS_((char * prefixTag,	long whichFolder));static char * GetUserName _ANSI_ARGS_((void));/* *---------------------------------------------------------------------- * * RezRCVariables -- * *  Creates environment variables from the applications resource fork. *  The function looks for the 'STR#' resource with the name defined *  in the #define REZ_ENV.  If the define is not defined this code *  will not be included.  If the resource doesn't exist or no strings *  reside in the resource nothing will happen. * * Results: *	ptr to value on success, NULL if error. * * Side effects: *	Memory is allocated and returned to the caller. * *---------------------------------------------------------------------- */#ifdef REZ_ENVstatic char ** RezRCVariables(){    Handle envStrs = NULL;    char** rezEnv = NULL;    short int numStrs;    envStrs = GetNamedResource('STR#', REZ_ENV);    if (envStrs == NULL) return NULL;    numStrs = *((short *) (*envStrs));	    rezEnv = (char **) ckalloc((numStrs + 1) * sizeof(char *));    if (envStrs != NULL) {	ResType	theType;	Str255 theName;	short theID, index = 1;	int i = 0;	char* string;		GetResInfo(envStrs, &theID, &theType, theName);	for(;;) {	    GetIndString(theName, theID, index++);	    if (theName[0] == '\0') break;	    string = (char *) ckalloc(theName[0] + 2);	    strncpy(string, (char *) theName + 1, theName[0]);	    string[theName[0]] = '\0';	    rezEnv[i++] = string;	}	ReleaseResource(envStrs);			rezEnv[i] = NULL;	return rezEnv;    }	    return NULL;}#endif/* *---------------------------------------------------------------------- * * FileRCVariables -- * *  Creates environment variables from a file in the system preferences *  folder.  The function looks for a file in the preferences folder  *  a name defined in the #define kPrefsFile.  If the define is not  *  defined this code will not be included.  If the resource doesn't exist or *  no strings reside in the resource nothing will happen. * * Results: *	ptr to value on success, NULL if error. * * Side effects: *	Memory is allocated and returned to the caller. * *---------------------------------------------------------------------- */#ifdef kPrefsFilestatic char ** FileRCVariables(){    char *prefsFolder = NULL;    char *tempPtr = NULL;    char **fileEnv = NULL;    FILE *thePrefsFile = NULL;    int	i;    FSSpec prefDir;    OSErr err;    Handle theString = NULL;    Tcl_Channel chan;    int size;    Tcl_DString lineRead;	    err = FSpFindFolder(kOnSystemDisk, kPreferencesFolderType, 	    kDontCreateFolder, &prefDir);    if (err != noErr) {	return NULL;    }    err = FSpPathFromLocation(&prefDir, &size, &theString);    if (err != noErr) {	return NULL;    }    (void) Munger(theString, size, NULL, 0, kPrefsFile, strlen(kPrefsFile));    HLock(theString);    chan = Tcl_OpenFileChannel(NULL, *theString, "r", 0);    HUnlock(theString);    DisposeHandle(theString);    if (chan == NULL) {	return NULL;    }    /*     * We found a env file.  Let start parsing it.     */    fileEnv = (char **) ckalloc((kMaxEnvVarSize + 1) * sizeof(char *));    i = 0;    Tcl_DStringInit(&lineRead);    while (Tcl_Gets(chan, &lineRead) != -1) {	/*	 * First strip off new line char	 */	if (lineRead.string[lineRead.length-1] == '\n') {	    lineRead.string[lineRead.length-1] = '\0';	}	if (lineRead.string[0] == '\0' || lineRead.string[0] == '#') {	    /*	     * skip empty lines or commented lines	     */	    Tcl_DStringSetLength(&lineRead, 0);	    continue;	}			tempPtr = (char *) ckalloc(lineRead.length + 1);	strcpy(tempPtr, lineRead.string);	fileEnv[i++] = tempPtr;	Tcl_DStringSetLength(&lineRead, 0);    }	    fileEnv[i] = NULL;    Tcl_Close(NULL, chan);    Tcl_DStringFree(&lineRead);	    return fileEnv;}#endif/* *---------------------------------------------------------------------- * * MakeFolderEnvVar -- * *	This function creates "environment" variable by taking a prefix and *	appending a folder path to a directory.  The directory is specified *	by a integer value acceptable by the FindFolder function. * * Results: *	The function returns an *allocated* string.  If the folder doesn't *	exist the return string is still allocated and just contains the *	given prefix. * * Side effects: *	Memory is allocated and returned to the caller. * *---------------------------------------------------------------------- */static char * MakeFolderEnvVar(    char * prefixTag,		/* Prefix added before result. */    long whichFolder)		/* Constant for FSpFindFolder. */{    char * thePath = NULL;    char * result = NULL;    OSErr theErr = noErr;    Handle theString = NULL;    FSSpec theFolder;    int size;    Tcl_DString pathStr;    Tcl_DString tagPathStr;        Tcl_DStringInit(&pathStr);    theErr = FSpFindFolder(kOnSystemDisk, whichFolder, 	    kDontCreateFolder, &theFolder);    if (theErr == noErr) {	theErr = FSpPathFromLocation(&theFolder, &size, &theString);			HLock(theString);	tclPlatform = TCL_PLATFORM_MAC;	Tcl_DStringAppend(&pathStr, *theString, -1);	HUnlock(theString);	DisposeHandle(theString);			Tcl_DStringInit(&tagPathStr);	Tcl_DStringAppend(&tagPathStr, prefixTag, strlen(prefixTag));	Tcl_DStringAppend(&tagPathStr, pathStr.string, pathStr.length);	Tcl_DStringFree(&pathStr);		/*	 * Make sure the path ends with a ':'	 */	if (tagPathStr.string[tagPathStr.length - 1] != ':') {	    Tcl_DStringAppend(&tagPathStr, ":", 1);	}	/*	 * Don't free tagPathStr - rather make sure it's allocated	 * and return it as the result.	 */	if (tagPathStr.string == tagPathStr.staticSpace) {	    result = (char *) ckalloc(tagPathStr.length + 1);	    strcpy(result, tagPathStr.string);	} else {	    result = tagPathStr.string;	}    } else {	result = (char *) ckalloc(strlen(prefixTag) + 1);	strcpy(result, prefixTag);    }	    return result;}/* *---------------------------------------------------------------------- * * PathVariables -- * *  Creates environment variables from the system call FSpFindFolder. *  The function generates environment variables for many of the  *  commonly used paths on the Macintosh. * * Results: *	ptr to value on success, NULL if error. * * Side effects: *	Memory is allocated and returned to the caller. * *---------------------------------------------------------------------- */static char ** PathVariables(){    int i = 0;    char **sysEnv;    char *thePath = NULL;        sysEnv = (char **) ckalloc((12) * sizeof(char *));    sysEnv[i++] = MakeFolderEnvVar("PREF_FOLDER=", kPreferencesFolderType);    sysEnv[i++] = MakeFolderEnvVar("SYS_FOLDER=", kSystemFolderType);    sysEnv[i++] = MakeFolderEnvVar("TEMP=", kTemporaryFolderType);    sysEnv[i++] = MakeFolderEnvVar("APPLE_M_FOLDER=", kAppleMenuFolderType);    sysEnv[i++] = MakeFolderEnvVar("CP_FOLDER=", kControlPanelFolderType);    sysEnv[i++] = MakeFolderEnvVar("DESK_FOLDER=", kDesktopFolderType);    sysEnv[i++] = MakeFolderEnvVar("EXT_FOLDER=", kExtensionFolderType);    sysEnv[i++] = MakeFolderEnvVar("PRINT_MON_FOLDER=",	    kPrintMonitorDocsFolderType);    sysEnv[i++] = MakeFolderEnvVar("SHARED_TRASH_FOLDER=",	    kWhereToEmptyTrashFolderType);    sysEnv[i++] = MakeFolderEnvVar("TRASH_FOLDER=", kTrashFolderType);    sysEnv[i++] = MakeFolderEnvVar("START_UP_FOLDER=", kStartupFolderType);    sysEnv[i++] = NULL;	    return sysEnv;}/* *---------------------------------------------------------------------- * * SystemVariables -- * *  Creates environment variables from various Mac system calls. * * Results: *	ptr to value on success, NULL if error. * * Side effects: *	Memory is allocated and returned to the caller. * *---------------------------------------------------------------------- */static char ** SystemVariables(){    int i = 0;    char ** sysEnv;    char * thePath = NULL;    Handle theString = NULL;    FSSpec currentDir;    int size;        sysEnv = (char **) ckalloc((4) * sizeof(char *));    /*     * Get user name from chooser.  It will be assigned to both     * the USER and LOGIN environment variables.     */    thePath = GetUserName();    if (thePath != NULL) {	sysEnv[i] = (char *) ckalloc(strlen(kLoginnameTag) + strlen(thePath) + 1);	strcpy(sysEnv[i], kLoginnameTag);	strcpy(sysEnv[i]+strlen(kLoginnameTag), thePath);	i++;	sysEnv[i] = (char *) ckalloc(strlen(kUsernameTag) + strlen(thePath) + 1);	strcpy(sysEnv[i], kUsernameTag);	strcpy(sysEnv[i]+strlen(kUsernameTag), thePath);	i++;    }    /*     * Get 'home' directory     */#ifdef kDefaultDirTag    FSpGetDefaultDir(&currentDir);    FSpPathFromLocation(&currentDir, &size, &theString);    HLock(theString);    sysEnv[i] = (char *) ckalloc(strlen(kDefaultDirTag) + size + 4);    strcpy(sysEnv[i], kDefaultDirTag);    strncpy(sysEnv[i]+strlen(kDefaultDirTag) , *theString, size);    if (sysEnv[i][strlen(kDefaultDirTag) + size - 1] != ':') {	sysEnv[i][strlen(kDefaultDirTag) + size] = ':';	sysEnv[i][strlen(kDefaultDirTag) + size + 1] = '\0';    } else {	sysEnv[i][strlen(kDefaultDirTag) + size] = '\0';    }    HUnlock(theString);    DisposeHandle(theString);    i++;#endif    sysEnv[i++] = NULL;    return sysEnv;}/* *---------------------------------------------------------------------- * * TclMacCreateEnv -- * *	This function allocates and populates the global "environ" *	variable.  Entries are in traditional Unix format but variables *	are, hopefully, a bit more relevant for the Macintosh. * * Results: *	The number of elements in the newly created environ array. * * Side effects: *	Memory is allocated and pointed too by the environ variable. * *---------------------------------------------------------------------- */intTclMacCreateEnv(){    char ** sysEnv = NULL;    char ** pathEnv = NULL;    char ** fileEnv = NULL;    char ** rezEnv = NULL;    int count = 0;    int i, j;    sysEnv = SystemVariables();    if (sysEnv != NULL) {	for (i = 0; sysEnv[i] != NULL; count++, i++) {	    /* Empty Loop */	}    }    pathEnv = PathVariables();    if (pathEnv != NULL) {	for (i = 0; pathEnv[i] != NULL; count++, i++) {	    /* Empty Loop */	}    }#ifdef kPrefsFile    fileEnv = FileRCVariables();    if (fileEnv != NULL) {	for (i = 0; fileEnv[i] != NULL; count++, i++) {	    /* Empty Loop */	}    }#endif#ifdef REZ_ENV    rezEnv = RezRCVariables();    if (rezEnv != NULL) {	for (i = 0; rezEnv[i] != NULL; count++, i++) {	    /* Empty Loop */	}    }#endif    /*     * Create environ variable     */    environ = (char **) ckalloc((count + 1) * sizeof(char *));    j = 0;	    if (sysEnv != NULL) {	for (i = 0; sysEnv[i] != NULL;)	    environ[j++] = sysEnv[i++];	ckfree((char *) sysEnv);    }    if (pathEnv != NULL) {	for (i = 0; pathEnv[i] != NULL;)	    environ[j++] = pathEnv[i++];	ckfree((char *) pathEnv);    }#ifdef kPrefsFile    if (fileEnv != NULL) {	for (i = 0; fileEnv[i] != NULL;)	    environ[j++] = fileEnv[i++];	ckfree((char *) fileEnv);    }#endif#ifdef REZ_ENV    if (rezEnv != NULL) {	for (i = 0; rezEnv[i] != NULL;)	    environ[j++] = rezEnv[i++];	ckfree((char *) rezEnv);    }#endif    environ[j] = NULL;    return j;}/* *---------------------------------------------------------------------- * * GetUserName -- * *	Get the user login name. * * Results: *  ptr to static string, NULL if error. * * Side effects: *	None. * *---------------------------------------------------------------------- */static char *GetUserName(){    static char buf[33];    short refnum;    Handle h;	    refnum = CurResFile();    UseResFile(0);    h = GetResource('STR ', -16096);    UseResFile(refnum);    if (h == NULL) {	return NULL;    }        HLock(h);    strncpy(buf, (*h)+1, **h);    buf[**h] = '\0';    HUnlock(h);    ReleaseResource(h);    return(buf[0] ? buf : NULL);}