Python code coverage for PC/os2emx/getpathp.c

#	count	content
1	n/a
2	n/a	/* Return the initial module search path. */
3	n/a	/* This version used by OS/2+EMX */
4	n/a
5	n/a	/* ----------------------------------------------------------------
6	n/a	PATH RULES FOR OS/2+EMX:
7	n/a	This describes how sys.path is formed on OS/2+EMX. It describes the
8	n/a	functionality, not the implementation (ie, the order in which these
9	n/a	are actually fetched is different)
10	n/a
11	n/a	* Python always adds an empty entry at the start, which corresponds
12	n/a	to the current directory.
13	n/a
14	n/a	* If the PYTHONPATH env. var. exists, its entries are added next.
15	n/a
16	n/a	* We attempt to locate the "Python Home" - if the PYTHONHOME env var
17	n/a	is set, we believe it. Otherwise, we use the path of our host .EXE's
18	n/a	to try and locate our "landmark" (lib\\os.py) and deduce our home.
19	n/a	- If we DO have a Python Home: The relevant sub-directories (Lib,
20	n/a	plat-win, etc) are based on the Python Home
21	n/a	- If we DO NOT have a Python Home, the core Python Path is
22	n/a	loaded from the registry. This is the main PythonPath key,
23	n/a	and both HKLM and HKCU are combined to form the path)
24	n/a
25	n/a	* Iff - we can not locate the Python Home, and have not had a PYTHONPATH
26	n/a	specified (ie, we have _nothing_ we can assume is a good path), a
27	n/a	default path with relative entries is used (eg. .\Lib;.\plat-win, etc)
28	n/a
29	n/a
30	n/a	The end result of all this is:
31	n/a	* When running python.exe, or any other .exe in the main Python directory
32	n/a	(either an installed version, or directly from the PCbuild directory),
33	n/a	the core path is deduced.
34	n/a
35	n/a	* When Python is hosted in another exe (different directory, embedded via
36	n/a	COM, etc), the Python Home will not be deduced, so the core path from
37	n/a	the registry is used. Other "application paths "in the registry are
38	n/a	always read.
39	n/a
40	n/a	* If Python can't find its home and there is no registry (eg, frozen
41	n/a	exe, some very strange installation setup) you get a path with
42	n/a	some default, but relative, paths.
43	n/a
44	n/a	---------------------------------------------------------------- */
45	n/a
46	n/a
47	n/a	#include "Python.h"
48	n/a	#include "osdefs.h"
49	n/a
50	n/a	#ifndef PYOS_OS2
51	n/a	#error This file only compilable on OS/2
52	n/a	#endif
53	n/a
54	n/a	#define INCL_DOS
55	n/a	#include <os2.h>
56	n/a
57	n/a	#include <sys/types.h>
58	n/a	#include <sys/stat.h>
59	n/a	#include <string.h>
60	n/a
61	n/a	#if HAVE_UNISTD_H
62	n/a	#include <unistd.h>
63	n/a	#endif /* HAVE_UNISTD_H */
64	n/a
65	n/a	/* Search in some common locations for the associated Python libraries.
66	n/a	*
67	n/a	* Py_GetPath() tries to return a sensible Python module search path.
68	n/a	*
69	n/a	* The approach is an adaptation for Windows of the strategy used in
70	n/a	* ../Modules/getpath.c; it uses the Windows Registry as one of its
71	n/a	* information sources.
72	n/a	*/
73	n/a
74	n/a	#ifndef LANDMARK
75	n/a	#if defined(PYCC_GCC)
76	n/a	#define LANDMARK "lib/os.py"
77	n/a	#else
78	n/a	#define LANDMARK "lib\\os.py"
79	n/a	#endif
80	n/a	#endif
81	n/a
82	n/a	static char prefix[MAXPATHLEN+1];
83	n/a	static char progpath[MAXPATHLEN+1];
84	n/a	static char *module_search_path = NULL;
85	n/a
86	n/a
87	n/a	static int
88	n/a	is_sep(char ch) /* determine if "ch" is a separator character */
89	n/a	{
90	n/a	#ifdef ALTSEP
91	n/a	return ch == SEP \|\| ch == ALTSEP;
92	n/a	#else
93	n/a	return ch == SEP;
94	n/a	#endif
95	n/a	}
96	n/a
97	n/a	/* assumes 'dir' null terminated in bounds.
98	n/a	* Never writes beyond existing terminator.
99	n/a	*/
100	n/a	static void
101	n/a	reduce(char *dir)
102	n/a	{
103	n/a	size_t i = strlen(dir);
104	n/a	while (i > 0 && !is_sep(dir[i]))
105	n/a	--i;
106	n/a	dir[i] = '\0';
107	n/a	}
108	n/a
109	n/a	static int
110	n/a	exists(char *filename)
111	n/a	{
112	n/a	struct stat buf;
113	n/a	return stat(filename, &buf) == 0;
114	n/a	}
115	n/a
116	n/a	/* Is module (check for .pyc/.pyo too)
117	n/a	* Assumes 'filename' MAXPATHLEN+1 bytes long -
118	n/a	* may extend 'filename' by one character.
119	n/a	*/
120	n/a	static int
121	n/a	ismodule(char *filename)
122	n/a	{
123	n/a	if (exists(filename))
124	n/a	return 1;
125	n/a
126	n/a	/* Check for the compiled version of prefix. */
127	n/a	if (strlen(filename) < MAXPATHLEN) {
128	n/a	strcat(filename, Py_OptimizeFlag ? "o" : "c");
129	n/a	if (exists(filename))
130	n/a	return 1;
131	n/a	}
132	n/a	return 0;
133	n/a	}
134	n/a
135	n/a	/* Add a path component, by appending stuff to buffer.
136	n/a	buffer must have at least MAXPATHLEN + 1 bytes allocated, and contain a
137	n/a	NUL-terminated string with no more than MAXPATHLEN characters (not counting
138	n/a	the trailing NUL). It's a fatal error if it contains a string longer than
139	n/a	that (callers must be careful!). If these requirements are met, it's
140	n/a	guaranteed that buffer will still be a NUL-terminated string with no more
141	n/a	than MAXPATHLEN characters at exit. If stuff is too long, only as much of
142	n/a	stuff as fits will be appended.
143	n/a	*/
144	n/a
145	n/a	static void
146	n/a	join(char buffer, char stuff)
147	n/a	{
148	n/a	size_t n, k;
149	n/a	if (is_sep(stuff[0]))
150	n/a	n = 0;
151	n/a	else {
152	n/a	n = strlen(buffer);
153	n/a	if (n > 0 && !is_sep(buffer[n-1]) && n < MAXPATHLEN)
154	n/a	buffer[n++] = SEP;
155	n/a	}
156	n/a	if (n > MAXPATHLEN)
157	n/a	Py_FatalError("buffer overflow in getpathp.c's joinpath()");
158	n/a	k = strlen(stuff);
159	n/a	if (n + k > MAXPATHLEN)
160	n/a	k = MAXPATHLEN - n;
161	n/a	strncpy(buffer+n, stuff, k);
162	n/a	buffer[n+k] = '\0';
163	n/a	}
164	n/a
165	n/a	/* gotlandmark only called by search_for_prefix, which ensures
166	n/a	* 'prefix' is null terminated in bounds. join() ensures
167	n/a	* 'landmark' can not overflow prefix if too long.
168	n/a	*/
169	n/a	static int
170	n/a	gotlandmark(char *landmark)
171	n/a	{
172	n/a	int n, ok;
173	n/a
174	n/a	n = strlen(prefix);
175	n/a	join(prefix, landmark);
176	n/a	ok = ismodule(prefix);
177	n/a	prefix[n] = '\0';
178	n/a	return ok;
179	n/a	}
180	n/a
181	n/a	/* assumes argv0_path is MAXPATHLEN+1 bytes long, already \0 term'd.
182	n/a	* assumption provided by only caller, calculate_path()
183	n/a	*/
184	n/a	static int
185	n/a	search_for_prefix(char argv0_path, char landmark)
186	n/a	{
187	n/a	/* Search from argv0_path, until landmark is found */
188	n/a	strcpy(prefix, argv0_path);
189	n/a	do {
190	n/a	if (gotlandmark(landmark))
191	n/a	return 1;
192	n/a	reduce(prefix);
193	n/a	} while (prefix[0]);
194	n/a	return 0;
195	n/a	}
196	n/a
197	n/a
198	n/a	static void
199	n/a	get_progpath(void)
200	n/a	{
201	n/a	extern char *Py_GetProgramName(void);
202	n/a	char *path = getenv("PATH");
203	n/a	char *prog = Py_GetProgramName();
204	n/a
205	n/a	PPIB pib;
206	n/a	if ((DosGetInfoBlocks(NULL, &pib) == 0) &&
207	n/a	(DosQueryModuleName(pib->pib_hmte, sizeof(progpath), progpath) == 0))
208	n/a	return;
209	n/a
210	n/a	if (prog == NULL \|\| *prog == '\0')
211	n/a	prog = "python";
212	n/a
213	n/a	/* If there is no slash in the argv0 path, then we have to
214	n/a	* assume python is on the user's $PATH, since there's no
215	n/a	* other way to find a directory to start the search from. If
216	n/a	* $PATH isn't exported, you lose.
217	n/a	*/
218	n/a	#ifdef ALTSEP
219	n/a	if (strchr(prog, SEP) \|\| strchr(prog, ALTSEP))
220	n/a	#else
221	n/a	if (strchr(prog, SEP))
222	n/a	#endif
223	n/a	strncpy(progpath, prog, MAXPATHLEN);
224	n/a	else if (path) {
225	n/a	while (1) {
226	n/a	char *delim = strchr(path, DELIM);
227	n/a
228	n/a	if (delim) {
229	n/a	size_t len = delim - path;
230	n/a	/* ensure we can't overwrite buffer */
231	n/a	#if !defined(PYCC_GCC)
232	n/a	len = min(MAXPATHLEN,len);
233	n/a	#else
234	n/a	len = MAXPATHLEN < len ? MAXPATHLEN : len;
235	n/a	#endif
236	n/a	strncpy(progpath, path, len);
237	n/a	*(progpath + len) = '\0';
238	n/a	}
239	n/a	else
240	n/a	strncpy(progpath, path, MAXPATHLEN);
241	n/a
242	n/a	/* join() is safe for MAXPATHLEN+1 size buffer */
243	n/a	join(progpath, prog);
244	n/a	if (exists(progpath))
245	n/a	break;
246	n/a
247	n/a	if (!delim) {
248	n/a	progpath[0] = '\0';
249	n/a	break;
250	n/a	}
251	n/a	path = delim + 1;
252	n/a	}
253	n/a	}
254	n/a	else
255	n/a	progpath[0] = '\0';
256	n/a	}
257	n/a
258	n/a	static void
259	n/a	calculate_path(void)
260	n/a	{
261	n/a	char argv0_path[MAXPATHLEN+1];
262	n/a	char *buf;
263	n/a	size_t bufsz;
264	n/a	char *pythonhome = Py_GetPythonHome();
265	n/a	char *envpath = getenv("PYTHONPATH");
266	n/a	char zip_path[MAXPATHLEN+1];
267	n/a	size_t len;
268	n/a
269	n/a	get_progpath();
270	n/a	/* progpath guaranteed \0 terminated in MAXPATH+1 bytes. */
271	n/a	strcpy(argv0_path, progpath);
272	n/a	reduce(argv0_path);
273	n/a	if (pythonhome == NULL \|\| *pythonhome == '\0') {
274	n/a	if (search_for_prefix(argv0_path, LANDMARK))
275	n/a	pythonhome = prefix;
276	n/a	else
277	n/a	pythonhome = NULL;
278	n/a	}
279	n/a	else
280	n/a	strncpy(prefix, pythonhome, MAXPATHLEN);
281	n/a
282	n/a	if (envpath && *envpath == '\0')
283	n/a	envpath = NULL;
284	n/a
285	n/a	/* Calculate zip archive path */
286	n/a	strncpy(zip_path, progpath, MAXPATHLEN);
287	n/a	zip_path[MAXPATHLEN] = '\0';
288	n/a	len = strlen(zip_path);
289	n/a	if (len > 4) {
290	n/a	zip_path[len-3] = 'z'; /* change ending to "zip" */
291	n/a	zip_path[len-2] = 'i';
292	n/a	zip_path[len-1] = 'p';
293	n/a	}
294	n/a	else {
295	n/a	zip_path[0] = 0;
296	n/a	}
297	n/a
298	n/a	/* We need to construct a path from the following parts.
299	n/a	* (1) the PYTHONPATH environment variable, if set;
300	n/a	* (2) the zip archive file path;
301	n/a	* (3) the PYTHONPATH config macro, with the leading "."
302	n/a	* of each component replaced with pythonhome, if set;
303	n/a	* (4) the directory containing the executable (argv0_path).
304	n/a	* The length calculation calculates #3 first.
305	n/a	*/
306	n/a
307	n/a	/* Calculate size of return buffer */
308	n/a	if (pythonhome != NULL) {
309	n/a	char *p;
310	n/a	bufsz = 1;
311	n/a	for (p = PYTHONPATH; *p; p++) {
312	n/a	if (*p == DELIM)
313	n/a	bufsz++; /* number of DELIM plus one */
314	n/a	}
315	n/a	bufsz *= strlen(pythonhome);
316	n/a	}
317	n/a	else
318	n/a	bufsz = 0;
319	n/a	bufsz += strlen(PYTHONPATH) + 1;
320	n/a	bufsz += strlen(argv0_path) + 1;
321	n/a	bufsz += strlen(zip_path) + 1;
322	n/a	if (envpath != NULL)
323	n/a	bufsz += strlen(envpath) + 1;
324	n/a
325	n/a	module_search_path = buf = malloc(bufsz);
326	n/a	if (buf == NULL) {
327	n/a	/* We can't exit, so print a warning and limp along */
328	n/a	fprintf(stderr, "Can't malloc dynamic PYTHONPATH.\n");
329	n/a	if (envpath) {
330	n/a	fprintf(stderr, "Using environment $PYTHONPATH.\n");
331	n/a	module_search_path = envpath;
332	n/a	}
333	n/a	else {
334	n/a	fprintf(stderr, "Using default static path.\n");
335	n/a	module_search_path = PYTHONPATH;
336	n/a	}
337	n/a	return;
338	n/a	}
339	n/a
340	n/a	if (envpath) {
341	n/a	strcpy(buf, envpath);
342	n/a	buf = strchr(buf, '\0');
343	n/a	*buf++ = DELIM;
344	n/a	}
345	n/a	if (zip_path[0]) {
346	n/a	strcpy(buf, zip_path);
347	n/a	buf = strchr(buf, '\0');
348	n/a	*buf++ = DELIM;
349	n/a	}
350	n/a
351	n/a	if (pythonhome == NULL) {
352	n/a	strcpy(buf, PYTHONPATH);
353	n/a	buf = strchr(buf, '\0');
354	n/a	}
355	n/a	else {
356	n/a	char *p = PYTHONPATH;
357	n/a	char *q;
358	n/a	size_t n;
359	n/a	for (;;) {
360	n/a	q = strchr(p, DELIM);
361	n/a	if (q == NULL)
362	n/a	n = strlen(p);
363	n/a	else
364	n/a	n = q-p;
365	n/a	if (p[0] == '.' && is_sep(p[1])) {
366	n/a	strcpy(buf, pythonhome);
367	n/a	buf = strchr(buf, '\0');
368	n/a	p++;
369	n/a	n--;
370	n/a	}
371	n/a	strncpy(buf, p, n);
372	n/a	buf += n;
373	n/a	if (q == NULL)
374	n/a	break;
375	n/a	*buf++ = DELIM;
376	n/a	p = q+1;
377	n/a	}
378	n/a	}
379	n/a	if (argv0_path) {
380	n/a	*buf++ = DELIM;
381	n/a	strcpy(buf, argv0_path);
382	n/a	buf = strchr(buf, '\0');
383	n/a	}
384	n/a	*buf = '\0';
385	n/a	}
386	n/a
387	n/a
388	n/a	/* External interface */
389	n/a
390	n/a	char *
391	n/a	Py_GetPath(void)
392	n/a	{
393	n/a	if (!module_search_path)
394	n/a	calculate_path();
395	n/a	return module_search_path;
396	n/a	}
397	n/a
398	n/a	char *
399	n/a	Py_GetPrefix(void)
400	n/a	{
401	n/a	if (!module_search_path)
402	n/a	calculate_path();
403	n/a	return prefix;
404	n/a	}
405	n/a
406	n/a	char *
407	n/a	Py_GetExecPrefix(void)
408	n/a	{
409	n/a	return Py_GetPrefix();
410	n/a	}
411	n/a
412	n/a	char *
413	n/a	Py_GetProgramFullPath(void)
414	n/a	{
415	n/a	if (!module_search_path)
416	n/a	calculate_path();
417	n/a	return progpath;
418	n/a	}