macgetpath - sys.path setting code factored out of config.c and
macglue.c
macgetplatform - factored out of config.c
diff --git a/Mac/Python/macgetpath.c b/Mac/Python/macgetpath.c
new file mode 100644
index 0000000..12fcf71
--- /dev/null
+++ b/Mac/Python/macgetpath.c
@@ -0,0 +1,282 @@
+#include "Python.h"
+#include "osdefs.h"
+
+#include "pythonresources.h"
+
+
+/* Return the initial python search path. This is called once from
+** initsys() to initialize sys.path.
+**
+** If USE_BUILTIN_PATH is defined the path defined here is used
+** (after prepending the python home dir to each item).
+** If it is not defined the path is gotten from a resource in the
+** Preferences file.
+**
+** XXXX This code needs cleaning up. The routines here have moved
+** around quite a bit, and they're pretty messy for that reason.
+*/
+
+#include <Files.h>
+#include <Aliases.h>
+#include <Folders.h>
+#include <Resources.h>
+#include <TextUtils.h>
+
+#define PYTHONPATH "\
+:\n\
+:Lib\n\
+:Lib:stdwin\n\
+:Lib:test\n\
+:Lib:mac"
+
+
+char *
+getpythonpath()
+{
+ /* Modified by Jack to do something a bit more sensible:
+ ** - Prepend the python home-directory (which is obtained from a Preferences
+ ** resource)
+ ** - Add :
+ */
+ static char *pythonpath;
+ char *curwd;
+ char *p, *endp;
+ int newlen;
+ extern char *PyMac_GetPythonDir();
+#ifndef USE_BUILTIN_PATH
+ extern char *PyMac_GetPythonPath();
+#endif
+
+ if ( pythonpath ) return pythonpath;
+ curwd = PyMac_GetPythonDir();
+#ifndef USE_BUILTIN_PATH
+ if ( pythonpath = PyMac_GetPythonPath(curwd) )
+ return pythonpath;
+ printf("Warning: No pythonpath resource found, using builtin default\n");
+#endif
+ p = PYTHONPATH;
+ endp = p;
+ pythonpath = malloc(2);
+ if ( pythonpath == NULL ) return PYTHONPATH;
+ strcpy(pythonpath, ":");
+ while (*endp) {
+ endp = strchr(p, '\n');
+ if ( endp == NULL )
+ endp = p + strlen(p);
+ newlen = strlen(pythonpath) + 1 + strlen(curwd) + (endp-p);
+ pythonpath = realloc(pythonpath, newlen+1);
+ if ( pythonpath == NULL ) return PYTHONPATH;
+ strcat(pythonpath, "\n");
+ if ( *p == ':' ) {
+ p++;
+ strcat(pythonpath, curwd);
+ strncat(pythonpath, p, (endp-p));
+ newlen--; /* Ok, ok, we've allocated one byte too much */
+ } else {
+ /* We've allocated too much in this case */
+ newlen -= strlen(curwd);
+ pythonpath = realloc(pythonpath, newlen+1);
+ if ( pythonpath == NULL ) return PYTHONPATH;
+ strncat(pythonpath, p, (endp-p));
+ }
+ pythonpath[newlen] = '\0';
+ p = endp + 1;
+ }
+ return pythonpath;
+}
+
+
+/*
+** Return the name of the Python directory
+*/
+char *
+PyMac_GetPythonDir()
+{
+ int item;
+ static char name[256];
+ AliasHandle handle;
+ FSSpec dirspec;
+ int ok = 0;
+ Boolean modified = 0, cannotmodify = 0;
+ short oldrh, prefrh;
+ short prefdirRefNum;
+ long prefdirDirID;
+
+ /*
+ ** Remember old resource file and try to open preferences file
+ ** in the preferences folder. If it doesn't exist we try to create
+ ** it. If anything fails here we limp on, but set cannotmodify so
+ ** we don't try to store things later on.
+ */
+ oldrh = CurResFile();
+ if ( FindFolder(kOnSystemDisk, 'pref', kDontCreateFolder, &prefdirRefNum,
+ &prefdirDirID) != noErr ) {
+ /* Something wrong with preferences folder */
+ cannotmodify = 1;
+ } else {
+ (void)FSMakeFSSpec(prefdirRefNum, prefdirDirID, "\pPython Preferences", &dirspec);
+ prefrh = FSpOpenResFile(&dirspec, fsRdWrShPerm);
+ if ( prefrh == -1 ) {
+#ifdef USE_MAC_MODPREFS
+ /* It doesn't exist. Try to create it */
+ FSpCreateResFile(&dirspec, 'PYTH', 'pref', 0);
+ prefrh = FSpOpenResFile(&dirspec, fsRdWrShPerm);
+ if ( prefrh == -1 ) {
+ /* This is strange, what should we do now? */
+ cannotmodify = 1;
+ } else {
+ UseResFile(prefrh);
+ }
+#else
+ printf("Error: no Preferences file. Attempting to limp on...\n");
+ name[0] = 0;
+ getwd(name);
+ return name;
+#endif
+ }
+ }
+ /* So, we've opened our preferences file, we hope. Look for the alias */
+ handle = (AliasHandle)Get1Resource('alis', PYTHONHOME_ID);
+ if ( handle ) {
+ /* It exists. Resolve it (possibly updating it) */
+ if ( ResolveAlias(NULL, handle, &dirspec, &modified) == noErr ) {
+ ok = 1;
+ }
+ }
+ if ( !ok ) {
+#ifdef USE_MAC_MODPREFS
+ /* No luck, so far. ask the user for help */
+ item = Alert(NOPYTHON_ALERT, NULL);
+ if ( item == YES_ITEM ) {
+ /* The user wants to point us to a directory. Let her do so */
+ ok = PyMac_GetDirectory(&dirspec);
+ if ( ok )
+ modified = 1;
+ } else if ( item == CURWD_ITEM ) {
+ /* The user told us the current directory is fine. Build an FSSpec for it */
+ if ( getwd(name) ) {
+ if ( FSMakeFSSpec(0, 0, Pstring(name), &dirspec) == 0 ) {
+ ok = 1;
+ modified = 1;
+ }
+ }
+ }
+ if ( handle ) {
+ /* Set the (old, invalid) alias record to the new data */
+ UpdateAlias(NULL, &dirspec, handle, &modified);
+ }
+#else
+ printf("Error: corrupted Preferences file. Attempting to limp on...\n");
+ name[0] = 0;
+ getwd(name);
+ return name;
+#endif
+ }
+#ifdef USE_MAC_MODPREFS
+ if ( ok && modified && !cannotmodify) {
+ /* We have a new, valid fsspec and we can update the preferences file. Do so. */
+ if ( !handle ) {
+ if (NewAlias(NULL, &dirspec, &handle) == 0 )
+ AddResource((Handle)handle, 'alis', PYTHONHOME_ID, "\p");
+ } else {
+ ChangedResource((Handle)handle);
+ }
+ UpdateResFile(prefrh);
+ }
+#endif
+ if ( !cannotmodify ) {
+ /* This means we have the resfile open. Close it. */
+ CloseResFile(prefrh);
+ }
+ /* Back to the old resource file */
+ UseResFile(oldrh);
+ /* Now turn the fsspec into a path to give back to our caller */
+ if ( ok ) {
+ ok = (nfullpath(&dirspec, name) == 0);
+ if ( ok ) strcat(name, ":");
+ }
+ if ( !ok ) {
+ /* If all fails, we return the current directory */
+ name[0] = 0;
+ (void)getwd(name);
+ }
+ return name;
+}
+
+#ifndef USE_BUILTIN_PATH
+char *
+PyMac_GetPythonPath(dir)
+char *dir;
+{
+ FSSpec dirspec;
+ short oldrh, prefrh = -1;
+ short prefdirRefNum;
+ long prefdirDirID;
+ char *rv;
+ int i, newlen;
+ Str255 pathitem;
+
+ /*
+ ** Remember old resource file and try to open preferences file
+ ** in the preferences folder.
+ */
+ oldrh = CurResFile();
+ if ( FindFolder(kOnSystemDisk, 'pref', kDontCreateFolder, &prefdirRefNum,
+ &prefdirDirID) == noErr ) {
+ (void)FSMakeFSSpec(prefdirRefNum, prefdirDirID, "\pPython Preferences", &dirspec);
+ prefrh = FSpOpenResFile(&dirspec, fsRdWrShPerm);
+ }
+ /* At this point, we may or may not have the preferences file open, and it
+ ** may or may not contain a sys.path STR# resource. We don't care, if it doesn't
+ ** exist we use the one from the application (the default).
+ ** We put an initial '\n' in front of the path that we don't return to the caller
+ */
+ if( (rv = malloc(2)) == NULL )
+ goto out;
+ strcpy(rv, "\n");
+ for(i=1; ; i++) {
+ GetIndString(pathitem, PYTHONPATH_ID, i);
+ if( pathitem[0] == 0 )
+ break;
+ if ( pathitem[0] >= 9 && strncmp((char *)pathitem+1, "$(PYTHON)", 9) == 0 ) {
+ /* We have to put the directory in place */
+ newlen = strlen(rv) + strlen(dir) + (pathitem[0]-9) + 2;
+ if( (rv=realloc(rv, newlen)) == NULL)
+ goto out;
+ strcat(rv, dir);
+ /* Skip a colon at the beginning of the item */
+ if ( pathitem[0] > 9 && pathitem[1+9] == ':' ) {
+ memcpy(rv+strlen(rv), pathitem+1+10, pathitem[0]-10);
+ newlen--;
+ } else {
+ memcpy(rv+strlen(rv), pathitem+1+9, pathitem[0]-9);
+ }
+ rv[newlen-2] = '\n';
+ rv[newlen-1] = 0;
+ } else {
+ /* Use as-is */
+ newlen = strlen(rv) + (pathitem[0]) + 2;
+ if( (rv=realloc(rv, newlen)) == NULL)
+ goto out;
+ memcpy(rv+strlen(rv), pathitem+1, pathitem[0]);
+ rv[newlen-2] = '\n';
+ rv[newlen-1] = 0;
+ }
+ }
+ if( strlen(rv) == 1) {
+ free(rv);
+ rv = NULL;
+ }
+ if ( rv ) {
+ rv[strlen(rv)-1] = 0;
+ rv++;
+ }
+out:
+ if ( prefrh ) {
+ CloseResFile(prefrh);
+ UseResFile(oldrh);
+ }
+ return rv;
+}
+#endif /* !USE_BUILTIN_PATH */
+