Programming Python (196 page)

/******************************************************************
* A C extension module for Python, called "cenviron".  Wraps the
* C library's getenv/putenv routines for use in Python programs.
******************************************************************/
#include 
#include 
#include 
/***********************/
/* 1) module functions */
/***********************/
static PyObject *                                   /* returns object */
wrap_getenv(PyObject *self, PyObject *args)         /* self not used */
{                                                   /* args from python */
char *varName, *varValue;
PyObject *returnObj = NULL;                         /* null=exception */
if (PyArg_Parse(args, "(s)", &varName)) {           /* Python -> C */
varValue = getenv(varName);                     /* call C getenv */
if (varValue != NULL)
returnObj = Py_BuildValue("s", varValue);   /* C -> Python */
else
PyErr_SetString(PyExc_SystemError, "Error calling getenv");
}
return returnObj;
}
static PyObject *
wrap_putenv(PyObject *self, PyObject *args)
{
char *varName, *varValue, *varAssign;
PyObject *returnObj = NULL;
if (PyArg_Parse(args, "(ss)", &varName, &varValue))
{
varAssign = malloc(strlen(varName) + strlen(varValue) + 2);
sprintf(varAssign, "%s=%s", varName, varValue);
if (putenv(varAssign) == 0) {
Py_INCREF(Py_None);                   /* C call success */
returnObj = Py_None;                  /* reference None */
}
else
PyErr_SetString(PyExc_SystemError, "Error calling putenv");
}
return returnObj;
}
/**************************/
/* 2) registration table  */
/**************************/
static PyMethodDef cenviron_methods[] = {
{"getenv",  wrap_getenv, METH_VARARGS, "getenv doc"},  /* name, &func,... */
{"putenv",  wrap_putenv, METH_VARARGS, "putenv doc"},  /* name, &func,... */
{NULL, NULL, 0, NULL}                                  /* end of table marker */
};
/*************************/
/* 3) module definition  */
/*************************/
static struct PyModuleDef cenvironmodule = {
PyModuleDef_HEAD_INIT,
"cenviron",        /* name of module */
"cenviron doc",    /* module documentation, may be NULL */
−1,                /* size of per-interpreter module state, −1=in global vars */
cenviron_methods   /* link to methods table */
};
/*************************/
/* 4) module initializer */
/*************************/
PyMODINIT_FUNC
PyInit_cenviron()                      /* called on first import */
{                                      /* name matters if loaded dynamically */
return PyModule_Create(&cenvironmodule);
}

##################################################################
# Compile cenviron.c into cenviron.dll--a shareable object file
# on Cygwin, which is loaded dynamically when first imported.
##################################################################
PYLIB = /usr/local/bin
PYINC = /usr/local/include/python3.1
cenviron.dll: cenviron.c
gcc cenviron.c -g -I$(PYINC) -shared  -L$(PYLIB) -lpython3.1 -o [email protected]
clean:
rm -f *.pyc cenviron.dll

Example 20-10. PP4E\Integrate\Extend\Cenviron\envmap.py

import os
from cenviron import getenv, putenv       # get C module's methods
class EnvMapping:                         # wrap in a Python class
def __setitem__(self, key, value):
os.environ[key] = value           # on writes: Env[key]=value
putenv(key, value)                # put in os.environ too
def __getitem__(self, key):
value = getenv(key)               # on reads: Env[key]
os.environ[key] = value           # integrity check
return value
Env = EnvMapping()                        # make one instance

Example 20-11. PP4E\Integrate\Extend\Cenviron\envattr.py

import os
from cenviron import getenv, putenv       # get C module's methods
class EnvWrapper:                         # wrap in a Python class
def __setattr__(self, name, value):
os.environ[name] = value          # on writes: Env.name=value
putenv(name, value)               # put in os.environ too
def __getattr__(self, name):
value = getenv(name)              # on reads: Env.name
os.environ[name] = value          # integrity check
return value
Env = EnvWrapper()                        # make one instance

Example 20-12. PP4E\Integrate\Extend\Swig\Environ\environ.i

/***************************************************************
* Swig module description file, to generate all Python wrapper
* code for C lib getenv/putenv calls: "swig -python environ.i".
***************************************************************/
%module environ
extern char * getenv(const char *varname);
extern int    putenv(char *assignment);

Example 20-13. PP4E\Integrate\Extend\Swig\Environ\makefile.environ-swig

# build environ extension from SWIG generated code
PYLIB = /usr/local/bin
PYINC = /usr/local/include/python3.1
SWIG  = /cygdrive/c/temp/swigwin-2.0.0/swig
_environ.dll: environ_wrap.c
gcc environ_wrap.c -g -I$(PYINC) -L$(PYLIB) -lpython3.1 -shared -o [email protected]
environ_wrap.c: environ.i
$(SWIG) -python environ.i
clean:
rm -f *.o *.dll *.pyc core environ_wrap.c environ.py

If you look closely, you may notice that I didn’t call
putenv
this time. It turns out there’s good
cause: the C library’s
putenv
wants
a string of the form “USER=Gilligan” to be passed, which becomes part
of the environment. In C code, this means we must create a new piece
of memory to pass in; we used
malloc
in
Example 20-8
to satisfy this
constraint. However, there’s no simple and direct way to guarantee
this on the Python side of the fence. In a prior Python release, it
was apparently sufficient to hold on to the string passed to
putenv
in a temporary Python variable, but
this no longer works with Python 3.X and/or SWIG 2.0. A fix may
require either a custom C function or SWIG’s typemaps which allow its
handling of data translations to be customized. In the interest of
space, we’ll leave addressing this as suggested exercise; see SWIG for
details.