Add create mode to open()

Modules/_io/fileio.c

 /* Author: Daniel Stutzbach */
 
 #define PY_SSIZE_T_CLEAN
 #include "Python.h"
 #include "structmember.h"
 #ifdef HAVE_SYS_TYPES_H
 #include <sys/types.h>
 #endif
 #ifdef HAVE_SYS_STAT_H
 #include <sys/stat.h>
@@ skipping 34 matching lines @@
 
 #if SIZEOF_INT < 4
 #define BIGCHUNK  (512 * 32)
 #else
 #define BIGCHUNK  (512 * 1024)
 #endif
 
 typedef struct {
     PyObject_HEAD
     int fd;
+    unsigned int created : 1;
     unsigned int readable : 1;
     unsigned int writable : 1;
     signed int seekable : 2; /* -1 means unknown */
     unsigned int closefd : 1;
     unsigned int deallocating: 1;
     PyObject *weakreflist;
     PyObject *dict;
 } fileio;
 
 PyTypeObject PyFileIO_Type;
@@ skipping 85 matching lines @@
 static PyObject *
 fileio_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
     fileio *self;
 
     assert(type != NULL && type->tp_alloc != NULL);
 
     self = (fileio *) type->tp_alloc(type, 0);
     if (self != NULL) {
         self->fd = -1;
+        self->created = 0;
         self->readable = 0;
         self->writable = 0;
         self->seekable = -1;
         self->closefd = 1;
         self->weakreflist = NULL;
     }
 
     return (PyObject *) self;
 }
 
@@ skipping 115 matching lines @@
                                 "encoder failed to return bytes");
                 goto error;
             }
             name = PyBytes_AS_STRING(stringobj);
         }
     }
 
     s = mode;
     while (*s) {
         switch (*s++) {
-        case 'r':
+        case 'x':
             if (rwa) {
             bad_mode:
                 PyErr_SetString(PyExc_ValueError,
-                                "Must have exactly one of read/write/append "
+                                "Must have exactly one of create/read/write/append "
                                 "mode and at most one plus");
                 goto error;
             }
             rwa = 1;
+            self->created = 1;
+            self->writable = 1;
+                flags |= O_EXCL | O_CREAT;

[Benjamin Peterson, 2012/01/08 16:16:10]

Strange indentation again.

+            break;
+        case 'r':
+            if (rwa)
+                goto bad_mode;
+            rwa = 1;
             self->readable = 1;
             break;
         case 'w':
             if (rwa)
                 goto bad_mode;
             rwa = 1;
             self->writable = 1;
             flags |= O_CREAT | O_TRUNC;
             break;
         case 'a':
@@ skipping 150 matching lines @@
                  "File not open for %s", action);
     return NULL;
 }
 
 static PyObject *
 fileio_fileno(fileio *self)
 {
     if (self->fd < 0)
         return err_closed();
     return PyLong_FromLong((long) self->fd);
+}
+
+static PyObject *
+fileio_created(fileio *self)
+{
+    if (self->fd < 0)
+        return err_closed();
+    return PyBool_FromLong((long) self->created);
 }
 
 static PyObject *
 fileio_readable(fileio *self)
 {
     if (self->fd < 0)
         return err_closed();
     return PyBool_FromLong((long) self->readable);
 }
 
@@ skipping 472 matching lines @@
         return NULL;
     }
 
     return posobj;
 }
 #endif /* HAVE_FTRUNCATE */
 
 static char *
 mode_string(fileio *self)
 {
+        if (self->created) {

[Charles-François Natali, 2011/12/30 12:49:33]

Indentation.

+                if (self->readable)
+                        return "xb+";
+                else
+                        return "xb";
+        }
     if (self->readable) {
         if (self->writable)
             return "rb+";
         else
             return "rb";
     }
     else
         return "wb";
 }
 
@@ skipping 40 matching lines @@
 {
     PyErr_Format(PyExc_TypeError,
                  "cannot serialize '%s' object", Py_TYPE(self)->tp_name);
     return NULL;
 }
 
 
 PyDoc_STRVAR(fileio_doc,
 "file(name: str[, mode: str]) -> file IO object\n"
 "\n"
-"Open a file.  The mode can be 'r', 'w' or 'a' for reading (default),\n"
-"writing or appending.  The file will be created if it doesn't exist\n"
-"when opened for writing or appending; it will be truncated when\n"
-"opened for writing.  Add a '+' to the mode to allow simultaneous\n"
-"reading and writing.");
+"Open a file.  The mode can be 'x', 'r', 'w' or 'a' for creating,\n"
+"reading (default), writing or appending.  The file will be created\n"
+"if it doesn't exist when opened for writing or appending; it will be\n"
+"truncated when opened for writing.  An IOError will be raise if it\n"

[Benjamin Peterson, 2012/01/08 16:16:10]

OSError.

+"already exists when opened for creating. Opening a file for creating\n"
+"implies writing, so this mode behaves in a similar way to 'w'.  Add a\n"
+"'+' to the mode to allow simultaneous reading and writing.");
 
 PyDoc_STRVAR(read_doc,
 "read(size: int) -> bytes.  read at most size bytes, returned as bytes.\n"
 "\n"
 "Only makes one system call, so less data may be returned than requested\n"
 "In non-blocking mode, returns None if no data is available.\n"
 "On end-of-file, returns ''.");
 
 PyDoc_STRVAR(readall_doc,
 "readall() -> bytes.  read all data from the file, returned as bytes.\n"
@@ skipping 41 matching lines @@
 "close() -> None.  Close the file.\n"
 "\n"
 "A closed file cannot be used for further I/O operations.  close() may be\n"
 "called more than once without error.  Changes the fileno to -1.");
 
 PyDoc_STRVAR(isatty_doc,
 "isatty() -> bool.  True if the file is connected to a tty device.");
 
 PyDoc_STRVAR(seekable_doc,
 "seekable() -> bool.  True if file supports random-access.");
+
+PyDoc_STRVAR(created_doc,
+"created() -> bool. True if file was newly created when opened with 'x' mode");

[Charles-François Natali, 2011/12/30 12:49:33]

Nit: missing space.

 
 PyDoc_STRVAR(readable_doc,
 "readable() -> bool.  True if file was opened in a read mode.");
 
 PyDoc_STRVAR(writable_doc,
 "writable() -> bool.  True if file was opened in a write mode.");
 
 static PyMethodDef fileio_methods[] = {
     {"read",     (PyCFunction)fileio_read,         METH_VARARGS, read_doc},
     {"readall",  (PyCFunction)fileio_readall,  METH_NOARGS,  readall_doc},
     {"readinto", (PyCFunction)fileio_readinto, METH_VARARGS, readinto_doc},
     {"write",    (PyCFunction)fileio_write,        METH_VARARGS, write_doc},
     {"seek",     (PyCFunction)fileio_seek,         METH_VARARGS, seek_doc},
     {"tell",     (PyCFunction)fileio_tell,         METH_VARARGS, tell_doc},
 #ifdef HAVE_FTRUNCATE
     {"truncate", (PyCFunction)fileio_truncate, METH_VARARGS, truncate_doc},
 #endif
     {"close",    (PyCFunction)fileio_close,        METH_NOARGS,  close_doc},
     {"seekable", (PyCFunction)fileio_seekable, METH_NOARGS,      seekable_doc},
+    {"created",  (PyCFunction)fileio_created,  METH_NOARGS,      created_doc},
     {"readable", (PyCFunction)fileio_readable, METH_NOARGS,      readable_doc},
     {"writable", (PyCFunction)fileio_writable, METH_NOARGS,      writable_doc},
     {"fileno",   (PyCFunction)fileio_fileno,   METH_NOARGS,      fileno_doc},
     {"isatty",   (PyCFunction)fileio_isatty,   METH_NOARGS,      isatty_doc},
     {"_dealloc_warn", (PyCFunction)fileio_dealloc_warn, METH_O, NULL},
     {"__getstate__", (PyCFunction)fileio_getstate, METH_NOARGS, NULL},
     {NULL,           NULL}             /* sentinel */
 };
 
 /* 'closed' and 'mode' are attributes for backwards compatibility reasons. */
@@ skipping 59 matching lines @@
     0,                                          /* tp_base */
     0,                                          /* tp_dict */
     0,                                          /* tp_descr_get */
     0,                                          /* tp_descr_set */
     offsetof(fileio, dict),         /* tp_dictoffset */
     fileio_init,                                /* tp_init */
     PyType_GenericAlloc,                        /* tp_alloc */
     fileio_new,                                 /* tp_new */
     PyObject_GC_Del,                            /* tp_free */
 };