Index: Doc/lib/libimp.tex
===================================================================
RCS file: /cvsroot/python/python/dist/src/Doc/lib/libimp.tex,v
retrieving revision 1.32
diff -c -r1.32 libimp.tex
*** Doc/lib/libimp.tex	9 Apr 2002 18:14:59 -0000	1.32
--- Doc/lib/libimp.tex	23 Nov 2002 23:20:00 -0000
***************
*** 106,111 ****
--- 106,126 ----
  triggered by that).
  \end{funcdesc}
  
+ \begin{funcdesc}{set_frozenmodules}{seq_of_tuples}
+ Set the global list of frozen modules.  \var{seq_of_tuples} is a sequence
+ of tuples of length 3: (\var{modulename}, \var{codedata}, \var{ispkg})
+ \var{modulename} is the name of the frozen module (may contain dots).
+ \var{codedata} is a marshalled code object. \var{ispkg} is a boolean
+ indicating whether the module is a package.
+ \versionadded{2.3}
+ \end{funcdesc}
+ 
+ \begin{funcdesc}{get_frozenmodules}{}
+ Return the global list of frozen modules as a tuple of tuples. See
+ \function{set_frozenmodules()} for a description of its contents.
+ \versionadded{2.3}
+ \end{funcdesc}
+ 
  The following constants with integer values, defined in this module,
  are used to indicate the search result of \function{find_module()}.
  
Index: Python/import.c
===================================================================
RCS file: /cvsroot/python/python/dist/src/Python/import.c,v
retrieving revision 2.210
diff -c -r2.210 import.c
*** Python/import.c	31 Aug 2002 15:16:14 -0000	2.210
--- Python/import.c	23 Nov 2002 23:20:02 -0000
***************
*** 2295,2300 ****
--- 2295,2420 ----
  	return m;
  }
  
+ /* Keep a reference to the tuple used to build the real frozen
+    modules array, as the latter points to string data inside
+    the tuple. */
+ static PyObject *frozenmodulestuple = NULL;
+ 
+ static PyObject *
+ imp_set_frozenmodules(PyObject *self, PyObject *args)
+ {
+ 	PyObject *t, *item, *name, *code, *ispkg;
+ 	struct _frozen *frozenmodules;
+ 	int n, i;
+ 
+ 	if (!PyArg_ParseTuple(args, "O:set_frozenmodules", &t))
+ 		return NULL;
+ 
+ 	/* turn the argument into a tuple so we're sure our list
+ 	   isn't being tampered with behind our backs */
+ 	t = PySequence_Tuple(t);
+ 	if (t == NULL)
+ 		return NULL;
+ 
+ 	n = PyTuple_Size(t);
+ 	frozenmodules = PyMem_Malloc((n + 1)* sizeof(struct _frozen));
+ 	if (frozenmodules == NULL) {
+ 		PyErr_SetString(PyExc_MemoryError,
+ 				"no memory to allocate frozen array");
+ 		goto error;
+ 	}
+ 	for (i = 0; i < n; i++) {
+ 		item = PyTuple_GetItem(t, i);
+ 		if (item == NULL)
+ 			goto error;
+ 		if (!PyTuple_Check(item) || PyTuple_Size(item) != 3)
+ 			goto typeerror;
+ 		name = PyTuple_GetItem(item, 0);
+ 		code = PyTuple_GetItem(item, 1);
+ 		ispkg = PyTuple_GetItem(item, 2);
+ 		if (!PyString_Check(name) || !PyString_Check(code))
+ 			goto typeerror;
+ 		frozenmodules[i].name = PyString_AsString(name);
+ 		frozenmodules[i].code = PyString_AsString(code);
+ 		frozenmodules[i].size = PyString_Size(code);
+ 		if (PyObject_IsTrue(ispkg))
+ 			frozenmodules[i].size = -frozenmodules[i].size;
+ 	}
+ 	frozenmodules[n].name = NULL; /* sentinel */
+ 	frozenmodules[n].code = NULL;
+ 	frozenmodules[n].size = 0;
+ 
+ 	if (frozenmodulestuple != NULL) {
+ 		Py_DECREF(frozenmodulestuple);
+ 		PyMem_Free(PyImport_FrozenModules);
+ 	} /* else we don't know how or if PyImport_FrozenModules were
+ 	     allocated, so we can't do anything. */
+ 
+ 	frozenmodulestuple = t;
+ 	PyImport_FrozenModules = frozenmodules;
+ 
+ 	Py_INCREF(Py_None);
+ 	return Py_None;
+ 
+ typeerror:
+ 	PyErr_SetString(PyExc_TypeError,
+ 			"items must be tuples of length 3, "
+ 			"containing two strings and a bool");
+ error:
+ 	Py_DECREF(t);
+ 	PyMem_Free(frozenmodules);
+ 	return NULL;
+ }
+ 
+ static PyObject *
+ imp_get_frozenmodules(PyObject *self, PyObject *args)
+ {
+ 	PyObject *t, *item, *ob;
+ 	int i;
+ 	struct _frozen *p;
+ 	if (!PyArg_ParseTuple(args, ":get_frozenmodules"))
+ 		return NULL;
+ 
+ 	/* We could just return frozenmodulestuple if it isn't
+ 	   NULL, but it's possible a C extension stepped on
+ 	   PyImport_FrozenModules after us, so we always build
+ 	   a new tuple. */
+ 
+ 	for (p = PyImport_FrozenModules, i = 0; ; p++, i++) {
+ 		if (p->name == NULL)
+ 			break;
+ 	}
+ 	t = PyTuple_New(i);
+ 	if (t == NULL)
+ 		return NULL;
+ 	for (p = PyImport_FrozenModules, i = 0; ; p++, i++) {
+ 		if (p->name == NULL)
+ 			break;
+ 		item = PyTuple_New(3);
+ 		if (item == NULL)
+ 			goto error;
+ 		ob = PyString_FromString(p->name);
+ 		if (ob == NULL)
+ 			goto error;
+ 		Py_INCREF(ob);
+ 		PyTuple_SET_ITEM(item, 0, ob);
+ 		ob = PyString_FromStringAndSize(p->code, p->size >= 0 ?
+ 					       p->size : -(p->size));
+ 		if (ob == NULL)
+ 			goto error;
+ 		Py_INCREF(ob);
+ 		PyTuple_SET_ITEM(item, 1, ob);
+ 		ob = p->size >= 0 ? Py_False : Py_True;
+ 		Py_INCREF(ob);
+ 		PyTuple_SET_ITEM(item, 2, ob);
+ 		PyTuple_SET_ITEM(t, i, item);
+ 	}
+ 	return t;
+ error:
+ 	Py_DECREF(t);
+ 	return NULL;
+ }
+ 
  static PyObject *
  imp_get_frozen_object(PyObject *self, PyObject *args)
  {
***************
*** 2521,2526 ****
--- 2641,2660 ----
  Return 1 if the import lock is currently held.\n\
  On platforms without threads, return 0.");
  
+ PyDoc_STRVAR(doc_set_frozenmodules,
+ "set_frozenmodules(seq_of_tuples) -> None\n\
+ Set the global list of frozen modules.\n\
+ The single argument is a sequence of tuples of length 3:\n\
+   (modulename, codedata, ispkg)\n\
+ 'modulename' is the name of the frozen module (may contain dots).\n\
+ 'codedata' is a marshalled code object. 'ispkg' is a boolean\n\
+ indicating whether the module is a package.");
+ 
+ PyDoc_STRVAR(doc_get_frozenmodules,
+ "get_frozenmodules() -> tuple_of_tuples\n\
+ Return the global list of frozen modules as a tuple of tuples. See\n\
+ the set_frozenmodules() doc string for a description of its contents.");
+ 
  static PyMethodDef imp_methods[] = {
  	{"find_module",		imp_find_module, METH_VARARGS, doc_find_module},
  	{"get_magic",		imp_get_magic,	 METH_VARARGS, doc_get_magic},
***************
*** 2528,2533 ****
--- 2662,2671 ----
  	{"load_module",		imp_load_module, METH_VARARGS, doc_load_module},
  	{"new_module",		imp_new_module,	 METH_VARARGS, doc_new_module},
  	{"lock_held",		imp_lock_held,	 METH_VARARGS, doc_lock_held},
+ 	{"set_frozenmodules",	imp_set_frozenmodules,	METH_VARARGS,
+ 							doc_set_frozenmodules},
+ 	{"get_frozenmodules",	imp_get_frozenmodules,	METH_VARARGS,
+ 							doc_get_frozenmodules},
  	/* The rest are obsolete */
  	{"get_frozen_object",	imp_get_frozen_object,	METH_VARARGS},
  	{"init_builtin",	imp_init_builtin,	METH_VARARGS},