/* 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.

*/

#define MODULE_VERSION "1.0"

#include "Python.h"

#include "structmember.h"

#define IS_BASESTRING(o) \

PyUnicode_Check(o)

static PyObject *error_obj; /* CSV exception */

static PyObject *dialects; /* Dialect registry */

static long field_limit = 128 * 1024; /* max parsed field size */

typedef enum {

START_RECORD, START_FIELD, ESCAPED_CHAR, IN_FIELD,

IN_QUOTED_FIELD, ESCAPE_IN_QUOTED_FIELD, QUOTE_IN_QUOTED_FIELD,

EAT_CRNL

} 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 ""? */

Py_UNICODE delimiter; /* field separator */

Py_UNICODE quotechar; /* quote character */

Py_UNICODE escapechar; /* escape character */

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

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

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

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

} DialectObj;

static 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 */

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

Py_ssize_t field_size; /* size of allocated buffer */

Py_ssize_t field_len; /* length of current field */

int numeric_field; /* treat field as numeric */

unsigned long line_num; /* Source-file line number */

} ReaderObj;

static PyTypeObject Reader_Type;

#define ReaderObject_Check(v) (Py_TYPE(v) == &Reader_Type)

typedef struct {

PyObject_HEAD

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

DialectObj *dialect; /* parsing dialect */

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

Py_ssize_t rec_size; /* size of allocated record */

Py_ssize_t rec_len; /* length of record */

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

} WriterObj;

static 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) {

if (!PyErr_Occurred())

PyErr_Format(error_obj, "unknown dialect");

}

else

Py_INCREF(dialect_obj);

return dialect_obj;

}

static PyObject *

get_string(PyObject *str)

{

Py_XINCREF(str);

return str;

}

static PyObject *

get_nullchar_as_None(Py_UNICODE c)

{

if (c == '\0') {

Py_INCREF(Py_None);

return Py_None;

}

else

return PyUnicode_FromOrdinal(c);

}

static PyObject *

Dialect_get_lineterminator(DialectObj *self)

{

return get_string(self->lineterminator);

}

static PyObject *

Dialect_get_delimiter(DialectObj *self)

{

return get_nullchar_as_None(self->delimiter);

}

static PyObject *

Dialect_get_escapechar(DialectObj *self)

{

return get_nullchar_as_None(self->escapechar);

}

static PyObject *

Dialect_get_quotechar(DialectObj *self)

{

return get_nullchar_as_None(self->quotechar);

}

static PyObject *

Dialect_get_quoting(DialectObj *self)

{

return PyLong_FromLong(self->quoting);

}

static int

_set_bool(const char *name, int *target, PyObject *src, int dflt)

{

if (src == NULL)

*target = dflt;

else

*target = PyObject_IsTrue(src);

return 0;

}

static int

_set_int(const char *name, int *target, PyObject *src, int dflt)

{

if (src == NULL)

*target = dflt;

else {

long value;

if (!PyLong_CheckExact(src)) {

PyErr_Format(PyExc_TypeError,

"\"%s\" must be an integer", name);

return -1;

}

value = PyLong_AsLong(src);

if (value == -1 && PyErr_Occurred())

return -1;

#if SIZEOF_LONG > SIZEOF_INT

if (value > INT_MAX || value < INT_MIN) {

PyErr_Format(PyExc_ValueError,

"integer out of range for \"%s\"", name);

return -1;

}

#endif

*target = (int)value;

}

return 0;

}

static int

_set_char(const char *name, Py_UNICODE *target, PyObject *src, Py_UNICODE dflt)

{

if (src == NULL)

*target = dflt;

else {

*target = '\0';

if (src != Py_None) {

Py_UNICODE *buf;

Py_ssize_t len;

buf = PyUnicode_AsUnicode(src);

len = PyUnicode_GetSize(src);

if (buf == NULL || len > 1) {

PyErr_Format(PyExc_TypeError,

"\"%s\" must be an 1-character string",

name);

return -1;

}

if (len > 0)

*target = buf[0];

}

}

return 0;

}

static int

_set_str(const char *name, PyObject **target, PyObject *src, const char *dflt)

{

if (src == NULL)

*target = PyUnicode_DecodeASCII(dflt, strlen(dflt), NULL);

else {

if (src == Py_None)

*target = NULL;

else if (!IS_BASESTRING(src)) {

PyErr_Format(PyExc_TypeError,

"\"%s\" must be a string", name);

return -1;

}

else {

Py_XDECREF(*target);

Py_INCREF(src);

*target = src;

}

}

return 0;

}

static int

dialect_check_quoting(int quoting)

{

StyleDesc *qs;

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

if (qs->style == quoting)

return 0;

}

PyErr_Format(PyExc_TypeError, "bad \"quoting\" value");

return -1;

}

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

static struct PyMemberDef Dialect_memberlist[] = {

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

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

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

{ NULL }

};

static PyGetSetDef Dialect_getsetlist[] = {

{ "delimiter", (getter)Dialect_get_delimiter},

{ "escapechar", (getter)Dialect_get_escapechar},

{ "lineterminator", (getter)Dialect_get_lineterminator},

{ "quotechar", (getter)Dialect_get_quotechar},

{ "quoting", (getter)Dialect_get_quoting},

{NULL},

};

static void

Dialect_dealloc(DialectObj *self)

{

Py_XDECREF(self->lineterminator);

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

}

static char *dialect_kws[] = {

"dialect",

"delimiter",

"doublequote",

"escapechar",

"lineterminator",

"quotechar",

"quoting",

"skipinitialspace",

"strict",

NULL

};

static PyObject *

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

{

DialectObj *self;

PyObject *ret = NULL;

PyObject *dialect = NULL;

PyObject *delimiter = NULL;

PyObject *doublequote = NULL;

PyObject *escapechar = NULL;

PyObject *lineterminator = NULL;

PyObject *quotechar = NULL;

PyObject *quoting = NULL;

PyObject *skipinitialspace = NULL;

PyObject *strict = NULL;

if (!PyArg_ParseTupleAndKeywords(args, kwargs,

"|OOOOOOOOO", dialect_kws,

&dialect,

&delimiter,

&doublequote,

&escapechar,

&lineterminator,

&quotechar,

&quoting,

&skipinitialspace,

&strict))

return NULL;

if (dialect != NULL) {

if (IS_BASESTRING(dialect)) {

dialect = get_dialect_from_registry(dialect);

if (dialect == NULL)

return NULL;

}

else

Py_INCREF(dialect);

/* Can we reuse this instance? */

if (PyObject_TypeCheck(dialect, &Dialect_Type) &&

delimiter == 0 &&

doublequote == 0 &&

escapechar == 0 &&

lineterminator == 0 &&

quotechar == 0 &&

quoting == 0 &&

skipinitialspace == 0 &&

strict == 0)

return dialect;

}

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

if (self == NULL) {

Py_XDECREF(dialect);

return NULL;

}

self->lineterminator = NULL;

Py_XINCREF(delimiter);

Py_XINCREF(doublequote);

Py_XINCREF(escapechar);

Py_XINCREF(lineterminator);

Py_XINCREF(quotechar);

Py_XINCREF(quoting);

Py_XINCREF(skipinitialspace);

Py_XINCREF(strict);

if (dialect != NULL) {

#define DIALECT_GETATTR(v, n) \

if (v == NULL) \

v = PyObject_GetAttrString(dialect, n)

DIALECT_GETATTR(delimiter, "delimiter");

DIALECT_GETATTR(doublequote, "doublequote");

DIALECT_GETATTR(escapechar, "escapechar");

DIALECT_GETATTR(lineterminator, "lineterminator");

DIALECT_GETATTR(quotechar, "quotechar");

DIALECT_GETATTR(quoting, "quoting");

DIALECT_GETATTR(skipinitialspace, "skipinitialspace");

DIALECT_GETATTR(strict, "strict");

PyErr_Clear();

}

/* check types and convert to C values */

#define DIASET(meth, name, target, src, dflt) \

if (meth(name, target, src, dflt)) \

goto err

DIASET(_set_char, "delimiter", &self->delimiter, delimiter, ',');

DIASET(_set_bool, "doublequote", &self->doublequote, doublequote, 1);

DIASET(_set_char, "escapechar", &self->escapechar, escapechar, 0);

DIASET(_set_str, "lineterminator", &self->lineterminator, lineterminator, "\r\n");

DIASET(_set_char, "quotechar", &self->quotechar, quotechar, '"');

DIASET(_set_int, "quoting", &self->quoting, quoting, QUOTE_MINIMAL);

DIASET(_set_bool, "skipinitialspace", &self->skipinitialspace, skipinitialspace, 0);

DIASET(_set_bool, "strict", &self->strict, strict, 0);

/* validate options */

if (dialect_check_quoting(self->quoting))

goto err;

if (self->delimiter == 0) {

PyErr_SetString(PyExc_TypeError, "delimiter must be set");

goto err;

}

if (quotechar == Py_None && quoting == NULL)

self->quoting = QUOTE_NONE;

if (self->quoting != QUOTE_NONE && self->quotechar == 0) {

PyErr_SetString(PyExc_TypeError,

"quotechar must be set if quoting enabled");

goto err;

}

if (self->lineterminator == 0) {

PyErr_SetString(PyExc_TypeError, "lineterminator must be set");

goto err;

}

ret = (PyObject *)self;

Py_INCREF(self);

err:

Py_XDECREF(self);

Py_XDECREF(dialect);

Py_XDECREF(delimiter);

Py_XDECREF(doublequote);

Py_XDECREF(escapechar);

Py_XDECREF(lineterminator);

Py_XDECREF(quotechar);

Py_XDECREF(quoting);

Py_XDECREF(skipinitialspace);

Py_XDECREF(strict);

return ret;

}

PyDoc_STRVAR(Dialect_Type_doc,

"CSV dialect\n"

"\n"

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

static PyTypeObject Dialect_Type = {

PyVarObject_HEAD_INIT(NULL, 0)

"_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 */

0, /* tp_reserved */

(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 */

0, /* 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 */

0, /* tp_init */

0, /* tp_alloc */

dialect_new, /* tp_new */

0, /* tp_free */

};

/*

* Return an instance of the dialect type, given a Python instance or kwarg

* description of the dialect

*/

static PyObject *

_call_dialect(PyObject *dialect_inst, PyObject *kwargs)

{

PyObject *ctor_args;

PyObject *dialect;

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

if (ctor_args == NULL)

return NULL;

dialect = PyObject_Call((PyObject *)&Dialect_Type, ctor_args, kwargs);

Py_DECREF(ctor_args);

return dialect;

}

/*

* READER

*/

static int

parse_save_field(ReaderObj *self)

{

PyObject *field;

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

if (field == NULL)

return -1;

self->field_len = 0;

if (self->numeric_field) {

PyObject *tmp;

self->numeric_field = 0;

tmp = PyNumber_Float(field);

if (tmp == NULL) {

Py_DECREF(field);

return -1;

}

Py_DECREF(field);

field = tmp;

}

PyList_Append(self->fields, field);

Py_DECREF(field);

return 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_New(Py_UNICODE, self->field_size);

}

else {

Py_UNICODE *field = self->field;

if (self->field_size > PY_SSIZE_T_MAX / 2) {

PyErr_NoMemory();

return 0;

}

self->field_size *= 2;

self->field = PyMem_Resize(field, Py_UNICODE, self->field_size);

}

if (self->field == NULL) {

PyErr_NoMemory();

return 0;

}

return 1;

}

static int

parse_add_char(ReaderObj *self, Py_UNICODE c)

{

if (self->field_len >= field_limit) {

PyErr_Format(error_obj, "field larger than field limit (%ld)",

field_limit);

return -1;

}

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

return -1;

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

return 0;

}

static int

parse_process_char(ReaderObj *self, Py_UNICODE c)

{

DialectObj *dialect = self->dialect;

switch (self->state) {

case START_RECORD:

/* start of record */

if (c == '\0')

/* empty line - return [] */

break;

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

self->state = EAT_CRNL;

break;

}

/* normal character - handle as START_FIELD */

self->state = START_FIELD;

/* fallthru */

case START_FIELD:

/* expecting field */

if (c == '\n' || c == '\r' || c == '\0') {

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

if (parse_save_field(self) < 0)

return -1;

self->state = (c == '\0' ? START_RECORD : EAT_CRNL);

}

else if (c == dialect->quotechar &&

dialect->quoting != QUOTE_NONE) {

/* 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 */

if (parse_save_field(self) < 0)

return -1;

}

else {

/* begin new unquoted field */

if (dialect->quoting == QUOTE_NONNUMERIC)

self->numeric_field = 1;

if (parse_add_char(self, c) < 0)

return -1;

self->state = IN_FIELD;

}

break;

case ESCAPED_CHAR:

if (c == '\0')

c = '\n';

if (parse_add_char(self, c) < 0)

return -1;

self->state = IN_FIELD;

break;

case IN_FIELD:

/* in unquoted field */

if (c == '\n' || c == '\r' || c == '\0') {

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

if (parse_save_field(self) < 0)

return -1;

self->state = (c == '\0' ? START_RECORD : EAT_CRNL);

}

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

/* possible escaped character */

self->state = ESCAPED_CHAR;

}

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

/* save field - wait for new field */

if (parse_save_field(self) < 0)

return -1;

self->state = START_FIELD;

}

else {

/* normal character - save in field */

if (parse_add_char(self, c) < 0)

return -1;

}

break;

case IN_QUOTED_FIELD:

/* in quoted field */

if (c == '\0')

;

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

/* Possible escape character */

self->state = ESCAPE_IN_QUOTED_FIELD;

}

else if (c == dialect->quotechar &&

dialect->quoting != QUOTE_NONE) {

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 */

if (parse_add_char(self, c) < 0)

return -1;

}

break;

case ESCAPE_IN_QUOTED_FIELD:

if (c == '\0')

c = '\n';

if (parse_add_char(self, c) < 0)

return -1;

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 " */

if (parse_add_char(self, c) < 0)

return -1;

self->state = IN_QUOTED_FIELD;

}

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

/* save field - wait for new field */

if (parse_save_field(self) < 0)

return -1;

self->state = START_FIELD;

}

else if (c == '\n' || c == '\r' || c == '\0') {

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

if (parse_save_field(self) < 0)

return -1;

self->state = (c == '\0' ? START_RECORD : EAT_CRNL);

}

else if (!dialect->strict) {

if (parse_add_char(self, c) < 0)

return -1;

self->state = IN_FIELD;

}

else {

/* illegal */

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

dialect->delimiter,

dialect->quotechar);

return -1;

}

break;

case EAT_CRNL:

if (c == '\n' || c == '\r')

;

else if (c == '\0')

self->state = START_RECORD;

else {

PyErr_Format(error_obj, "new-line character seen in unquoted field - do you need to open the file in universal-newline mode?");

return -1;

}

break;

}

return 0;

}

static int

parse_reset(ReaderObj *self)

{

Py_XDECREF(self->fields);

self->fields = PyList_New(0);

if (self->fields == NULL)

return -1;

self->field_len = 0;

self->state = START_RECORD;

self->numeric_field = 0;

return 0;

}

static PyObject *

Reader_iternext(ReaderObj *self)

{

PyObject *lineobj;

PyObject *fields = NULL;

Py_UNICODE *line, c;

Py_ssize_t linelen;

if (parse_reset(self) < 0)

return NULL;

do {

lineobj = PyIter_Next(self->input_iter);

if (lineobj == NULL) {

/* End of input OR exception */

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

PyErr_Format(error_obj,

"newline inside string");

return NULL;

}

if (!PyUnicode_Check(lineobj)) {

PyErr_Format(error_obj,

"iterator should return strings, "

"not %.200s "

"(did you open the file in text mode?)",

lineobj->ob_type->tp_name

);

Py_DECREF(lineobj);

return NULL;

}

++self->line_num;

line = PyUnicode_AsUnicode(lineobj);

linelen = PyUnicode_GetSize(lineobj);

if (line == NULL || linelen < 0) {

Py_DECREF(lineobj);

return NULL;

}

while (linelen--) {

c = *line++;

if (c == '\0') {

Py_DECREF(lineobj);

PyErr_Format(error_obj,

"line contains NULL byte");

goto err;

}

if (parse_process_char(self, c) < 0) {

Py_DECREF(lineobj);

goto err;

}

}

Py_DECREF(lineobj);

if (parse_process_char(self, 0) < 0)

goto err;

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

fields = self->fields;

self->fields = NULL;

err:

return fields;

}

static void

Reader_dealloc(ReaderObj *self)

{

PyObject_GC_UnTrack(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)

{

Py_VISIT(self->dialect);

Py_VISIT(self->input_iter);

Py_VISIT(self->fields);

return 0;

}

static int

Reader_clear(ReaderObj *self)

{

Py_CLEAR(self->dialect);

Py_CLEAR(self->input_iter);

Py_CLEAR(self->fields);

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 }

};

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

static struct PyMemberDef Reader_memberlist[] = {

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

{ "line_num", T_ULONG, R_OFF(line_num), READONLY },

{ NULL }

};

static PyTypeObject Reader_Type = {

PyVarObject_HEAD_INIT(NULL, 0)

"_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*/

0, /*tp_reserved*/

(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*/

PyObject_SelfIter, /*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;

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

if (!self)

return NULL;

self->dialect = NULL;

self->fields = NULL;

self->input_iter = NULL;

self->field = NULL;

self->field_size = 0;

self->line_num = 0;

if (parse_reset(self) < 0) {

Py_DECREF(self);

return NULL;

}

if (!PyArg_UnpackTuple(args, "", 1, 2, &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;

}

self->dialect = (DialectObj *)_call_dialect(dialect, keyword_args);

if (self->dialect == NULL) {

Py_DECREF(self);

return NULL;

}

PyObject_GC_Track(self);

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 Py_ssize_t

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

int *quoted, int copy_phase)

{

DialectObj *dialect = self->dialect;

int i;

Py_ssize_t rec_len;

Py_UNICODE *lineterm;

#define ADDCH(c) \

do {\

if (copy_phase) \

self->rec[rec_len] = c;\

rec_len++;\

} while(0)

lineterm = PyUnicode_AsUnicode(dialect->lineterminator);

if (lineterm == NULL)

return -1;

rec_len = self->rec_len;

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

if (self->num_fields > 0)

ADDCH(dialect->delimiter);

/* Handle preceding quote */

if (copy_phase && *quoted)

ADDCH(dialect->quotechar);

/* Copy/count field data */

/* If field is null just pass over */

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

Py_UNICODE c = field[i];

int want_escape = 0;

if (c == '\0')

break;

if (c == dialect->delimiter ||

c == dialect->escapechar ||

c == dialect->quotechar ||

Py_UNICODE_strchr(lineterm, c)) {

if (dialect->quoting == QUOTE_NONE)

want_escape = 1;

else {

if (c == dialect->quotechar) {

if (dialect->doublequote)

ADDCH(dialect->quotechar);

else

want_escape = 1;

}

if (!want_escape)

*quoted = 1;