PageRenderTime 820ms CodeModel.GetById 191ms app.highlight 423ms RepoModel.GetById 191ms app.codeStats 1ms

/Modules/_csv.c

http://unladen-swallow.googlecode.com/
C | 1611 lines | 1387 code | 162 blank | 62 comment | 236 complexity | 3cad9ad31ee7bd5bbd4736df6a872877 MD5 | raw file
   1/* csv module */
   2
   3/*
   4
   5This module provides the low-level underpinnings of a CSV reading/writing
   6module.  Users should not use this module directly, but import the csv.py
   7module instead.
   8
   9**** For people modifying this code, please note that as of this writing
  10**** (2003-03-23), it is intended that this code should work with Python
  11**** 2.2.
  12
  13*/
  14
  15#define MODULE_VERSION "1.0"
  16
  17#include "Python.h"
  18#include "structmember.h"
  19
  20
  21/* begin 2.2 compatibility macros */
  22#ifndef PyDoc_STRVAR
  23/* Define macros for inline documentation. */
  24#define PyDoc_VAR(name) static char name[]
  25#define PyDoc_STRVAR(name,str) PyDoc_VAR(name) = PyDoc_STR(str)
  26#ifdef WITH_DOC_STRINGS
  27#define PyDoc_STR(str) str
  28#else
  29#define PyDoc_STR(str) ""
  30#endif
  31#endif /* ifndef PyDoc_STRVAR */
  32
  33#ifndef PyMODINIT_FUNC
  34#	if defined(__cplusplus)
  35#		define PyMODINIT_FUNC extern "C" void
  36#	else /* __cplusplus */
  37#		define PyMODINIT_FUNC void
  38#	endif /* __cplusplus */
  39#endif
  40
  41#ifndef Py_CLEAR
  42#define Py_CLEAR(op)						\
  43	do {							\
  44		if (op) {					\
  45			PyObject *tmp = (PyObject *)(op);	\
  46			(op) = NULL;				\
  47			Py_DECREF(tmp);				\
  48		}						\
  49	} while (0)
  50#endif
  51#ifndef Py_VISIT
  52#define Py_VISIT(op)							\
  53        do { 								\
  54                if (op) {						\
  55                        int vret = visit((PyObject *)(op), arg);	\
  56                        if (vret)					\
  57                                return vret;				\
  58                }							\
  59        } while (0)
  60#endif
  61
  62/* end 2.2 compatibility macros */
  63
  64#define IS_BASESTRING(o) \
  65	PyObject_TypeCheck(o, &PyBaseString_Type)
  66
  67static PyObject *error_obj;	/* CSV exception */
  68static PyObject *dialects;      /* Dialect registry */
  69static long field_limit = 128 * 1024;	/* max parsed field size */
  70
  71typedef enum {
  72	START_RECORD, START_FIELD, ESCAPED_CHAR, IN_FIELD, 
  73	IN_QUOTED_FIELD, ESCAPE_IN_QUOTED_FIELD, QUOTE_IN_QUOTED_FIELD,
  74	EAT_CRNL
  75} ParserState;
  76
  77typedef enum {
  78	QUOTE_MINIMAL, QUOTE_ALL, QUOTE_NONNUMERIC, QUOTE_NONE
  79} QuoteStyle;
  80
  81typedef struct {
  82	QuoteStyle style;
  83	char *name;
  84} StyleDesc;
  85
  86static StyleDesc quote_styles[] = {
  87	{ QUOTE_MINIMAL,    "QUOTE_MINIMAL" },
  88	{ QUOTE_ALL,        "QUOTE_ALL" },
  89	{ QUOTE_NONNUMERIC, "QUOTE_NONNUMERIC" },
  90	{ QUOTE_NONE,       "QUOTE_NONE" },
  91	{ 0 }
  92};
  93
  94typedef struct {
  95        PyObject_HEAD
  96        
  97	int doublequote;	/* is " represented by ""? */
  98	char delimiter;		/* field separator */
  99	char quotechar;		/* quote character */
 100	char escapechar;	/* escape character */
 101	int skipinitialspace;	/* ignore spaces following delimiter? */
 102	PyObject *lineterminator; /* string to write between records */
 103	int quoting;		/* style of quoting to write */
 104
 105	int strict;		/* raise exception on bad CSV */
 106} DialectObj;
 107
 108staticforward PyTypeObject Dialect_Type;
 109
 110typedef struct {
 111        PyObject_HEAD
 112
 113        PyObject *input_iter;   /* iterate over this for input lines */
 114
 115        DialectObj *dialect;    /* parsing dialect */
 116
 117	PyObject *fields;	/* field list for current record */
 118	ParserState state;	/* current CSV parse state */
 119	char *field;		/* build current field in here */
 120	int field_size;		/* size of allocated buffer */
 121	int field_len;		/* length of current field */
 122	int numeric_field;	/* treat field as numeric */
 123	unsigned long line_num;	/* Source-file line number */
 124} ReaderObj;
 125
 126staticforward PyTypeObject Reader_Type;
 127
 128#define ReaderObject_Check(v)   (Py_TYPE(v) == &Reader_Type)
 129
 130typedef struct {
 131        PyObject_HEAD
 132
 133        PyObject *writeline;    /* write output lines to this file */
 134
 135        DialectObj *dialect;    /* parsing dialect */
 136
 137	char *rec;		/* buffer for parser.join */
 138	int rec_size;		/* size of allocated record */
 139	int rec_len;		/* length of record */
 140	int num_fields;		/* number of fields in record */
 141} WriterObj;        
 142
 143staticforward PyTypeObject Writer_Type;
 144
 145/*
 146 * DIALECT class
 147 */
 148
 149static PyObject *
 150get_dialect_from_registry(PyObject * name_obj)
 151{
 152        PyObject *dialect_obj;
 153
 154        dialect_obj = PyDict_GetItem(dialects, name_obj);
 155	if (dialect_obj == NULL) {
 156		if (!PyErr_Occurred())
 157			PyErr_Format(error_obj, "unknown dialect");
 158	}
 159	else
 160		Py_INCREF(dialect_obj);
 161        return dialect_obj;
 162}
 163
 164static PyObject *
 165get_string(PyObject *str)
 166{
 167        Py_XINCREF(str);
 168        return str;
 169}
 170
 171static PyObject *
 172get_nullchar_as_None(char c)
 173{
 174        if (c == '\0') {
 175                Py_INCREF(Py_None);
 176                return Py_None;
 177        }
 178        else
 179                return PyString_FromStringAndSize((char*)&c, 1);
 180}
 181
 182static PyObject *
 183Dialect_get_lineterminator(DialectObj *self)
 184{
 185        return get_string(self->lineterminator);
 186}
 187
 188static PyObject *
 189Dialect_get_escapechar(DialectObj *self)
 190{
 191        return get_nullchar_as_None(self->escapechar);
 192}
 193
 194static PyObject *
 195Dialect_get_quotechar(DialectObj *self)
 196{
 197        return get_nullchar_as_None(self->quotechar);
 198}
 199
 200static PyObject *
 201Dialect_get_quoting(DialectObj *self)
 202{
 203        return PyInt_FromLong(self->quoting);
 204}
 205
 206static int
 207_set_bool(const char *name, int *target, PyObject *src, int dflt)
 208{
 209	if (src == NULL)
 210		*target = dflt;
 211	else
 212		*target = PyObject_IsTrue(src);
 213	return 0;
 214}
 215
 216static int
 217_set_int(const char *name, int *target, PyObject *src, int dflt)
 218{
 219	if (src == NULL)
 220		*target = dflt;
 221	else {
 222		if (!PyInt_Check(src)) {
 223			PyErr_Format(PyExc_TypeError, 
 224				     "\"%s\" must be an integer", name);
 225			return -1;
 226		}
 227		*target = PyInt_AsLong(src);
 228	}
 229	return 0;
 230}
 231
 232static int
 233_set_char(const char *name, char *target, PyObject *src, char dflt)
 234{
 235	if (src == NULL)
 236		*target = dflt;
 237	else {
 238		if (src == Py_None || PyString_Size(src) == 0)
 239			*target = '\0';
 240		else if (!PyString_Check(src) || PyString_Size(src) != 1) {
 241			PyErr_Format(PyExc_TypeError, 
 242				     "\"%s\" must be an 1-character string", 
 243				     name);
 244			return -1;
 245		}
 246		else {
 247			char *s = PyString_AsString(src);
 248			if (s == NULL)
 249				return -1;
 250			*target = s[0];
 251		}
 252	}
 253        return 0;
 254}
 255
 256static int
 257_set_str(const char *name, PyObject **target, PyObject *src, const char *dflt)
 258{
 259	if (src == NULL)
 260		*target = PyString_FromString(dflt);
 261	else {
 262		if (src == Py_None)
 263			*target = NULL;
 264		else if (!IS_BASESTRING(src)) {
 265			PyErr_Format(PyExc_TypeError, 
 266				     "\"%s\" must be an string", name);
 267			return -1;
 268		}
 269		else {
 270			Py_XDECREF(*target);
 271			Py_INCREF(src);
 272			*target = src;
 273		}
 274	}
 275        return 0;
 276}
 277
 278static int
 279dialect_check_quoting(int quoting)
 280{
 281        StyleDesc *qs = quote_styles;
 282
 283	for (qs = quote_styles; qs->name; qs++) {
 284		if (qs->style == quoting)
 285                        return 0;
 286        }
 287	PyErr_Format(PyExc_TypeError, "bad \"quoting\" value");
 288        return -1;
 289}
 290
 291#define D_OFF(x) offsetof(DialectObj, x)
 292
 293static struct PyMemberDef Dialect_memberlist[] = {
 294	{ "delimiter",          T_CHAR, D_OFF(delimiter), READONLY },
 295	{ "skipinitialspace",   T_INT, D_OFF(skipinitialspace), READONLY },
 296	{ "doublequote",        T_INT, D_OFF(doublequote), READONLY },
 297	{ "strict",             T_INT, D_OFF(strict), READONLY },
 298	{ NULL }
 299};
 300
 301static PyGetSetDef Dialect_getsetlist[] = {
 302	{ "escapechar",		(getter)Dialect_get_escapechar},
 303	{ "lineterminator",	(getter)Dialect_get_lineterminator},
 304	{ "quotechar",		(getter)Dialect_get_quotechar},
 305	{ "quoting",		(getter)Dialect_get_quoting},
 306	{NULL},
 307};
 308
 309static void
 310Dialect_dealloc(DialectObj *self)
 311{
 312        Py_XDECREF(self->lineterminator);
 313        Py_TYPE(self)->tp_free((PyObject *)self);
 314}
 315
 316static char *dialect_kws[] = {
 317	"dialect",
 318	"delimiter",
 319	"doublequote",
 320	"escapechar",
 321	"lineterminator",
 322	"quotechar",
 323	"quoting",
 324	"skipinitialspace",
 325	"strict",
 326	NULL
 327};
 328
 329static PyObject *
 330dialect_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 331{
 332	DialectObj *self;
 333	PyObject *ret = NULL;
 334	PyObject *dialect = NULL;
 335	PyObject *delimiter = NULL;
 336	PyObject *doublequote = NULL;
 337	PyObject *escapechar = NULL;
 338	PyObject *lineterminator = NULL;
 339	PyObject *quotechar = NULL;
 340	PyObject *quoting = NULL;
 341	PyObject *skipinitialspace = NULL;
 342	PyObject *strict = NULL;
 343
 344	if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 345					 "|OOOOOOOOO", dialect_kws,
 346					 &dialect,
 347					 &delimiter,
 348					 &doublequote,
 349					 &escapechar,
 350					 &lineterminator,
 351					 &quotechar,
 352					 &quoting,
 353					 &skipinitialspace,
 354					 &strict))
 355		return NULL;
 356
 357	if (dialect != NULL) {
 358		if (IS_BASESTRING(dialect)) {
 359			dialect = get_dialect_from_registry(dialect);
 360			if (dialect == NULL)
 361				return NULL;
 362		}
 363		else
 364			Py_INCREF(dialect);
 365		/* Can we reuse this instance? */
 366		if (PyObject_TypeCheck(dialect, &Dialect_Type) &&
 367		    delimiter == 0 &&
 368		    doublequote == 0 &&
 369		    escapechar == 0 &&
 370		    lineterminator == 0 &&
 371		    quotechar == 0 &&
 372		    quoting == 0 &&
 373		    skipinitialspace == 0 &&
 374		    strict == 0)
 375			return dialect;
 376	}
 377
 378	self = (DialectObj *)type->tp_alloc(type, 0);
 379	if (self == NULL) {
 380		Py_XDECREF(dialect);
 381		return NULL;
 382	}
 383	self->lineterminator = NULL;
 384
 385	Py_XINCREF(delimiter);
 386	Py_XINCREF(doublequote);
 387	Py_XINCREF(escapechar);
 388	Py_XINCREF(lineterminator);
 389	Py_XINCREF(quotechar);
 390	Py_XINCREF(quoting);
 391	Py_XINCREF(skipinitialspace);
 392	Py_XINCREF(strict);
 393	if (dialect != NULL) {
 394#define DIALECT_GETATTR(v, n) \
 395		if (v == NULL) \
 396			v = PyObject_GetAttrString(dialect, n)
 397		DIALECT_GETATTR(delimiter, "delimiter");
 398		DIALECT_GETATTR(doublequote, "doublequote");
 399		DIALECT_GETATTR(escapechar, "escapechar");
 400		DIALECT_GETATTR(lineterminator, "lineterminator");
 401		DIALECT_GETATTR(quotechar, "quotechar");
 402		DIALECT_GETATTR(quoting, "quoting");
 403		DIALECT_GETATTR(skipinitialspace, "skipinitialspace");
 404		DIALECT_GETATTR(strict, "strict");
 405		PyErr_Clear();
 406	}
 407
 408	/* check types and convert to C values */
 409#define DIASET(meth, name, target, src, dflt) \
 410	if (meth(name, target, src, dflt)) \
 411		goto err
 412	DIASET(_set_char, "delimiter", &self->delimiter, delimiter, ',');
 413	DIASET(_set_bool, "doublequote", &self->doublequote, doublequote, 1);
 414	DIASET(_set_char, "escapechar", &self->escapechar, escapechar, 0);
 415	DIASET(_set_str, "lineterminator", &self->lineterminator, lineterminator, "\r\n");
 416	DIASET(_set_char, "quotechar", &self->quotechar, quotechar, '"');
 417	DIASET(_set_int, "quoting", &self->quoting, quoting, QUOTE_MINIMAL);
 418	DIASET(_set_bool, "skipinitialspace", &self->skipinitialspace, skipinitialspace, 0);
 419	DIASET(_set_bool, "strict", &self->strict, strict, 0);
 420
 421	/* validate options */
 422	if (dialect_check_quoting(self->quoting))
 423		goto err;
 424	if (self->delimiter == 0) {
 425                PyErr_SetString(PyExc_TypeError, "delimiter must be set");
 426		goto err;
 427	}
 428	if (quotechar == Py_None && quoting == NULL)
 429		self->quoting = QUOTE_NONE;
 430	if (self->quoting != QUOTE_NONE && self->quotechar == 0) {
 431                PyErr_SetString(PyExc_TypeError, 
 432				"quotechar must be set if quoting enabled");
 433		goto err;
 434	}
 435	if (self->lineterminator == 0) {
 436		PyErr_SetString(PyExc_TypeError, "lineterminator must be set");
 437		goto err;
 438	}
 439
 440	ret = (PyObject *)self;
 441	Py_INCREF(self);
 442err:
 443	Py_XDECREF(self);
 444	Py_XDECREF(dialect);
 445	Py_XDECREF(delimiter);
 446	Py_XDECREF(doublequote);
 447	Py_XDECREF(escapechar);
 448	Py_XDECREF(lineterminator);
 449	Py_XDECREF(quotechar);
 450	Py_XDECREF(quoting);
 451	Py_XDECREF(skipinitialspace);
 452	Py_XDECREF(strict);
 453	return ret;
 454}
 455
 456
 457PyDoc_STRVAR(Dialect_Type_doc, 
 458"CSV dialect\n"
 459"\n"
 460"The Dialect type records CSV parsing and generation options.\n");
 461
 462static PyTypeObject Dialect_Type = {
 463	PyVarObject_HEAD_INIT(NULL, 0)
 464	"_csv.Dialect",                         /* tp_name */
 465	sizeof(DialectObj),                     /* tp_basicsize */
 466	0,                                      /* tp_itemsize */
 467	/*  methods  */
 468	(destructor)Dialect_dealloc,            /* tp_dealloc */
 469	(printfunc)0,                           /* tp_print */
 470	(getattrfunc)0,                         /* tp_getattr */
 471	(setattrfunc)0,                         /* tp_setattr */
 472	(cmpfunc)0,                             /* tp_compare */
 473	(reprfunc)0,                            /* tp_repr */
 474	0,                                      /* tp_as_number */
 475	0,                                      /* tp_as_sequence */
 476	0,                                      /* tp_as_mapping */
 477	(hashfunc)0,                            /* tp_hash */
 478	(ternaryfunc)0,                         /* tp_call */
 479	(reprfunc)0,                    	/* tp_str */
 480	0,                                      /* tp_getattro */
 481        0,                                      /* tp_setattro */
 482        0,                                      /* tp_as_buffer */
 483        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 484	Dialect_Type_doc,                       /* tp_doc */
 485        0,                                      /* tp_traverse */
 486        0,                                      /* tp_clear */
 487        0,                                      /* tp_richcompare */
 488        0,                                      /* tp_weaklistoffset */
 489        0,                                      /* tp_iter */
 490        0,                                      /* tp_iternext */
 491	0,					/* tp_methods */
 492        Dialect_memberlist,                     /* tp_members */
 493        Dialect_getsetlist,                     /* tp_getset */
 494	0,					/* tp_base */
 495	0,					/* tp_dict */
 496	0,					/* tp_descr_get */
 497	0,					/* tp_descr_set */
 498	0,					/* tp_dictoffset */
 499	0,					/* tp_init */
 500	0,					/* tp_alloc */
 501	dialect_new,			        /* tp_new */
 502	0,                           		/* tp_free */
 503};
 504
 505/*
 506 * Return an instance of the dialect type, given a Python instance or kwarg
 507 * description of the dialect
 508 */
 509static PyObject *
 510_call_dialect(PyObject *dialect_inst, PyObject *kwargs)
 511{
 512	PyObject *ctor_args;
 513	PyObject *dialect;
 514
 515	ctor_args = Py_BuildValue(dialect_inst ? "(O)" : "()", dialect_inst);
 516	if (ctor_args == NULL)
 517		return NULL;
 518	dialect = PyObject_Call((PyObject *)&Dialect_Type, ctor_args, kwargs);
 519	Py_DECREF(ctor_args);
 520	return dialect;
 521}
 522
 523/*
 524 * READER
 525 */
 526static int
 527parse_save_field(ReaderObj *self)
 528{
 529	PyObject *field;
 530
 531	field = PyString_FromStringAndSize(self->field, self->field_len);
 532	if (field == NULL)
 533		return -1;
 534	self->field_len = 0;
 535	if (self->numeric_field) {
 536		PyObject *tmp;
 537
 538		self->numeric_field = 0;
 539		tmp = PyNumber_Float(field);
 540		if (tmp == NULL) {
 541			Py_DECREF(field);
 542			return -1;
 543		}
 544		Py_DECREF(field);
 545		field = tmp;
 546	}
 547	PyList_Append(self->fields, field);
 548	Py_DECREF(field);
 549	return 0;
 550}
 551
 552static int
 553parse_grow_buff(ReaderObj *self)
 554{
 555	if (self->field_size == 0) {
 556		self->field_size = 4096;
 557		if (self->field != NULL)
 558			PyMem_Free(self->field);
 559		self->field = PyMem_Malloc(self->field_size);
 560	}
 561	else {
 562		if (self->field_size > INT_MAX / 2) {
 563			PyErr_NoMemory();
 564			return 0;
 565		} 
 566		self->field_size *= 2;
 567		self->field = PyMem_Realloc(self->field, self->field_size);
 568	}
 569	if (self->field == NULL) {
 570		PyErr_NoMemory();
 571		return 0;
 572	}
 573	return 1;
 574}
 575
 576static int
 577parse_add_char(ReaderObj *self, char c)
 578{
 579	if (self->field_len >= field_limit) {
 580		PyErr_Format(error_obj, "field larger than field limit (%ld)",
 581			     field_limit);
 582		return -1;
 583	}
 584	if (self->field_len == self->field_size && !parse_grow_buff(self))
 585		return -1;
 586	self->field[self->field_len++] = c;
 587	return 0;
 588}
 589
 590static int
 591parse_process_char(ReaderObj *self, char c)
 592{
 593        DialectObj *dialect = self->dialect;
 594
 595	switch (self->state) {
 596	case START_RECORD:
 597		/* start of record */
 598		if (c == '\0')
 599			/* empty line - return [] */
 600			break;
 601		else if (c == '\n' || c == '\r') {
 602			self->state = EAT_CRNL;
 603			break;
 604		}
 605		/* normal character - handle as START_FIELD */
 606		self->state = START_FIELD;
 607		/* fallthru */
 608	case START_FIELD:
 609		/* expecting field */
 610		if (c == '\n' || c == '\r' || c == '\0') {
 611			/* save empty field - return [fields] */
 612			if (parse_save_field(self) < 0)
 613				return -1;
 614			self->state = (c == '\0' ? START_RECORD : EAT_CRNL);
 615		}
 616		else if (c == dialect->quotechar && 
 617			 dialect->quoting != QUOTE_NONE) {
 618			/* start quoted field */
 619			self->state = IN_QUOTED_FIELD;
 620		}
 621		else if (c == dialect->escapechar) {
 622			/* possible escaped character */
 623			self->state = ESCAPED_CHAR;
 624		}
 625		else if (c == ' ' && dialect->skipinitialspace)
 626			/* ignore space at start of field */
 627			;
 628		else if (c == dialect->delimiter) {
 629			/* save empty field */
 630			if (parse_save_field(self) < 0)
 631				return -1;
 632		}
 633		else {
 634			/* begin new unquoted field */
 635			if (dialect->quoting == QUOTE_NONNUMERIC)
 636				self->numeric_field = 1;
 637			if (parse_add_char(self, c) < 0)
 638				return -1;
 639			self->state = IN_FIELD;
 640		}
 641		break;
 642
 643	case ESCAPED_CHAR:
 644		if (c == '\0')
 645			c = '\n';
 646		if (parse_add_char(self, c) < 0)
 647			return -1;
 648		self->state = IN_FIELD;
 649		break;
 650
 651	case IN_FIELD:
 652		/* in unquoted field */
 653		if (c == '\n' || c == '\r' || c == '\0') {
 654			/* end of line - return [fields] */
 655			if (parse_save_field(self) < 0)
 656				return -1;
 657			self->state = (c == '\0' ? START_RECORD : EAT_CRNL);
 658		}
 659		else if (c == dialect->escapechar) {
 660			/* possible escaped character */
 661			self->state = ESCAPED_CHAR;
 662		}
 663		else if (c == dialect->delimiter) {
 664			/* save field - wait for new field */
 665			if (parse_save_field(self) < 0)
 666				return -1;
 667			self->state = START_FIELD;
 668		}
 669		else {
 670			/* normal character - save in field */
 671			if (parse_add_char(self, c) < 0)
 672				return -1;
 673		}
 674		break;
 675
 676	case IN_QUOTED_FIELD:
 677		/* in quoted field */
 678		if (c == '\0')
 679			;
 680		else if (c == dialect->escapechar) {
 681			/* Possible escape character */
 682			self->state = ESCAPE_IN_QUOTED_FIELD;
 683		}
 684		else if (c == dialect->quotechar &&
 685			 dialect->quoting != QUOTE_NONE) {
 686			if (dialect->doublequote) {
 687				/* doublequote; " represented by "" */
 688				self->state = QUOTE_IN_QUOTED_FIELD;
 689			}
 690			else {
 691				/* end of quote part of field */
 692				self->state = IN_FIELD;
 693			}
 694		}
 695		else {
 696			/* normal character - save in field */
 697			if (parse_add_char(self, c) < 0)
 698				return -1;
 699		}
 700		break;
 701
 702	case ESCAPE_IN_QUOTED_FIELD:
 703		if (c == '\0')
 704			c = '\n';
 705		if (parse_add_char(self, c) < 0)
 706			return -1;
 707		self->state = IN_QUOTED_FIELD;
 708		break;
 709
 710	case QUOTE_IN_QUOTED_FIELD:
 711		/* doublequote - seen a quote in an quoted field */
 712		if (dialect->quoting != QUOTE_NONE && 
 713                    c == dialect->quotechar) {
 714			/* save "" as " */
 715			if (parse_add_char(self, c) < 0)
 716				return -1;
 717			self->state = IN_QUOTED_FIELD;
 718		}
 719		else if (c == dialect->delimiter) {
 720			/* save field - wait for new field */
 721			if (parse_save_field(self) < 0)
 722				return -1;
 723			self->state = START_FIELD;
 724		}
 725		else if (c == '\n' || c == '\r' || c == '\0') {
 726			/* end of line - return [fields] */
 727			if (parse_save_field(self) < 0)
 728				return -1;
 729			self->state = (c == '\0' ? START_RECORD : EAT_CRNL);
 730		}
 731		else if (!dialect->strict) {
 732			if (parse_add_char(self, c) < 0)
 733				return -1;
 734			self->state = IN_FIELD;
 735		}
 736		else {
 737			/* illegal */
 738			PyErr_Format(error_obj, "'%c' expected after '%c'", 
 739					dialect->delimiter, 
 740                                        dialect->quotechar);
 741			return -1;
 742		}
 743		break;
 744
 745	case EAT_CRNL:
 746		if (c == '\n' || c == '\r')
 747			;
 748		else if (c == '\0')
 749			self->state = START_RECORD;
 750		else {
 751			PyErr_Format(error_obj, "new-line character seen in unquoted field - do you need to open the file in universal-newline mode?");
 752			return -1;
 753		}
 754		break;
 755
 756	}
 757	return 0;
 758}
 759
 760static int
 761parse_reset(ReaderObj *self)
 762{
 763	Py_XDECREF(self->fields);
 764	self->fields = PyList_New(0);
 765	if (self->fields == NULL)
 766		return -1;
 767	self->field_len = 0;
 768	self->state = START_RECORD;
 769	self->numeric_field = 0;
 770	return 0;
 771}
 772
 773static PyObject *
 774Reader_iternext(ReaderObj *self)
 775{
 776        PyObject *lineobj;
 777        PyObject *fields = NULL;
 778        char *line, c;
 779	int linelen;
 780
 781	if (parse_reset(self) < 0)
 782		return NULL;
 783        do {
 784                lineobj = PyIter_Next(self->input_iter);
 785                if (lineobj == NULL) {
 786                        /* End of input OR exception */
 787                        if (!PyErr_Occurred() && self->field_len != 0)
 788                                PyErr_Format(error_obj,
 789					     "newline inside string");
 790                        return NULL;
 791                }
 792		++self->line_num;
 793
 794                line = PyString_AsString(lineobj);
 795		linelen = PyString_Size(lineobj);
 796
 797                if (line == NULL || linelen < 0) {
 798                        Py_DECREF(lineobj);
 799                        return NULL;
 800                }
 801                while (linelen--) {
 802			c = *line++;
 803			if (c == '\0') {
 804				Py_DECREF(lineobj);
 805				PyErr_Format(error_obj,
 806					     "line contains NULL byte");
 807				goto err;
 808			}
 809			if (parse_process_char(self, c) < 0) {
 810				Py_DECREF(lineobj);
 811				goto err;
 812			}
 813		}
 814                Py_DECREF(lineobj);
 815		if (parse_process_char(self, 0) < 0)
 816			goto err;
 817        } while (self->state != START_RECORD);
 818
 819        fields = self->fields;
 820        self->fields = NULL;
 821err:
 822        return fields;
 823}
 824
 825static void
 826Reader_dealloc(ReaderObj *self)
 827{
 828	PyObject_GC_UnTrack(self);
 829        Py_XDECREF(self->dialect);
 830        Py_XDECREF(self->input_iter);
 831        Py_XDECREF(self->fields);
 832        if (self->field != NULL)
 833        	PyMem_Free(self->field);
 834	PyObject_GC_Del(self);
 835}
 836
 837static int
 838Reader_traverse(ReaderObj *self, visitproc visit, void *arg)
 839{
 840	Py_VISIT(self->dialect);
 841	Py_VISIT(self->input_iter);
 842	Py_VISIT(self->fields);
 843	return 0;
 844}
 845
 846static int
 847Reader_clear(ReaderObj *self)
 848{
 849	Py_CLEAR(self->dialect);
 850	Py_CLEAR(self->input_iter);
 851	Py_CLEAR(self->fields);
 852	return 0;
 853}
 854
 855PyDoc_STRVAR(Reader_Type_doc,
 856"CSV reader\n"
 857"\n"
 858"Reader objects are responsible for reading and parsing tabular data\n"
 859"in CSV format.\n"
 860);
 861
 862static struct PyMethodDef Reader_methods[] = {
 863	{ NULL, NULL }
 864};
 865#define R_OFF(x) offsetof(ReaderObj, x)
 866
 867static struct PyMemberDef Reader_memberlist[] = {
 868	{ "dialect", T_OBJECT, R_OFF(dialect), RO },
 869	{ "line_num", T_ULONG, R_OFF(line_num), RO },
 870	{ NULL }
 871};
 872
 873
 874static PyTypeObject Reader_Type = {
 875	PyVarObject_HEAD_INIT(NULL, 0)
 876	"_csv.reader",                          /*tp_name*/
 877	sizeof(ReaderObj),                      /*tp_basicsize*/
 878	0,                                      /*tp_itemsize*/
 879	/* methods */
 880	(destructor)Reader_dealloc,             /*tp_dealloc*/
 881	(printfunc)0,                           /*tp_print*/
 882	(getattrfunc)0,                         /*tp_getattr*/
 883	(setattrfunc)0,                         /*tp_setattr*/
 884	(cmpfunc)0,                             /*tp_compare*/
 885	(reprfunc)0,                            /*tp_repr*/
 886	0,                                      /*tp_as_number*/
 887	0,                                      /*tp_as_sequence*/
 888	0,                                      /*tp_as_mapping*/
 889	(hashfunc)0,                            /*tp_hash*/
 890	(ternaryfunc)0,                         /*tp_call*/
 891	(reprfunc)0,                    	/*tp_str*/
 892	0,                                      /*tp_getattro*/
 893        0,                                      /*tp_setattro*/
 894        0,                                      /*tp_as_buffer*/
 895        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
 896		Py_TPFLAGS_HAVE_GC,		/*tp_flags*/
 897	Reader_Type_doc,                        /*tp_doc*/
 898        (traverseproc)Reader_traverse,          /*tp_traverse*/
 899        (inquiry)Reader_clear,                  /*tp_clear*/
 900        0,                                      /*tp_richcompare*/
 901        0,                                      /*tp_weaklistoffset*/
 902        PyObject_SelfIter,		        /*tp_iter*/
 903        (getiterfunc)Reader_iternext,           /*tp_iternext*/
 904        Reader_methods,                         /*tp_methods*/
 905        Reader_memberlist,                      /*tp_members*/
 906        0,                                      /*tp_getset*/
 907
 908};
 909
 910static PyObject *
 911csv_reader(PyObject *module, PyObject *args, PyObject *keyword_args)
 912{
 913	PyObject * iterator, * dialect = NULL;
 914        ReaderObj * self = PyObject_GC_New(ReaderObj, &Reader_Type);
 915
 916        if (!self)
 917                return NULL;
 918
 919        self->dialect = NULL;
 920        self->fields = NULL;
 921        self->input_iter = NULL;
 922	self->field = NULL;
 923	self->field_size = 0;
 924	self->line_num = 0;
 925
 926	if (parse_reset(self) < 0) {
 927                Py_DECREF(self);
 928                return NULL;
 929	}
 930
 931	if (!PyArg_UnpackTuple(args, "", 1, 2, &iterator, &dialect)) {
 932                Py_DECREF(self);
 933                return NULL;
 934        }
 935        self->input_iter = PyObject_GetIter(iterator);
 936        if (self->input_iter == NULL) {
 937                PyErr_SetString(PyExc_TypeError, 
 938                                "argument 1 must be an iterator");
 939                Py_DECREF(self);
 940                return NULL;
 941        }
 942	self->dialect = (DialectObj *)_call_dialect(dialect, keyword_args);
 943        if (self->dialect == NULL) {
 944                Py_DECREF(self);
 945                return NULL;
 946        }
 947
 948	PyObject_GC_Track(self);
 949        return (PyObject *)self;
 950}
 951
 952/*
 953 * WRITER
 954 */
 955/* ---------------------------------------------------------------- */
 956static void
 957join_reset(WriterObj *self)
 958{
 959	self->rec_len = 0;
 960	self->num_fields = 0;
 961}
 962
 963#define MEM_INCR 32768
 964
 965/* Calculate new record length or append field to record.  Return new
 966 * record length.
 967 */
 968static int
 969join_append_data(WriterObj *self, char *field, int quote_empty,
 970		 int *quoted, int copy_phase)
 971{
 972        DialectObj *dialect = self->dialect;
 973	int i, rec_len;
 974	char *lineterm;
 975
 976#define ADDCH(c) \
 977	do {\
 978		if (copy_phase) \
 979			self->rec[rec_len] = c;\
 980		rec_len++;\
 981	} while(0)
 982
 983	lineterm = PyString_AsString(dialect->lineterminator);
 984	if (lineterm == NULL)
 985		return -1;
 986
 987	rec_len = self->rec_len;
 988
 989	/* If this is not the first field we need a field separator */
 990	if (self->num_fields > 0)
 991		ADDCH(dialect->delimiter);
 992
 993	/* Handle preceding quote */
 994	if (copy_phase && *quoted)
 995		ADDCH(dialect->quotechar);
 996
 997	/* Copy/count field data */
 998	for (i = 0;; i++) {
 999		char c = field[i];
1000		int want_escape = 0;
1001
1002		if (c == '\0')
1003			break;
1004
1005		if (c == dialect->delimiter ||
1006		    c == dialect->escapechar ||
1007		    c == dialect->quotechar ||
1008		    strchr(lineterm, c)) {
1009			if (dialect->quoting == QUOTE_NONE)
1010				want_escape = 1;
1011			else {
1012				if (c == dialect->quotechar) {
1013					if (dialect->doublequote)
1014						ADDCH(dialect->quotechar);
1015					else
1016						want_escape = 1;
1017				}
1018				if (!want_escape)
1019					*quoted = 1;
1020			}
1021			if (want_escape) {
1022				if (!dialect->escapechar) {
1023					PyErr_Format(error_obj, 
1024						     "need to escape, but no escapechar set");
1025					return -1;
1026				}
1027				ADDCH(dialect->escapechar);
1028			}
1029		}
1030		/* Copy field character into record buffer.
1031		 */
1032		ADDCH(c);
1033	}
1034
1035	/* If field is empty check if it needs to be quoted.
1036	 */
1037	if (i == 0 && quote_empty) {
1038		if (dialect->quoting == QUOTE_NONE) {
1039			PyErr_Format(error_obj,
1040                                     "single empty field record must be quoted");
1041			return -1;
1042		}
1043		else
1044			*quoted = 1;
1045	}
1046
1047	if (*quoted) {
1048		if (copy_phase)
1049			ADDCH(dialect->quotechar);
1050		else
1051			rec_len += 2;
1052	}
1053	return rec_len;
1054#undef ADDCH
1055}
1056
1057static int
1058join_check_rec_size(WriterObj *self, int rec_len)
1059{
1060
1061	if (rec_len < 0 || rec_len > INT_MAX - MEM_INCR) {
1062		PyErr_NoMemory();
1063		return 0;
1064	}
1065
1066	if (rec_len > self->rec_size) {
1067		if (self->rec_size == 0) {
1068			self->rec_size = (rec_len / MEM_INCR + 1) * MEM_INCR;
1069			if (self->rec != NULL)
1070				PyMem_Free(self->rec);
1071			self->rec = PyMem_Malloc(self->rec_size);
1072		}
1073		else {
1074			char *old_rec = self->rec;
1075
1076			self->rec_size = (rec_len / MEM_INCR + 1) * MEM_INCR;
1077			self->rec = PyMem_Realloc(self->rec, self->rec_size);
1078			if (self->rec == NULL)
1079				PyMem_Free(old_rec);
1080		}
1081		if (self->rec == NULL) {
1082			PyErr_NoMemory();
1083			return 0;
1084		}
1085	}
1086	return 1;
1087}
1088
1089static int
1090join_append(WriterObj *self, char *field, int *quoted, int quote_empty)
1091{
1092	int rec_len;
1093
1094	rec_len = join_append_data(self, field, quote_empty, quoted, 0);
1095	if (rec_len < 0)
1096		return 0;
1097
1098	/* grow record buffer if necessary */
1099	if (!join_check_rec_size(self, rec_len))
1100		return 0;
1101
1102	self->rec_len = join_append_data(self, field, quote_empty, quoted, 1);
1103	self->num_fields++;
1104
1105	return 1;
1106}
1107
1108static int
1109join_append_lineterminator(WriterObj *self)
1110{
1111	int terminator_len;
1112	char *terminator;
1113
1114	terminator_len = PyString_Size(self->dialect->lineterminator);
1115	if (terminator_len == -1)
1116		return 0;
1117
1118	/* grow record buffer if necessary */
1119	if (!join_check_rec_size(self, self->rec_len + terminator_len))
1120		return 0;
1121
1122	terminator = PyString_AsString(self->dialect->lineterminator); 
1123	if (terminator == NULL)
1124		return 0;
1125	memmove(self->rec + self->rec_len, terminator, terminator_len);
1126	self->rec_len += terminator_len;
1127
1128	return 1;
1129}
1130
1131PyDoc_STRVAR(csv_writerow_doc,
1132"writerow(sequence)\n"
1133"\n"
1134"Construct and write a CSV record from a sequence of fields.  Non-string\n"
1135"elements will be converted to string.");
1136
1137static PyObject *
1138csv_writerow(WriterObj *self, PyObject *seq)
1139{
1140        DialectObj *dialect = self->dialect;
1141	int len, i;
1142
1143	if (!PySequence_Check(seq))
1144		return PyErr_Format(error_obj, "sequence expected");
1145
1146	len = PySequence_Length(seq);
1147	if (len < 0)
1148		return NULL;
1149
1150	/* Join all fields in internal buffer.
1151	 */
1152	join_reset(self);
1153	for (i = 0; i < len; i++) {
1154		PyObject *field;
1155		int append_ok;
1156		int quoted;
1157
1158		field = PySequence_GetItem(seq, i);
1159		if (field == NULL)
1160			return NULL;
1161
1162		switch (dialect->quoting) {
1163		case QUOTE_NONNUMERIC:
1164			quoted = !PyNumber_Check(field);
1165			break;
1166		case QUOTE_ALL:
1167			quoted = 1;
1168			break;
1169		default:
1170			quoted = 0;
1171			break;
1172		}
1173
1174		if (PyString_Check(field)) {
1175			append_ok = join_append(self,
1176						PyString_AS_STRING(field),
1177                                                &quoted, len == 1);
1178			Py_DECREF(field);
1179		}
1180		else if (field == Py_None) {
1181			append_ok = join_append(self, "", &quoted, len == 1);
1182			Py_DECREF(field);
1183		}
1184		else {
1185			PyObject *str;
1186
1187			str = PyObject_Str(field);
1188			Py_DECREF(field);
1189			if (str == NULL)
1190				return NULL;
1191
1192			append_ok = join_append(self, PyString_AS_STRING(str), 
1193                                                &quoted, len == 1);
1194			Py_DECREF(str);
1195		}
1196		if (!append_ok)
1197			return NULL;
1198	}
1199
1200	/* Add line terminator.
1201	 */
1202	if (!join_append_lineterminator(self))
1203		return 0;
1204
1205	return PyObject_CallFunction(self->writeline, 
1206                                     "(s#)", self->rec, self->rec_len);
1207}
1208
1209PyDoc_STRVAR(csv_writerows_doc,
1210"writerows(sequence of sequences)\n"
1211"\n"
1212"Construct and write a series of sequences to a csv file.  Non-string\n"
1213"elements will be converted to string.");
1214
1215static PyObject *
1216csv_writerows(WriterObj *self, PyObject *seqseq)
1217{
1218        PyObject *row_iter, *row_obj, *result;
1219
1220        row_iter = PyObject_GetIter(seqseq);
1221        if (row_iter == NULL) {
1222                PyErr_SetString(PyExc_TypeError,
1223                                "writerows() argument must be iterable");
1224                return NULL;
1225        }
1226        while ((row_obj = PyIter_Next(row_iter))) {
1227                result = csv_writerow(self, row_obj);
1228                Py_DECREF(row_obj);
1229                if (!result) {
1230                        Py_DECREF(row_iter);
1231                        return NULL;
1232                }
1233                else
1234                     Py_DECREF(result);   
1235        }
1236        Py_DECREF(row_iter);
1237        if (PyErr_Occurred())
1238                return NULL;
1239        Py_INCREF(Py_None);
1240        return Py_None;
1241}
1242
1243static struct PyMethodDef Writer_methods[] = {
1244        { "writerow", (PyCFunction)csv_writerow, METH_O, csv_writerow_doc},
1245        { "writerows", (PyCFunction)csv_writerows, METH_O, csv_writerows_doc},
1246	{ NULL, NULL }
1247};
1248
1249#define W_OFF(x) offsetof(WriterObj, x)
1250
1251static struct PyMemberDef Writer_memberlist[] = {
1252	{ "dialect", T_OBJECT, W_OFF(dialect), RO },
1253	{ NULL }
1254};
1255
1256static void
1257Writer_dealloc(WriterObj *self)
1258{
1259	PyObject_GC_UnTrack(self);
1260        Py_XDECREF(self->dialect);
1261        Py_XDECREF(self->writeline);
1262	if (self->rec != NULL)
1263		PyMem_Free(self->rec);
1264	PyObject_GC_Del(self);
1265}
1266
1267static int
1268Writer_traverse(WriterObj *self, visitproc visit, void *arg)
1269{
1270	Py_VISIT(self->dialect);
1271	Py_VISIT(self->writeline);
1272	return 0;
1273}
1274
1275static int
1276Writer_clear(WriterObj *self)
1277{
1278	Py_CLEAR(self->dialect);
1279	Py_CLEAR(self->writeline);
1280	return 0;
1281}
1282
1283PyDoc_STRVAR(Writer_Type_doc, 
1284"CSV writer\n"
1285"\n"
1286"Writer objects are responsible for generating tabular data\n"
1287"in CSV format from sequence input.\n"
1288);
1289
1290static PyTypeObject Writer_Type = {
1291	PyVarObject_HEAD_INIT(NULL, 0)
1292	"_csv.writer",                          /*tp_name*/
1293	sizeof(WriterObj),                      /*tp_basicsize*/
1294	0,                                      /*tp_itemsize*/
1295	/* methods */
1296	(destructor)Writer_dealloc,             /*tp_dealloc*/
1297	(printfunc)0,                           /*tp_print*/
1298	(getattrfunc)0,                         /*tp_getattr*/
1299	(setattrfunc)0,                         /*tp_setattr*/
1300	(cmpfunc)0,                             /*tp_compare*/
1301	(reprfunc)0,                            /*tp_repr*/
1302	0,                                      /*tp_as_number*/
1303	0,                                      /*tp_as_sequence*/
1304	0,                                      /*tp_as_mapping*/
1305	(hashfunc)0,                            /*tp_hash*/
1306	(ternaryfunc)0,                         /*tp_call*/
1307	(reprfunc)0,                            /*tp_str*/
1308	0,                                      /*tp_getattro*/
1309        0,                                      /*tp_setattro*/
1310        0,                                      /*tp_as_buffer*/
1311        Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
1312		Py_TPFLAGS_HAVE_GC,		/*tp_flags*/
1313	Writer_Type_doc,
1314        (traverseproc)Writer_traverse,          /*tp_traverse*/
1315        (inquiry)Writer_clear,                  /*tp_clear*/
1316        0,                                      /*tp_richcompare*/
1317        0,                                      /*tp_weaklistoffset*/
1318        (getiterfunc)0,                         /*tp_iter*/
1319        (getiterfunc)0,                         /*tp_iternext*/
1320        Writer_methods,                         /*tp_methods*/
1321        Writer_memberlist,                      /*tp_members*/
1322        0,                                      /*tp_getset*/
1323};
1324
1325static PyObject *
1326csv_writer(PyObject *module, PyObject *args, PyObject *keyword_args)
1327{
1328	PyObject * output_file, * dialect = NULL;
1329        WriterObj * self = PyObject_GC_New(WriterObj, &Writer_Type);
1330
1331        if (!self)
1332                return NULL;
1333
1334        self->dialect = NULL;
1335        self->writeline = NULL;
1336
1337	self->rec = NULL;
1338	self->rec_size = 0;
1339	self->rec_len = 0;
1340	self->num_fields = 0;
1341
1342	if (!PyArg_UnpackTuple(args, "", 1, 2, &output_file, &dialect)) {
1343                Py_DECREF(self);
1344                return NULL;
1345        }
1346        self->writeline = PyObject_GetAttrString(output_file, "write");
1347        if (self->writeline == NULL || !PyCallable_Check(self->writeline)) {
1348                PyErr_SetString(PyExc_TypeError,
1349                                "argument 1 must have a \"write\" method");
1350                Py_DECREF(self);
1351                return NULL;
1352        }
1353	self->dialect = (DialectObj *)_call_dialect(dialect, keyword_args);
1354        if (self->dialect == NULL) {
1355                Py_DECREF(self);
1356                return NULL;
1357        }
1358	PyObject_GC_Track(self);
1359        return (PyObject *)self;
1360}
1361
1362/*
1363 * DIALECT REGISTRY
1364 */
1365static PyObject *
1366csv_list_dialects(PyObject *module, PyObject *args)
1367{
1368        return PyDict_Keys(dialects);
1369}
1370
1371static PyObject *
1372csv_register_dialect(PyObject *module, PyObject *args, PyObject *kwargs)
1373{
1374	PyObject *name_obj, *dialect_obj = NULL;
1375	PyObject *dialect;
1376
1377	if (!PyArg_UnpackTuple(args, "", 1, 2, &name_obj, &dialect_obj))
1378                return NULL;
1379        if (!IS_BASESTRING(name_obj)) {
1380                PyErr_SetString(PyExc_TypeError, 
1381                                "dialect name must be a string or unicode");
1382                return NULL;
1383        }
1384	dialect = _call_dialect(dialect_obj, kwargs);
1385	if (dialect == NULL)
1386		return NULL;
1387	if (PyDict_SetItem(dialects, name_obj, dialect) < 0) {
1388		Py_DECREF(dialect);
1389                return NULL;
1390        }
1391	Py_DECREF(dialect);
1392        Py_INCREF(Py_None);
1393        return Py_None;
1394}
1395
1396static PyObject *
1397csv_unregister_dialect(PyObject *module, PyObject *name_obj)
1398{
1399        if (PyDict_DelItem(dialects, name_obj) < 0)
1400                return PyErr_Format(error_obj, "unknown dialect");
1401        Py_INCREF(Py_None);
1402        return Py_None;
1403}
1404
1405static PyObject *
1406csv_get_dialect(PyObject *module, PyObject *name_obj)
1407{
1408        return get_dialect_from_registry(name_obj);
1409}
1410
1411static PyObject *
1412csv_field_size_limit(PyObject *module, PyObject *args)
1413{
1414	PyObject *new_limit = NULL;
1415	long old_limit = field_limit;
1416
1417	if (!PyArg_UnpackTuple(args, "field_size_limit", 0, 1, &new_limit))
1418		return NULL;
1419	if (new_limit != NULL) {
1420		if (!PyInt_Check(new_limit)) {
1421			PyErr_Format(PyExc_TypeError, 
1422				     "limit must be an integer");
1423			return NULL;
1424		}
1425		field_limit = PyInt_AsLong(new_limit);
1426	}
1427	return PyInt_FromLong(old_limit);
1428}
1429
1430/*
1431 * MODULE
1432 */
1433
1434PyDoc_STRVAR(csv_module_doc,
1435"CSV parsing and writing.\n"
1436"\n"
1437"This module provides classes that assist in the reading and writing\n"
1438"of Comma Separated Value (CSV) files, and implements the interface\n"
1439"described by PEP 305.  Although many CSV files are simple to parse,\n"
1440"the format is not formally defined by a stable specification and\n"
1441"is subtle enough that parsing lines of a CSV file with something\n"
1442"like line.split(\",\") is bound to fail.  The module supports three\n"
1443"basic APIs: reading, writing, and registration of dialects.\n"
1444"\n"
1445"\n"
1446"DIALECT REGISTRATION:\n"
1447"\n"
1448"Readers and writers support a dialect argument, which is a convenient\n"
1449"handle on a group of settings.  When the dialect argument is a string,\n"
1450"it identifies one of the dialects previously registered with the module.\n"
1451"If it is a class or instance, the attributes of the argument are used as\n"
1452"the settings for the reader or writer:\n"
1453"\n"
1454"    class excel:\n"
1455"        delimiter = ','\n"
1456"        quotechar = '\"'\n"
1457"        escapechar = None\n"
1458"        doublequote = True\n"
1459"        skipinitialspace = False\n"
1460"        lineterminator = '\\r\\n'\n"
1461"        quoting = QUOTE_MINIMAL\n"
1462"\n"
1463"SETTINGS:\n"
1464"\n"
1465"    * quotechar - specifies a one-character string to use as the \n"
1466"        quoting character.  It defaults to '\"'.\n"
1467"    * delimiter - specifies a one-character string to use as the \n"
1468"        field separator.  It defaults to ','.\n"
1469"    * skipinitialspace - specifies how to interpret whitespace which\n"
1470"        immediately follows a delimiter.  It defaults to False, which\n"
1471"        means that whitespace immediately following a delimiter is part\n"
1472"        of the following field.\n"
1473"    * lineterminator -  specifies the character sequence which should \n"
1474"        terminate rows.\n"
1475"    * quoting - controls when quotes should be generated by the writer.\n"
1476"        It can take on any of the following module constants:\n"
1477"\n"
1478"        csv.QUOTE_MINIMAL means only when required, for example, when a\n"
1479"            field contains either the quotechar or the delimiter\n"
1480"        csv.QUOTE_ALL means that quotes are always placed around fields.\n"
1481"        csv.QUOTE_NONNUMERIC means that quotes are always placed around\n"
1482"            fields which do not parse as integers or floating point\n"
1483"            numbers.\n"
1484"        csv.QUOTE_NONE means that quotes are never placed around fields.\n"
1485"    * escapechar - specifies a one-character string used to escape \n"
1486"        the delimiter when quoting is set to QUOTE_NONE.\n"
1487"    * doublequote - controls the handling of quotes inside fields.  When\n"
1488"        True, two consecutive quotes are interpreted as one during read,\n"
1489"        and when writing, each quote character embedded in the data is\n"
1490"        written as two quotes\n");
1491
1492PyDoc_STRVAR(csv_reader_doc,
1493"    csv_reader = reader(iterable [, dialect='excel']\n"
1494"                        [optional keyword args])\n"
1495"    for row in csv_reader:\n"
1496"        process(row)\n"
1497"\n"
1498"The \"iterable\" argument can be any object that returns a line\n"
1499"of input for each iteration, such as a file object or a list.  The\n"
1500"optional \"dialect\" parameter is discussed below.  The function\n"
1501"also accepts optional keyword arguments which override settings\n"
1502"provided by the dialect.\n"
1503"\n"
1504"The returned object is an iterator.  Each iteration returns a row\n"
1505"of the CSV file (which can span multiple input lines):\n");
1506
1507PyDoc_STRVAR(csv_writer_doc,
1508"    csv_writer = csv.writer(fileobj [, dialect='excel']\n"
1509"                            [optional keyword args])\n"
1510"    for row in sequence:\n"
1511"        csv_writer.writerow(row)\n"
1512"\n"
1513"    [or]\n"
1514"\n"
1515"    csv_writer = csv.writer(fileobj [, dialect='excel']\n"
1516"                            [optional keyword args])\n"
1517"    csv_writer.writerows(rows)\n"
1518"\n"
1519"The \"fileobj\" argument can be any object that supports the file API.\n");
1520
1521PyDoc_STRVAR(csv_list_dialects_doc,
1522"Return a list of all know dialect names.\n"
1523"    names = csv.list_dialects()");
1524
1525PyDoc_STRVAR(csv_get_dialect_doc,
1526"Return the dialect instance associated with name.\n"
1527"    dialect = csv.get_dialect(name)");
1528
1529PyDoc_STRVAR(csv_register_dialect_doc,
1530"Create a mapping from a string name to a dialect class.\n"
1531"    dialect = csv.register_dialect(name, dialect)");
1532
1533PyDoc_STRVAR(csv_unregister_dialect_doc,
1534"Delete the name/dialect mapping associated with a string name.\n"
1535"    csv.unregister_dialect(name)");
1536
1537PyDoc_STRVAR(csv_field_size_limit_doc,
1538"Sets an upper limit on parsed fields.\n"
1539"    csv.field_size_limit([limit])\n"
1540"\n"
1541"Returns old limit. If limit is not given, no new limit is set and\n"
1542"the old limit is returned");
1543
1544static struct PyMethodDef csv_methods[] = {
1545	{ "reader", (PyCFunction)csv_reader, 
1546		METH_VARARGS | METH_KEYWORDS, csv_reader_doc},
1547	{ "writer", (PyCFunction)csv_writer, 
1548		METH_VARARGS | METH_KEYWORDS, csv_writer_doc},
1549	{ "list_dialects", (PyCFunction)csv_list_dialects, 
1550		METH_NOARGS, csv_list_dialects_doc},
1551	{ "register_dialect", (PyCFunction)csv_register_dialect, 
1552		METH_VARARGS | METH_KEYWORDS, csv_register_dialect_doc},
1553	{ "unregister_dialect", (PyCFunction)csv_unregister_dialect, 
1554		METH_O, csv_unregister_dialect_doc},
1555	{ "get_dialect", (PyCFunction)csv_get_dialect, 
1556		METH_O, csv_get_dialect_doc},
1557	{ "field_size_limit", (PyCFunction)csv_field_size_limit, 
1558		METH_VARARGS, csv_field_size_limit_doc},
1559	{ NULL, NULL }
1560};
1561
1562PyMODINIT_FUNC
1563init_csv(void)
1564{
1565	PyObject *module;
1566	StyleDesc *style;
1567
1568	if (PyType_Ready(&Dialect_Type) < 0)
1569		return;
1570
1571	if (PyType_Ready(&Reader_Type) < 0)
1572		return;
1573
1574	if (PyType_Ready(&Writer_Type) < 0)
1575		return;
1576
1577	/* Create the module and add the functions */
1578	module = Py_InitModule3("_csv", csv_methods, csv_module_doc);
1579	if (module == NULL)
1580		return;
1581
1582	/* Add version to the module. */
1583	if (PyModule_AddStringConstant(module, "__version__",
1584				       MODULE_VERSION) == -1)
1585		return;
1586
1587        /* Add _dialects dictionary */
1588        dialects = PyDict_New();
1589        if (dialects == NULL)
1590                return;
1591        if (PyModule_AddObject(module, "_dialects", dialects))
1592                return;
1593
1594	/* Add quote styles into dictionary */
1595	for (style = quote_styles; style->name; style++) {
1596		if (PyModule_AddIntConstant(module, style->name,
1597					    style->style) == -1)
1598			return;
1599	}
1600
1601        /* Add the Dialect type */
1602	Py_INCREF(&Dialect_Type);
1603        if (PyModule_AddObject(module, "Dialect", (PyObject *)&Dialect_Type))
1604                return;
1605
1606	/* Add the CSV exception object to the module. */
1607	error_obj = PyErr_NewException("_csv.Error", NULL, NULL);
1608	if (error_obj == NULL)
1609		return;
1610	PyModule_AddObject(module, "Error", error_obj);
1611}