libraries/pyshapelib/dbflibmodule.c

/* Copyright (c) 2001, 2002, 2007 by Intevation GmbH
 * Authors:
 * Bram de Greve <[email protected]>
 * Bernhard Herzog <[email protected]>
 *
 * This program is free software under the GPL (>=v2)
 * Read the file COPYING coming with Thuban for details.
 */

#include "pyshapelib_common.h"

/* UNICODE & LANGUAGE DRIVER SUPPORT FOR DBFLIB
 *
 * When writing Unicode objects to a dbflib database, the unicode has to be
 * encoded in 8-bit characters using a code page.  This code page is indentified
 * by the Language Driver ID (LDID) field in the database header.
 *
 * At this moment, this need unofficial modifications of the maptools shapelib
 * library because they do not read the LDID.  No patch has been submitted yet,
 * but the version contained in the Thuban source tree incorporates the required
 * modifications.
 *
 * pyshapelib is designed to compile with either the patched or unpatched shapelib
 * by defining HAVE_LANGUAGE_DRIVER as true or false respectively.  In the latter 
 * case, a Windows ANSI code page (cp1252) is assumed
 */
 #if HAVE_LANGUAGE_DRIVER

#define PYSHAPELIB_NUM_LANGUAGE_DRIVERS 256

#define PYSHAPELIB_ADD_LANGUAGE_DRIVER(ldid, codec, name)\
        codecs[ldid] = codec;\
        drivers[ldid] = "LDID_" name;\
        PyModule_AddIntConstant(module, "LDID_" name, ldid)

static char* codecs[PYSHAPELIB_NUM_LANGUAGE_DRIVERS];
static char* drivers[PYSHAPELIB_NUM_LANGUAGE_DRIVERS];

#endif


/** Determine name of Python's built-in codec
 */
static char* get_codec(DBFHandle handle)
{
#if HAVE_LANGUAGE_DRIVER
        if (!codecs[handle->nLanguageDriver])
        {
                PyErr_Format(PyExc_ValueError, "Language Driver ID %d not recognized", handle->nLanguageDriver);
        }
        return codecs[handle->nLanguageDriver];
#else
        return "cp1252";
#endif
}


/** decode to unicode object 
 */
static PyObject* decode_string(DBFHandle handle, const char* string)
{
        char* codec = get_codec(handle);
        if (!codec) return NULL;
        return PyUnicode_Decode(string, strlen(string), codec, NULL);
}

/** encode unicode object to normal Python string object 
 */
static PyObject* encode_string(DBFHandle handle, PyObject* string)
{
        char* codec = get_codec(handle);
        if (!codec) return NULL;

        if (PyString_Check(string))
        {
                return PyString_AsEncodedObject(string, codec, NULL);
        }
        if (PyUnicode_Check(string))
        {
                return PyUnicode_AsEncodedString(string, codec, NULL);
        }

        PyErr_SetString(PyExc_TypeError, "value is neither a string or unicode object");
        return NULL;
}


/* --- DBFFile ------------------------------------------------------------------------------------------------------- */

typedef struct {
        PyObject_HEAD
        DBFHandle handle;
} DBFFileObject;


/* allocator 
*/
static PyObject* dbffile_new(PyTypeObject* type, PyObject* args, PyObject* kwds)
{
        DBFFileObject* self;    
        self = (DBFFileObject*) type->tp_alloc(type, 0);
        self->handle = NULL;
        return (PyObject*) self;
}


/* deallocator
*/
static void dbffile_dealloc(DBFFileObject* self)
{
        DBFClose(self->handle);
        self->handle = NULL;
        self->ob_type->tp_free((PyObject*)self);
}


/* constructor
*/
static int dbffile_init(DBFFileObject* self, PyObject* args, PyObject* kwds)
{
        char* file = NULL;
        char* mode = "rb";
        static char *kwlist[] = {"name", "mode", NULL};

        DBFClose(self->handle);
        self->handle = NULL;

#if defined(SHPAPI_HAS_WIDE) && defined(Py_WIN_WIDE_FILENAMES)
        if (GetVersion() < 0x80000000) {    /* On NT, so wide API available */
                PyObject *wfile;
                if (PyArg_ParseTupleAndKeywords(args, kwds, "U|s:DBFFile", kwlist, &wfile, &mode)) 
                {
                        PyObject *wmode = PyUnicode_DecodeASCII(mode, strlen(mode), NULL);
                        if (!wmode) return -1;
                        self->handle = DBFOpenW(PyUnicode_AS_UNICODE(wfile), PyUnicode_AS_UNICODE(wmode));
                        Py_DECREF(wmode);
                        if (!self->handle)
                        {
                                PyErr_SetFromErrnoWithFilenameObject(PyExc_IOError, wfile);
                                return -1;
                        }
                } 
                else 
                {
                        /* Drop the argument parsing error as narrow
                           strings are also valid. */
                        PyErr_Clear();
                }
        }
#endif

        if (!self->handle)
        {
                if (!PyArg_ParseTupleAndKeywords(args, kwds, "et|s:DBFFile", kwlist, 
                        Py_FileSystemDefaultEncoding, &file, &mode)) return -1; 
                self->handle = DBFOpen(file, mode);

                if (!self->handle)
                {
                        PyErr_SetFromErrnoWithFilename(PyExc_IOError, file);
                        PyMem_Free(file);
                        return -1;
                }

                PyMem_Free(file);
        }

        return 0;
}


static PyObject* dbffile_close(DBFFileObject* self)
{
        DBFClose(self->handle);
        self->handle = NULL;
        Py_RETURN_NONE;
}


static PyObject* dbffile_field_count(DBFFileObject* self)
{
        return PyInt_FromLong((long)DBFGetFieldCount(self->handle));
}


static PyObject* dbffile_record_count(DBFFileObject* self)
{
        return PyInt_FromLong((long)DBFGetRecordCount(self->handle));
}


static PyObject* dbffile_field_info(DBFFileObject* self, PyObject* args)
{
        char field_name[12];
        int field, width = 0, decimals = 0, field_type;
        
        if (!PyArg_ParseTuple(args, "i:field_info", &field)) return NULL;
        
        field_name[0] = '\0';
        field_type = DBFGetFieldInfo(self->handle, field, field_name, &width, &decimals);
        
        return Py_BuildValue("isii", field_type, field_name, width, decimals);
}


static PyObject* dbffile_add_field(DBFFileObject* self, PyObject* args)
{
        char* name;
        int type, width, decimals;
        int field;
        
        if (!PyArg_ParseTuple(args, "siii:add_field", &name, &type, &width, &decimals)) return NULL;
        
        field = DBFAddField(self->handle, name, (DBFFieldType)type, width, decimals);
        
        if (field < 0)
        {
                PyErr_SetString(PyExc_ValueError, "Failed to add field due to inappropriate field definition");
                return NULL;
        }
        return PyInt_FromLong((long)field);
}


/* Read one attribute from the dbf handle and return it as a new python object
*
* If an error occurs, set the appropriate Python exception and return
* NULL.
*
* Assume that the values of the record and field arguments are valid.
* The name argument will be passed to DBFGetFieldInfo as is and should
* thus be either NULL or a pointer to an array of at least 12 chars
*/
static PyObject* do_read_attribute(DBFHandle handle, int record, int field, char * name)
{
        int type, width;
        const char* string;
        type = DBFGetFieldInfo(handle, field, name, &width, NULL);
        
        /* For strings NULL and the empty string are indistinguishable
        * in DBF files. We prefer empty strings instead for backwards
        * compatibility reasons because older wrapper versions returned
        * emtpy strings as empty strings.
        */
        if (type != FTString && DBFIsAttributeNULL(handle, record, field))
        {
                Py_RETURN_NONE;
        }
        else
        {
                switch (type)
                {
                case FTString:
                        string = DBFReadStringAttribute(handle, record, field);
                        if (string) return decode_string(handle, string);

                case FTInteger:
                        return PyInt_FromLong((long)DBFReadIntegerAttribute(handle, record, field));

                case FTDouble:
                        return PyFloat_FromDouble(DBFReadDoubleAttribute(handle, record, field));
                        
                case FTLogical:
                        string = DBFReadLogicalAttribute(handle, record, field);
                        if (string)
                        {
                                switch (string[0])
                                {
                                case 'F':
                                case 'N':
                                        Py_RETURN_FALSE;
                                case 'T':
                                case 'Y':
                                        Py_RETURN_TRUE;
                                }
                        }
                        break;

                default:
                        PyErr_Format(PyExc_TypeError, "Invalid field data type %d", type);
                        return NULL;
                }
        }
        
        PyErr_Format(PyExc_IOError,     "Can't read value for row %d column %d", record, field);
        return NULL;
}    


/* the read_attribute method. Return the value of the given record and
* field as a python object of the appropriate type.
*/
static PyObject* dbffile_read_attribute(DBFFileObject* self, PyObject* args)
{
        int record, field;

        if (!PyArg_ParseTuple(args, "ii:read_field", &record, &field)) return NULL;
        
        if (record < 0 || record >= DBFGetRecordCount(self->handle))
        {
                PyErr_Format(PyExc_ValueError,
                                "record index %d out of bounds (record count: %d)",
                                record, DBFGetRecordCount(self->handle));
                return NULL;
        }

        if (field < 0 || field >= DBFGetFieldCount(self->handle))
        {
                PyErr_Format(PyExc_ValueError,
                                "field index %d out of bounds (field count: %d)",
                                field, DBFGetFieldCount(self->handle));
                return NULL;
        }

        return do_read_attribute(self->handle, record, field, NULL);
}


/* the read_record method. Return the record record as a dictionary with
* whose keys are the names of the fields, and their values as the
* appropriate Python type.
*/
static PyObject* dbffile_read_record(DBFFileObject* self, PyObject* args)
{
        int record;
        int num_fields;
        int i;
        char name[12];
        PyObject *dict;
        PyObject *value = NULL;

        if (!PyArg_ParseTuple(args, "i:read_record", &record)) return NULL;

        if (record < 0 || record >= DBFGetRecordCount(self->handle))
        {
                PyErr_Format(PyExc_ValueError,
                        "record index %d out of bounds (record count: %d)",
                        record, DBFGetRecordCount(self->handle));
                return NULL;
        }

        dict = PyDict_New();
        if (!dict) return NULL;
        
        num_fields = DBFGetFieldCount(self->handle);
        for (i = 0; i < num_fields; i++)
        {
                value = do_read_attribute(self->handle, record, i, name);
                if (!value || PyDict_SetItemString(dict, name, value) < 0) goto fail;
                Py_DECREF(value);
                value = NULL;
        }

        return dict;

fail:
        Py_XDECREF(value);
        Py_DECREF(dict);
        return NULL;
}


/* write a single field of a record. */
static int do_write_field(DBFHandle handle, int record, int field, int type, PyObject* value)
{
        PyObject* encoded_string = NULL;
        char * string_value;
        int int_value;
        double double_value;
        int logical_value;

        if (value == Py_None)
        {
                if (DBFWriteNULLAttribute(handle, record, field)) return 1;
        }
        else
        {
                switch (type)
                {
                case FTString:
                        encoded_string = encode_string(handle, value);
                        if (!encoded_string) return 0;
                        string_value = PyString_AsString(encoded_string);
                        if (!string_value) 
                        {
                                Py_DECREF(encoded_string);
                                return 0;
                        }
                        if (DBFWriteStringAttribute(handle, record, field, string_value))
                        {
                                Py_DECREF(encoded_string);
                                return 1;
                        }
                        Py_DECREF(encoded_string);
                        break;

                case FTInteger:
                        int_value = PyInt_AsLong(value);
                        if (int_value == -1 && PyErr_Occurred()) return 0;
                        if (DBFWriteIntegerAttribute(handle, record, field, int_value)) return 1;
                        break;

                case FTDouble:
                        double_value = PyFloat_AsDouble(value);
                        if (double_value == -1 && PyErr_Occurred()) return 0;
                        if (DBFWriteDoubleAttribute(handle, record, field, double_value)) return 1;
                        break;
                        
                case FTLogical:
                        logical_value = PyObject_IsTrue(value);
                        if (logical_value == -1) return 0;
                        if (DBFWriteLogicalAttribute(handle, record, field, logical_value ? 'T' : 'F')) return 1;
                        break;

                default:
                        PyErr_Format(PyExc_TypeError, "Invalid field data type %d", type);
                        return 0;
                }
        }

        PyErr_Format(PyExc_IOError,     "can't write field %d of record %d", field, record);
        return 0;
}


static PyObject* dbffile_write_field(DBFFileObject* self, PyObject* args)
{
        int record, field;
        PyObject* value;
        int type;

        if (!PyArg_ParseTuple(args, "iiO:write_field", &record, &field, &value)) return NULL;
        
        if (field < 0 || field >= DBFGetFieldCount(self->handle))
        {
                PyErr_Format(PyExc_ValueError,
                                "field index %d out of bounds (field count: %d)",
                                field, DBFGetFieldCount(self->handle));
                return NULL;
        }

        type = DBFGetFieldInfo(self->handle, field, NULL, NULL, NULL);
        if (!do_write_field(self->handle, record, field, type, value)) return NULL;
        Py_RETURN_NONE;
}


static PyObject* dbffile_write_record(DBFFileObject* self, PyObject* args)
{
        int record;
        PyObject* record_object;
        int i, num_fields;
        
        int type;
        char name[12];
        PyObject* value = NULL;
        
        if (!PyArg_ParseTuple(args, "iO:write_record", &record, &record_object)) return NULL;
        
        num_fields = DBFGetFieldCount(self->handle);
        
        /* mimic ShapeFile functionality where id = -1 means appending */
        if (record == -1)
        {
                record = num_fields;
        }

        if (PySequence_Check(record_object))
        {
                /* It's a sequence object. Iterate through all items in the
                * sequence and write them to the appropriate field.
                */
                if (PySequence_Length(record_object) != num_fields)
                {
                        PyErr_SetString(PyExc_TypeError, "record must have one item for each field");
                        return NULL;
                }
                for (i = 0; i < num_fields; ++i)
                {
                        type = DBFGetFieldInfo(self->handle, i, NULL, NULL, NULL); 
                        value = PySequence_GetItem(record_object, i);
                        if (!value) return NULL;
                        if (!do_write_field(self->handle, record, i, type, value)) 
                        {
                                Py_DECREF(value);
                                return NULL;
                        }
                        Py_DECREF(value);
                }
        }
        else
        {
                /* It's a dictionary-like object. Iterate over the names of the
                * known fields and write the corresponding item
                */
                for (i = 0; i < num_fields; ++i)
                {
                        name[0] = '\0';
                        type = DBFGetFieldInfo(self->handle, i, name, NULL, NULL);
                        value = PyDict_GetItemString(record_object, name);
                        if (value && !do_write_field(self->handle, record, i, type, value)) return NULL;
                }
        }
        
        return PyInt_FromLong((long)record);
}


static PyObject* dbffile_repr(DBFFileObject* self)
{
        /* TODO: it would be nice to do something like "dbflib.DBFFile(filename, mode)" instead */
        return PyString_FromFormat("<dbflib.DBFFile object at %p>", self->handle);
}


/* The commit method implementation
*
* The method relies on the DBFUpdateHeader method which is not
* available in shapelib <= 1.2.10.  setup.py defines
* HAVE_UPDATE_HEADER's value depending on whether the function is
* available in the shapelib version the code is compiled with.
*/
#if HAVE_UPDATE_HEADER
static PyObject* dbffile_commit(DBFFileObject* self)
{
        DBFUpdateHeader(self->handle);
        Py_RETURN_NONE;
}
#endif


#if HAVE_LANGUAGE_DRIVER

static PyObject* dbffile_language_driver(DBFFileObject* self, void* closure)
{
        return PyInt_FromLong((long)self->handle->nLanguageDriver);
}

#endif


static struct PyMethodDef dbffile_methods[] = 
{
        {"close", (PyCFunction)dbffile_close, METH_NOARGS, 
                "close() -> None\n\n"
                "closes DBFFile"},
        {"field_count", (PyCFunction)dbffile_field_count, METH_NOARGS, 
                "field_count() -> integer\n\n"
                "returns number of fields currently defined"},
        {"record_count", (PyCFunction)dbffile_record_count, METH_NOARGS, 
                "record_count() -> integer\n\n"
                "returns number of records that currently exist"},
        {"field_info", (PyCFunction)dbffile_field_info, METH_VARARGS,
                "field_info(field_index) -> (type, name, width, decimals)\n\n"
                "returns info of a field as a tuple with:\n"
                "- type: the type of the field corresponding to the integer value of one "
                " of the constants FTString, FTInteger, ...\n"
                "- name: the name of the field as a string\n"
                "- width: the width of the field as a number of characters\n"
                "- decimals: the number of decimal digits" },
        {"add_field", (PyCFunction)dbffile_add_field, METH_VARARGS,
                "add_field(type, name, width, decimals) -> field_index\n\n"
                "adds a new field and returns field index if successful\n"
                "- type: the type of the field corresponding to the integer value of one "
                " of the constants FTString, FTInteger, ...\n"
                "- name: the name of the field as a string\n"
                "- width: the width of the field as a number of characters\n"
                "- decimals: the number of decimal digits" },
        {"read_attribute", (PyCFunction)dbffile_read_attribute, METH_VARARGS, 
                "read_attribute(record_index, field_index) -> value\n\n"
                "returns the value of one field of a record"},
        {"read_record", (PyCFunction)dbffile_read_record, METH_VARARGS, 
                "read_record(record_index) -> dict\n\n"
                "returns an entire record as a dictionary of field names and values"},
        {"write_field", (PyCFunction)dbffile_write_field, METH_VARARGS, 
                "write_field(record_index, field_index, new_value)\n"
                "writes a single field of a record"},
        {"write_record", (PyCFunction)dbffile_write_record, METH_VARARGS, 
                "write_record(record_index, record) -> record_index\n\n"
                "Writes an entire record as a dict or a sequence, and return index of record\n"
                "Record can either be a dictionary in which case the keys are used as field names, "
                "or a sequence that must have an item for every field (length = field_count())"},
#if HAVE_UPDATE_HEADER
        {"commit", (PyCFunction)dbffile_commit, METH_NOARGS, 
                "commit() -> None"},
#endif
        {NULL}
};


static struct PyGetSetDef dbffile_getsetters[] = 
{
#if HAVE_LANGUAGE_DRIVER
        {"language_driver", (getter)dbffile_language_driver, NULL, "Language Driver ID (read-only)" },
#endif
        {NULL}
};


static PyTypeObject DBFFileType = PYSHAPELIB_DEFINE_TYPE(DBFFileObject, dbffile, "shapelib.DBFFile", 0);


/* --- dbflib -------------------------------------------------------------------------------------------------------- */

static PyObject* dbflib_open(PyObject* module, PyObject* args)
{
        return PyObject_CallObject((PyObject*)&DBFFileType, args);
}


static PyObject* dbflib_create(PyObject* module, PyObject* args)
{
        char* file;
        DBFFileObject* result;
        DBFHandle handle = NULL;
        int wideargument = 0;

#if defined(SHPAPI_HAS_WIDE) && defined(Py_WIN_WIDE_FILENAMES)
        if (GetVersion() < 0x80000000) {    /* On NT, so wide API available */
                PyObject *wfile;
                if (PyArg_ParseTuple(args, "U:create", &wfile)) 
                {
                        wideargument = 1;
                        handle = DBFCreateW(PyUnicode_AS_UNICODE(wfile));
                        if (!handle)
                        {
                                PyErr_SetFromErrnoWithFilenameObject(PyExc_IOError, wfile);
                                return NULL;
                        }
                } 
                else 
                {
                        /* Drop the argument parsing error as narrow
                           strings are also valid. */
                        PyErr_Clear();
                }
        }
#endif
        
        if (!handle)
        {
                if (!PyArg_ParseTuple(args, "et:create", Py_FileSystemDefaultEncoding, &file)) return NULL;
                handle = DBFCreate(file);
                if (!handle)
                {
                                PyErr_SetFromErrnoWithFilename(PyExc_IOError, file);
                                PyMem_Free(file);
                                return NULL;
                }
                PyMem_Free(file);
        }

        result = PyObject_New(DBFFileObject, &DBFFileType);
        if (!result)
        {
                DBFClose(handle);
                return PyErr_NoMemory();
        }
        
        result->handle = handle;
        return (PyObject*) result;
}


#if HAVE_LANGUAGE_DRIVER

/** translate a numeric Language Driver ID to the name of Python's codec.
 */
static PyObject* dbflib_language_driver_codec(PyObject* module, PyObject* args)
{
        int ldid;
        if (!PyArg_ParseTuple(args, "i:language_driver_name", &ldid)) return NULL;
        if (ldid < 0 || ldid >= PYSHAPELIB_NUM_LANGUAGE_DRIVERS || !codecs[ldid])
        {
                PyErr_SetString(PyExc_ValueError, "invalid driver id");
                return NULL;
        }
        return PyString_FromString(codecs[ldid]);
}

/** translate a numeric Language Driver ID to a string represting its constant.
 */
static PyObject* dbflib_language_driver_name(PyObject* module, PyObject* args)
{
        int ldid;
        if (!PyArg_ParseTuple(args, "i:language_driver_name", &ldid)) return NULL;
        if (ldid < 0 || ldid >= PYSHAPELIB_NUM_LANGUAGE_DRIVERS || !drivers[ldid])
        {
                PyErr_SetString(PyExc_ValueError, "invalid driver id");
                return NULL;
        }
        return PyString_FromString(drivers[ldid]);
}

#endif


static struct PyMethodDef dbflib_methods[] = 
{
        {"open", (PyCFunction)dbflib_open, METH_VARARGS, 
                "open(name [, mode]) -> DBFFile\n\n"
                "opens a DBFFile" },
        {"create", (PyCFunction)dbflib_create, METH_VARARGS, 
                "create(name [, language_driver]) -> DBFFile\n\n"
                "create a DBFFile " },
#if HAVE_LANGUAGE_DRIVER
        {"language_driver_codec", (PyCFunction)dbflib_language_driver_codec, METH_VARARGS, 
                "language_driver_codec(driver_id) -> string\n\n"
                "translate language driver id into the name of the Python's codec used as code page." },
        {"language_driver_name", (PyCFunction)dbflib_language_driver_name, METH_VARARGS, 
                "language_driver_name(driver_id) -> string\n\n"
                "translate language driver id into a string." },
#endif
        {NULL}
};


PyMODINIT_FUNC initdbflib(void)
{
        int i;

        PyObject* module = Py_InitModule("dbflib", dbflib_methods);
        if (!module) return;
        
        PYSHAPELIB_ADD_TYPE(DBFFileType, "DBFFile");
        
        PYSHAPELIB_ADD_CONSTANT(FTString);
        PYSHAPELIB_ADD_CONSTANT(FTInteger);
        PYSHAPELIB_ADD_CONSTANT(FTDouble);
        PYSHAPELIB_ADD_CONSTANT(FTLogical);
        PYSHAPELIB_ADD_CONSTANT(FTInvalid);
        PyModule_AddIntConstant(module, "_have_commit", HAVE_UPDATE_HEADER);

#if HAVE_LANGUAGE_DRIVER
        /* table compiled from these resources:
         * http://www.clicketyclick.dk/databases/xbase/format/dbf.html
         * http://www.esrinl.com/content/file.asp?id=307
         * http://msdn2.microsoft.com/en-us/library/aa975345(VS.71).aspx
         */
        for (i = 0; i < PYSHAPELIB_NUM_LANGUAGE_DRIVERS; ++i)
        {
                codecs[i] = NULL;
                drivers[i] = NULL;
        }
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x00, "cp1252", "NOT_SET");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x01, "cp437", "DOS_USA");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x02, "cp850", "DOS_INTERNATIONAL");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x03, "cp1252", "WINDOWS_ANSI");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x04, "mac_roman", "STANDARD_MACINTOSH");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x08, "cp865", "DANISH_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x09, "cp437", "DUTCH_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x0a, "cp850", "DUTCH_OEM_2");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x0b, "cp437", "FINNISH_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x0d, "cp437", "FRENCH_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x0e, "cp850", "FRENCH_OEM_2");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x0f, "cp437", "GERMAN_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x10, "cp850", "GERMAN_OEM_2");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x11, "cp437", "ITALIAN_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x12, "cp850", "ITALIAN_OEM_2");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x13, "cp932", "JAPANESE_SHIFT_JIS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x14, "cp850", "SPANISH_OEM_2");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x15, "cp437", "SWEDISH_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x16, "cp850", "SWEDISH_OEM_2");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x17, "cp865", "NORWEGIAN_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x18, "cp437", "SPANISH_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x19, "cp437", "ENGLISH_BRITAIN_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x1a, "cp850", "ENGLISH_BRITAIN_OEM_2");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x0b, "cp437", "ENGLISH_US_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x1c, "cp863", "FRENCH_CANADA_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x1d, "cp850", "FRENCH_OEM_2");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x1f, "cp852", "CZECH_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x22, "cp852", "HUNGARIAN_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x23, "cp852", "POLISH_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x24, "cp860", "PORTUGUESE_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x25, "cp850", "PORTUGUESE_OEM_2");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x26, "cp866", "RUSSIAN_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x37, "cp850", "ENGLISH_US_OEM_2");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x40, "cp852", "ROMANIAN_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x4d, "cp936", "CHINESE_GBK_PRC");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x4e, "cp949", "KOREAN_ANSI_OEM);");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x4f, "cp950", "CHINESE_BIG5_TAIWAN");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x50, "cp874", "THAI_ANSI_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x57, "cp1252", "ESRI_ANSI");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x58, "cp1252", "WESTERN_EUROPEAN_ANSI");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x59, "cp1252", "SPANISH_ANSI");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x64, "cp852", "EASTERN_EUROPEAN_MSDOS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x65, "cp866", "RUSSIAN_MSDOS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x66, "cp865", "NORDIC_MSDOS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x67, "cp861", "ICELANDIC_MSDOS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x68, "cp895", "CZECH_MSDOS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x69, "cp620", "POLISH_MSDOS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x6a, "cp737", "GREEK_MSDOS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x6b, "cp857", "TURKISH_MSDOS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x6c, "cp863", "FRENCH_CANADA_MSDOS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x78, "cp950", "TAIWAN_BIG5");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x79, "cp949", "HANGUL_WANSUG");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x7a, "cp936", "PRC_GBK");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x7b, "cp932", "JAPANESE_SHIFT_JIS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x7c, "cp874", "THAI_WINDOWS_MSDOS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x7d, "cp1255", "HEBREW_WINDOWS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x7e, "cp1256", "ARABIC_WINDOWS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x86, "cp737", "GREEK_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x87, "cp852", "SLOVENIAN_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x88, "cp857", "TURKISH_OEM");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x96, "mac_cyrillic", "RUSSIAN_MACINTOSH");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x97, "mac_latin2", "EASTERN_EUROPEAN_MACINTOSH");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0x98, "mac_greek", "GREEK_MACINTOSH");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0xc8, "cp1250", "EASTERN_EUROPEAN_WINDOWS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0xc9, "cp1251", "RUSSIAN_WINDOWS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0xca, "cp1254", "TURKISH_WINDOWS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0xcb, "cp1253", "GREEK_WINDOWS");
        PYSHAPELIB_ADD_LANGUAGE_DRIVER(0xcc, "cp1257", "BALTIC_WINDOWS");
#endif

}
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision