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

#define IS_BASESTRING(o) \

PyObject_TypeCheck(o, &PyBaseString_Type)

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

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

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

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(char c)

{

if (c == '\0') {

Py_INCREF(Py_None);

return Py_None;

}

else

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

}

static PyObject *

Dialect_get_lineterminator(DialectObj *self)

{

return get_string(self->lineterminator);

}

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 PyInt_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 {

if (!PyInt_Check(src)) {

PyErr_Format(PyExc_TypeError,

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

return -1;

}

*target = PyInt_AsLong(src);

}

return 0;

}

static int

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

{

if (src == NULL)

*target = dflt;

else {

if (src == Py_None || PyString_Size(src) == 0)

*target = '\0';

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

PyErr_Format(PyExc_TypeError,

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

name);

return -1;

}

else {

char *s = PyString_AsString(src);

if (s == NULL)

return -1;

*target = s[0];

}

}

return 0;

}

static int

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

{

if (src == NULL)

*target = PyString_FromString(dflt);

else {

if (src == Py_None)

*target = NULL;

else if (!IS_BASESTRING(src)) {

PyErr_Format(PyExc_TypeError,

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

return -1;

}

else {

Py_XDECREF(*target);

Py_INCREF(src);

*target = src;

}

}

return 0;

}

static int

dialect_check_quoting(int quoting)

{

StyleDesc *qs = quote_styles;

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[] = {

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

{ "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[] = {

{ "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);

self->ob_type->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 && self->quoting != QUOTE_NONE)

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;

err:

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 = {

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

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;

}

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 int

parse_add_char(ReaderObj *self, char 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, 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 &&

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

parse_save_field(self);

}

else {

/* begin new unquoted field */

if (parse_add_char(self, c) < 0)

return -1;

self->state = IN_FIELD;

}

break;

case ESCAPED_CHAR:

if (parse_add_char(self, c) < 0)

return -1;

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

if (parse_add_char(self, c) < 0)

return -1;

}

break;

case IN_QUOTED_FIELD:

/* in quoted field */

if (c == '\n') {

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

if (parse_add_char(self, '\n') < 0)

return -1;

}

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

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

if (parse_add_char(self, c) < 0)

return -1;

self->state = IN_FIELD;

}

else {

/* illegal */

self->had_parse_error = 1;

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

dialect->delimiter,

dialect->quotechar);

return -1;

}

break;

}

return 0;

}

/*

* READER

*/

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

static struct PyMemberDef Reader_memberlist[] = {

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

{ NULL }

};

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");

}

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

Py_DECREF(lineobj);

return NULL;

}

}

if (parse_process_char(self, '\n') < 0) {

Py_DECREF(lineobj);

return NULL;

}

Py_DECREF(lineobj);

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

fields = self->fields;

self->fields = PyList_New(0);

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)

{

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

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->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_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;

}

self->fields = PyList_New(0);

if (self->fields == 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 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