/* csv module */

/*

This module provides the low-level underpinnings of a CSV reading/writing

module. Users should not use this module directly, but import the csv.py

module instead.

**** For people modifying this code, please note that as of this writing

**** (2003-03-23), it is intended that this code should work with Python

**** 2.2.

*/

#define MODULE_VERSION "1.0"

#include "Python.h"

#include "structmember.h"

/* begin 2.2 compatibility macros */

#ifndef PyDoc_STRVAR

/* Define macros for inline documentation. */

#define PyDoc_VAR(name) static char name[]

#define PyDoc_STRVAR(name,str) PyDoc_VAR(name) = PyDoc_STR(str)

#ifdef WITH_DOC_STRINGS

#define PyDoc_STR(str) str

#else

#define PyDoc_STR(str) ""

#endif

#endif /* ifndef PyDoc_STRVAR */

#ifndef PyMODINIT_FUNC

# if defined(__cplusplus)

# define PyMODINIT_FUNC extern "C" void

# else /* __cplusplus */

# define PyMODINIT_FUNC void

# endif /* __cplusplus */

#endif

/* end 2.2 compatibility macros */

static PyObject *error_obj; /* CSV exception */

static PyObject *dialects; /* Dialect registry */

typedef enum {

START_RECORD, START_FIELD, ESCAPED_CHAR, IN_FIELD,

IN_QUOTED_FIELD, ESCAPE_IN_QUOTED_FIELD, QUOTE_IN_QUOTED_FIELD

} ParserState;

typedef enum {

QUOTE_MINIMAL, QUOTE_ALL, QUOTE_NONNUMERIC, QUOTE_NONE

} QuoteStyle;

typedef struct {

QuoteStyle style;

char *name;

} StyleDesc;

static StyleDesc quote_styles[] = {

{ QUOTE_MINIMAL, "QUOTE_MINIMAL" },

{ QUOTE_ALL, "QUOTE_ALL" },

{ QUOTE_NONNUMERIC, "QUOTE_NONNUMERIC" },

{ QUOTE_NONE, "QUOTE_NONE" },

{ 0 }

};

typedef struct {

PyObject_HEAD

int doublequote; /* is " represented by ""? */

char delimiter; /* field separator */

char quotechar; /* quote character */

char escapechar; /* escape character */

int skipinitialspace; /* ignore spaces following delimiter? */

PyObject *lineterminator; /* string to write between records */

QuoteStyle quoting; /* style of quoting to write */

int strict; /* raise exception on bad CSV */

} DialectObj;

staticforward PyTypeObject Dialect_Type;

typedef struct {

PyObject_HEAD

PyObject *input_iter; /* iterate over this for input lines */

DialectObj *dialect; /* parsing dialect */

PyObject *fields; /* field list for current record */

ParserState state; /* current CSV parse state */

char *field; /* build current field in here */

int field_size; /* size of allocated buffer */

int field_len; /* length of current field */

int had_parse_error; /* did we have a parse error? */

} ReaderObj;

staticforward PyTypeObject Reader_Type;

#define ReaderObject_Check(v) ((v)->ob_type == &Reader_Type)

typedef struct {

PyObject_HEAD

PyObject *writeline; /* write output lines to this file */

DialectObj *dialect; /* parsing dialect */

char *rec; /* buffer for parser.join */

int rec_size; /* size of allocated record */

int rec_len; /* length of record */

int num_fields; /* number of fields in record */

} WriterObj;

staticforward PyTypeObject Writer_Type;

/*

* DIALECT class

*/

static PyObject *

get_dialect_from_registry(PyObject * name_obj)

{

PyObject *dialect_obj;

dialect_obj = PyDict_GetItem(dialects, name_obj);

if (dialect_obj == NULL)

return PyErr_Format(error_obj, "unknown dialect");

Py_INCREF(dialect_obj);

return dialect_obj;

}

static int

check_delattr(PyObject *v)

{

if (v == NULL) {

PyErr_SetString(PyExc_TypeError,

"Cannot delete attribute");

return -1;

}

return 0;

}

static PyObject *

get_string(PyObject *str)

{

Py_XINCREF(str);

return str;

}

static int

set_string(PyObject **str, PyObject *v)

{

if (check_delattr(v) < 0)

return -1;

if (!PyString_Check(v)

#ifdef Py_USING_UNICODE

&& !PyUnicode_Check(v)

#endif

) {

PyErr_BadArgument();

return -1;

}

Py_XDECREF(*str);

Py_INCREF(v);

*str = v;

return 0;

}

static PyObject *

get_nullchar_as_None(char c)

{

if (c == '\0') {

Py_INCREF(Py_None);

return Py_None;

}

else

return PyString_FromStringAndSize((char*)&c, 1);

}

static int

set_None_as_nullchar(char * addr, PyObject *v)

{

if (check_delattr(v) < 0)

return -1;

if (v == Py_None)

*addr = '\0';

else if (!PyString_Check(v) || PyString_Size(v) != 1) {

PyErr_BadArgument();

return -1;

}

else {

char *s = PyString_AsString(v);

if (s == NULL)

return -1;

*addr = s[0];

}

return 0;

}

static PyObject *

Dialect_get_lineterminator(DialectObj *self)

{

return get_string(self->lineterminator);

}

static int

Dialect_set_lineterminator(DialectObj *self, PyObject *value)

{

return set_string(&self->lineterminator, value);

}

static PyObject *

Dialect_get_escapechar(DialectObj *self)

{

return get_nullchar_as_None(self->escapechar);

}

static int

Dialect_set_escapechar(DialectObj *self, PyObject *value)

{

return set_None_as_nullchar(&self->escapechar, value);

}

static PyObject *

Dialect_get_quoting(DialectObj *self)

{

return PyInt_FromLong(self->quoting);

}

static int

Dialect_set_quoting(DialectObj *self, PyObject *v)

{

int quoting;

StyleDesc *qs = quote_styles;

if (check_delattr(v) < 0)

return -1;

if (!PyInt_Check(v)) {

PyErr_BadArgument();

return -1;

}

quoting = PyInt_AsLong(v);

for (qs = quote_styles; qs->name; qs++) {

if (qs->style == quoting) {

self->quoting = quoting;

return 0;

}

}

PyErr_BadArgument();

return -1;

}

static struct PyMethodDef Dialect_methods[] = {

{ NULL, NULL }

};

#define D_OFF(x) offsetof(DialectObj, x)

static struct PyMemberDef Dialect_memberlist[] = {

{ "quotechar", T_CHAR, D_OFF(quotechar) },

{ "delimiter", T_CHAR, D_OFF(delimiter) },

{ "skipinitialspace", T_INT, D_OFF(skipinitialspace) },

{ "doublequote", T_INT, D_OFF(doublequote) },

{ "strict", T_INT, D_OFF(strict) },

{ NULL }

};

static PyGetSetDef Dialect_getsetlist[] = {

{ "escapechar", (getter)Dialect_get_escapechar,

(setter)Dialect_set_escapechar },

{ "lineterminator", (getter)Dialect_get_lineterminator,

(setter)Dialect_set_lineterminator },

{ "quoting", (getter)Dialect_get_quoting,

(setter)Dialect_set_quoting },

{NULL},

};

static void

Dialect_dealloc(DialectObj *self)

{

Py_XDECREF(self->lineterminator);

self->ob_type->tp_free((PyObject *)self);

}

static int

dialect_init(DialectObj * self, PyObject * args, PyObject * kwargs)

{

PyObject *dialect = NULL, *name_obj, *value_obj;

self->quotechar = '"';

self->delimiter = ',';

self->escapechar = '\0';

self->skipinitialspace = 0;

Py_XDECREF(self->lineterminator);

self->lineterminator = PyString_FromString("\r\n");

if (self->lineterminator == NULL)

return -1;

self->quoting = QUOTE_MINIMAL;

self->doublequote = 1;

self->strict = 0;

if (!PyArg_ParseTuple(args, "|O", &dialect))

return -1;

Py_XINCREF(dialect);

if (kwargs != NULL) {

PyObject * key = PyString_FromString("dialect");

PyObject * d;

d = PyDict_GetItem(kwargs, key);

if (d) {

Py_INCREF(d);

Py_XDECREF(dialect);

PyDict_DelItem(kwargs, key);

dialect = d;

}

Py_DECREF(key);

}

if (dialect != NULL) {

int i;

PyObject * dir_list;

/* If dialect is a string, look it up in our registry */

if (PyString_Check(dialect)

#ifdef Py_USING_UNICODE

|| PyUnicode_Check(dialect)

#endif

) {

PyObject * new_dia;

new_dia = get_dialect_from_registry(dialect);

Py_DECREF(dialect);

if (new_dia == NULL)

return -1;

dialect = new_dia;

}

/* A class rather than an instance? Instantiate */

if (PyObject_TypeCheck(dialect, &PyClass_Type)) {

PyObject * new_dia;

new_dia = PyObject_CallFunction(dialect, "");

Py_DECREF(dialect);

if (new_dia == NULL)

return -1;

dialect = new_dia;

}

/* Make sure we finally have an instance */

if (!PyInstance_Check(dialect) ||

(dir_list = PyObject_Dir(dialect)) == NULL) {

PyErr_SetString(PyExc_TypeError,

"dialect must be an instance");

Py_DECREF(dialect);

return -1;

}

/* And extract the attributes */

for (i = 0; i < PyList_GET_SIZE(dir_list); ++i) {

char *s;

name_obj = PyList_GET_ITEM(dir_list, i);

s = PyString_AsString(name_obj);

if (s == NULL)

return -1;

if (s[0] == '_')

continue;

value_obj = PyObject_GetAttr(dialect, name_obj);

if (value_obj) {

if (PyObject_SetAttr((PyObject *)self,

name_obj, value_obj)) {

Py_DECREF(value_obj);

Py_DECREF(dir_list);

Py_DECREF(dialect);

return -1;

}

Py_DECREF(value_obj);

}

}

Py_DECREF(dir_list);

Py_DECREF(dialect);

}

if (kwargs != NULL) {

int pos = 0;

while (PyDict_Next(kwargs, &pos, &name_obj, &value_obj)) {

if (PyObject_SetAttr((PyObject *)self,

name_obj, value_obj))

return -1;

}

}

return 0;

}

static PyObject *

dialect_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)

{

DialectObj *self;

self = (DialectObj *)type->tp_alloc(type, 0);

if (self != NULL) {

self->lineterminator = NULL;

}

return (PyObject *)self;

}

PyDoc_STRVAR(Dialect_Type_doc,

"CSV dialect\n"

"\n"

"The Dialect type records CSV parsing and generation options.\n");

static PyTypeObject Dialect_Type = {

PyObject_HEAD_INIT(NULL)

0, /* ob_size */

"_csv.Dialect", /* tp_name */

sizeof(DialectObj), /* tp_basicsize */

0, /* tp_itemsize */

/* methods */

(destructor)Dialect_dealloc, /* tp_dealloc */

(printfunc)0, /* tp_print */

(getattrfunc)0, /* tp_getattr */

(setattrfunc)0, /* tp_setattr */

(cmpfunc)0, /* tp_compare */

(reprfunc)0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

(hashfunc)0, /* tp_hash */

(ternaryfunc)0, /* tp_call */

(reprfunc)0, /* tp_str */

0, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */

Dialect_Type_doc, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

Dialect_methods, /* tp_methods */

Dialect_memberlist, /* tp_members */

Dialect_getsetlist, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

(initproc)dialect_init, /* tp_init */

PyType_GenericAlloc, /* tp_alloc */

dialect_new, /* tp_new */

0, /* tp_free */

};

static void

parse_save_field(ReaderObj *self)

{

PyObject *field;

field = PyString_FromStringAndSize(self->field, self->field_len);

if (field != NULL) {

PyList_Append(self->fields, field);

Py_XDECREF(field);

}

self->field_len = 0;

}

static int

parse_grow_buff(ReaderObj *self)

{

if (self->field_size == 0) {

self->field_size = 4096;

if (self->field != NULL)

PyMem_Free(self->field);

self->field = PyMem_Malloc(self->field_size);

}

else {

self->field_size *= 2;

self->field = PyMem_Realloc(self->field, self->field_size);

}

if (self->field == NULL) {

PyErr_NoMemory();

return 0;

}

return 1;

}

static void

parse_add_char(ReaderObj *self, char c)

{

if (self->field_len == self->field_size && !parse_grow_buff(self))

return;

self->field[self->field_len++] = c;

}

static void

parse_process_char(ReaderObj *self, char c)

{

DialectObj *dialect = self->dialect;

switch (self->state) {

case START_RECORD:

/* start of record */

if (c == '\n')

/* empty line - return [] */

break;

/* normal character - handle as START_FIELD */

self->state = START_FIELD;

/* fallthru */

case START_FIELD:

/* expecting field */

if (c == '\n') {

/* save empty field - return [fields] */

parse_save_field(self);

self->state = START_RECORD;

}

else if (c == dialect->quotechar) {

/* start quoted field */

self->state = IN_QUOTED_FIELD;

}

else if (c == dialect->escapechar) {

/* possible escaped character */

self->state = ESCAPED_CHAR;

}

else if (c == ' ' && dialect->skipinitialspace)

/* ignore space at start of field */

;

else if (c == dialect->delimiter) {

/* save empty field */

parse_save_field(self);

}

else {

/* begin new unquoted field */

parse_add_char(self, c);

self->state = IN_FIELD;

}

break;

case ESCAPED_CHAR:

if (c != dialect->escapechar &&

c != dialect->delimiter &&

c != dialect->quotechar)

parse_add_char(self, dialect->escapechar);

parse_add_char(self, c);

self->state = IN_FIELD;

break;

case IN_FIELD:

/* in unquoted field */

if (c == '\n') {

/* end of line - return [fields] */

parse_save_field(self);

self->state = START_RECORD;

}

else if (c == dialect->escapechar) {

/* possible escaped character */

self->state = ESCAPED_CHAR;

}

else if (c == dialect->delimiter) {

/* save field - wait for new field */

parse_save_field(self);

self->state = START_FIELD;

}

else {

/* normal character - save in field */

parse_add_char(self, c);

}

break;

case IN_QUOTED_FIELD:

/* in quoted field */

if (c == '\n') {

/* end of line - save '\n' in field */

parse_add_char(self, '\n');

}

else if (c == dialect->escapechar) {

/* Possible escape character */

self->state = ESCAPE_IN_QUOTED_FIELD;

}

else if (c == dialect->quotechar) {

if (dialect->doublequote) {

/* doublequote; " represented by "" */

self->state = QUOTE_IN_QUOTED_FIELD;

}

else {

/* end of quote part of field */

self->state = IN_FIELD;

}

}

else {

/* normal character - save in field */

parse_add_char(self, c);

}

break;

case ESCAPE_IN_QUOTED_FIELD:

if (c != dialect->escapechar &&

c != dialect->delimiter &&

c != dialect->quotechar)

parse_add_char(self, dialect->escapechar);

parse_add_char(self, c);

self->state = IN_QUOTED_FIELD;

break;

case QUOTE_IN_QUOTED_FIELD:

/* doublequote - seen a quote in an quoted field */

if (dialect->quoting != QUOTE_NONE &&

c == dialect->quotechar) {

/* save "" as " */

parse_add_char(self, c);

self->state = IN_QUOTED_FIELD;

}

else if (c == dialect->delimiter) {

/* save field - wait for new field */

parse_save_field(self);

self->state = START_FIELD;

}

else if (c == '\n') {

/* end of line - return [fields] */

parse_save_field(self);

self->state = START_RECORD;

}

else if (!dialect->strict) {

parse_add_char(self, c);

self->state = IN_FIELD;

}

else {

/* illegal */

self->had_parse_error = 1;

PyErr_Format(error_obj, "%c expected after %c",

dialect->delimiter,

dialect->quotechar);

}

break;

}

}

/*

* READER

*/

#define R_OFF(x) offsetof(ReaderObj, x)

static struct PyMemberDef Reader_memberlist[] = {

{ "dialect", T_OBJECT, R_OFF(dialect), RO },

{ NULL }

};

static PyObject *

Reader_getiter(ReaderObj *self)

{

Py_INCREF(self);

return (PyObject *)self;

}

static PyObject *

Reader_iternext(ReaderObj *self)

{

PyObject *lineobj;

PyObject *fields;

char *line;

do {

lineobj = PyIter_Next(self->input_iter);

if (lineobj == NULL) {

/* End of input OR exception */

if (!PyErr_Occurred() && self->field_len != 0)

return PyErr_Format(error_obj,

"newline inside string");

return NULL;

}

if (self->had_parse_error) {

if (self->fields) {

Py_XDECREF(self->fields);

}

self->fields = PyList_New(0);

self->field_len = 0;

self->state = START_RECORD;

self->had_parse_error = 0;

}

line = PyString_AsString(lineobj);

if (line == NULL) {

Py_DECREF(lineobj);

return NULL;

}

if (strlen(line) < (size_t)PyString_GET_SIZE(lineobj)) {

self->had_parse_error = 1;

Py_DECREF(lineobj);

return PyErr_Format(error_obj,

"string with NUL bytes");

}

/* Process line of text - send '\n' to processing code to

represent end of line. End of line which is not at end of

string is an error. */

while (*line) {

char c;

c = *line++;

if (c == '\r') {

c = *line++;

if (c == '\0')

/* macintosh end of line */

break;

if (c == '\n') {

c = *line++;

if (c == '\0')

/* DOS end of line */

break;

}

self->had_parse_error = 1;

Py_DECREF(lineobj);

return PyErr_Format(error_obj,

"newline inside string");

}

if (c == '\n') {

c = *line++;

if (c == '\0')

/* unix end of line */

break;

self->had_parse_error = 1;

Py_DECREF(lineobj);

return PyErr_Format(error_obj,

"newline inside string");

}

parse_process_char(self, c);

if (PyErr_Occurred()) {

Py_DECREF(lineobj);

return NULL;

}

}

parse_process_char(self, '\n');

Py_DECREF(lineobj);

} while (self->state != START_RECORD);

fields = self->fields;

self->fields = PyList_New(0);

return fields;

}

static void

Reader_dealloc(ReaderObj *self)

{

Py_XDECREF(self->dialect);

Py_XDECREF(self->input_iter);

Py_XDECREF(self->fields);

if (self->field != NULL)

PyMem_Free(self->field);

PyObject_GC_Del(self);

}

static int

Reader_traverse(ReaderObj *self, visitproc visit, void *arg)

{

int err;

#define VISIT(SLOT) \

if (SLOT) { \

err = visit((PyObject *)(SLOT), arg); \

if (err) \

return err; \

}

VISIT(self->dialect);

VISIT(self->input_iter);

VISIT(self->fields);

return 0;

}

static int

Reader_clear(ReaderObj *self)

{

Py_XDECREF(self->dialect);

Py_XDECREF(self->input_iter);

Py_XDECREF(self->fields);

self->dialect = NULL;

self->input_iter = NULL;

self->fields = NULL;

return 0;

}

PyDoc_STRVAR(Reader_Type_doc,

"CSV reader\n"

"\n"

"Reader objects are responsible for reading and parsing tabular data\n"

"in CSV format.\n"

);

static struct PyMethodDef Reader_methods[] = {

{ NULL, NULL }

};

static PyTypeObject Reader_Type = {

PyObject_HEAD_INIT(NULL)

0, /*ob_size*/

"_csv.reader", /*tp_name*/

sizeof(ReaderObj), /*tp_basicsize*/

0, /*tp_itemsize*/

/* methods */

(destructor)Reader_dealloc, /*tp_dealloc*/

(printfunc)0, /*tp_print*/

(getattrfunc)0, /*tp_getattr*/

(setattrfunc)0, /*tp_setattr*/

(cmpfunc)0, /*tp_compare*/

(reprfunc)0, /*tp_repr*/

0, /*tp_as_number*/

0, /*tp_as_sequence*/

0, /*tp_as_mapping*/

(hashfunc)0, /*tp_hash*/

(ternaryfunc)0, /*tp_call*/

(reprfunc)0, /*tp_str*/

0, /*tp_getattro*/

0, /*tp_setattro*/

0, /*tp_as_buffer*/

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |

Py_TPFLAGS_HAVE_GC, /*tp_flags*/

Reader_Type_doc, /*tp_doc*/

(traverseproc)Reader_traverse, /*tp_traverse*/

(inquiry)Reader_clear, /*tp_clear*/

0, /*tp_richcompare*/

0, /*tp_weaklistoffset*/

(getiterfunc)Reader_getiter, /*tp_iter*/

(getiterfunc)Reader_iternext, /*tp_iternext*/

Reader_methods, /*tp_methods*/

Reader_memberlist, /*tp_members*/

0, /*tp_getset*/

};

static PyObject *

csv_reader(PyObject *module, PyObject *args, PyObject *keyword_args)

{

PyObject * iterator, * dialect = NULL, *ctor_args;

ReaderObj * self = PyObject_GC_New(ReaderObj, &Reader_Type);

if (!self)

return NULL;

self->dialect = NULL;

self->input_iter = self->fields = NULL;

self->fields = NULL;

self->input_iter = NULL;

self->had_parse_error = 0;

self->field = NULL;

self->field_size = 0;

self->field_len = 0;

self->state = START_RECORD;

if (!PyArg_ParseTuple(args, "O|O", &iterator, &dialect)) {

Py_DECREF(self);

return NULL;

}

self->input_iter = PyObject_GetIter(iterator);

if (self->input_iter == NULL) {

PyErr_SetString(PyExc_TypeError,

"argument 1 must be an iterator");

Py_DECREF(self);

return NULL;

}

ctor_args = Py_BuildValue(dialect ? "(O)" : "()", dialect);

if (ctor_args == NULL) {

Py_DECREF(self);

return NULL;

}

self->dialect = (DialectObj *)PyObject_Call((PyObject *)&Dialect_Type,

ctor_args, keyword_args);

Py_DECREF(ctor_args);

if (self->dialect == NULL) {

Py_DECREF(self);

return NULL;

}

self->fields = PyList_New(0);

if (self->fields == NULL) {

Py_DECREF(self);

return NULL;

}

return (PyObject *)self;

}

/*

* WRITER

*/

/* ---------------------------------------------------------------- */

static void

join_reset(WriterObj *self)

{

self->rec_len = 0;

self->num_fields = 0;

}

#define MEM_INCR 32768

/* Calculate new record length or append field to record. Return new

* record length.

*/

static int

join_append_data(WriterObj *self, char *field, int quote_empty,

int *quoted, int copy_phase)

{

DialectObj *dialect = self->dialect;

int i, rec_len;

rec_len = self->rec_len;

/* If this is not the first field we need a field separator.

*/

if (self->num_fields > 0) {

if (copy_phase)

self->rec[rec_len] = dialect->delimiter;

rec_len++;

}

/* Handle preceding quote.

*/

switch (dialect->quoting) {

case QUOTE_ALL:

*quoted = 1;

if (copy_phase)

self->rec[rec_len] = dialect->quotechar;

rec_len++;

break;

case QUOTE_MINIMAL:

case QUOTE_NONNUMERIC:

/* We only know about quoted in the copy phase.

*/

if (copy_phase && *quoted) {

self->rec[rec_len] = dialect->quotechar;

rec_len++;

}

break;

case QUOTE_NONE:

break;

}

/* Copy/count field data.

*/

for (i = 0;; i++) {

char c = field[i];

if (c == '\0')

break;

/* If in doublequote mode we escape quote chars with a

* quote.

*/

if (dialect->quoting != QUOTE_NONE &&

c == dialect->quotechar && dialect->doublequote) {

if (copy_phase)

self->rec[rec_len] = dialect->quotechar;

*quoted = 1;

rec_len++;

}

/* Some special characters need to be escaped. If we have a

* quote character switch to quoted field instead of escaping

* individual characters.

*/

if (!*quoted

&& (c == dialect->delimiter ||

c == dialect->escapechar ||

c == '\n' || c == '\r')) {

if (dialect->quoting != QUOTE_NONE)

*quoted = 1;

else if (dialect->escapechar) {

if (copy_phase)

self->rec[rec_len] = dialect->escapechar;

rec_len++;

}

else {

PyErr_Format(error_obj,

"delimiter must be quoted or escaped");

return -1;

}

}

/* Copy field character into record buffer.

*/

if (copy_phase)

self->rec[rec_len] = c;

rec_len++;

}

/* If field is empty check if it needs to be quoted.

*/

if (i == 0 && quote_empty) {

if (dialect->quoting == QUOTE_NONE) {

PyErr_Format(error_obj,

"single empty field record must be quoted");

return -1;

} else

*quoted = 1;

}

/* Handle final quote character on field.

*/

if (*quoted) {

if (copy_phase)

self->rec[rec_len] = dialect->quotechar;

else

/* Didn't know about leading quote until we found it

* necessary in field data - compensate for it now.

*/

rec_len++;

rec_len++;

}

return rec_len;