Add create mode to open()

Modules/_io/_iomodule.c

 /*
     An implementation of the new I/O lib as defined by PEP 3116 - "New I/O"
     
     Classes defined here: UnsupportedOperation, BlockingIOError.
     Functions defined here: open().
     
     Mostly written by Amaury Forgeot d'Arc
 */
 
 #define PY_SSIZE_T_CLEAN
@@ skipping 172 matching lines @@
 "Open file and return a stream.  Raise IOError upon failure.\n"
 "\n"
 "file is either a text or byte string giving the name (and the path\n"
 "if the file isn't in the current working directory) of the file to\n"
 "be opened or an integer file descriptor of the file to be\n"
 "wrapped. (If a file descriptor is given, it is closed when the\n"
 "returned I/O object is closed, unless closefd is set to False.)\n"
 "\n"
 "mode is an optional string that specifies the mode in which the file\n"
 "is opened. It defaults to 'r' which means open for reading in text\n"
-"mode.  Other common values are 'w' for writing (truncating the file if\n"
+"mode.  Other common values are 'x' for creating and writing to a new \n"
+"file, 'w' for writing (truncating the file if\n"
 "it already exists), and 'a' for appending (which on some Unix systems,\n"
 "means that all writes append to the end of the file regardless of the\n"
 "current seek position). In text mode, if encoding is not specified the\n"
 "encoding used is platform dependent. (For reading and writing raw\n"
 "bytes use binary mode and leave encoding unspecified.) The available\n"
 "modes are:\n"
 "\n"
 "========= ===============================================================\n"
 "Character Meaning\n"
 "--------- ---------------------------------------------------------------\n"
 "'r'       open for reading (default)\n"
+"'x'       create a new file and open it for writing\n"
 "'w'       open for writing, truncating the file first\n"
 "'a'       open for writing, appending to the end of the file if it exists\n"
 "'b'       binary mode\n"
 "'t'       text mode (default)\n"
 "'+'       open a disk file for updating (reading and writing)\n"
 "'U'       universal newline mode (for backwards compatibility; unneeded\n"
 "          for new code)\n"
 "========= ===============================================================\n"
 "\n"
 "The default mode is 'rt' (open for reading text). For binary random\n"
 "access, the mode 'w+b' opens and truncates the file to 0 bytes, while\n"
-"'r+b' opens the file without truncation.\n"
+"'r+b' opens the file without truncation. The 'x' mode implies 'w' and\n"
+"raises an `IOError` if the file already exists.\n"

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

OSError.

 "\n"
 "Python distinguishes between files opened in binary and text modes,\n"
 "even when the underlying operating system doesn't. Files opened in\n"
 "binary mode (appending 'b' to the mode argument) return contents as\n"
 "bytes objects without any decoding. In text mode (the default, or when\n"
 "'t' is appended to the mode argument), the contents of the file are\n"
 "returned as strings, the bytes having been first decoded using a\n"
 "platform-dependent encoding or using the specified encoding if given.\n"
 "\n"
 "buffering is an optional integer used to set the buffering policy.\n"
@@ skipping 66 matching lines @@
 {
     char *kwlist[] = {"file", "mode", "buffering",
                       "encoding", "errors", "newline",
                       "closefd", NULL};
     PyObject *file;
     char *mode = "r";
     int buffering = -1, closefd = 1;
     char *encoding = NULL, *errors = NULL, *newline = NULL;
     unsigned i;
 
-    int reading = 0, writing = 0, appending = 0, updating = 0;
+    int creating = 0, reading = 0, writing = 0, appending = 0, updating = 0;
     int text = 0, binary = 0, universal = 0;
 
     char rawmode[5], *m;
     int line_buffering, isatty;
 
     PyObject *raw, *modeobj = NULL, *buffer = NULL, *wrapper = NULL;
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|sizzzi:open", kwlist,
                                      &file, &mode, &buffering,
                                      &encoding, &errors, &newline,
                                      &closefd)) {
         return NULL;
     }
 
     if (!PyUnicode_Check(file) &&
         !PyBytes_Check(file) &&
         !PyNumber_Check(file)) {
         PyErr_Format(PyExc_TypeError, "invalid file: %R", file);
         return NULL;
     }
 
     /* Decode mode */
     for (i = 0; i < strlen(mode); i++) {
         char c = mode[i];
 
         switch (c) {
+        case 'x':
+                creating = 1;
+                break;

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

The indentation level odesn't match.

         case 'r':
             reading = 1;
             break;
         case 'w':
             writing = 1;
             break;
         case 'a':
             appending = 1;
             break;
         case '+':
@@ skipping 16 matching lines @@
         /* c must not be duplicated */
         if (strchr(mode+i+1, c)) {
           invalid_mode:
             PyErr_Format(PyExc_ValueError, "invalid mode: '%s'", mode);
             return NULL;
         }
 
     }
 
     m = rawmode;
+    if (creating)  *(m++) = 'x';
     if (reading)   *(m++) = 'r';
     if (writing)   *(m++) = 'w';
     if (appending) *(m++) = 'a';
     if (updating)  *(m++) = '+';
     *m = '\0';
 
     /* Parameters validation */
     if (universal) {
         if (writing || appending) {
             PyErr_SetString(PyExc_ValueError,
                             "can't use U and writing mode at once");
             return NULL;
         }
         reading = 1;
     }
 
     if (text && binary) {
         PyErr_SetString(PyExc_ValueError,
                         "can't have text and binary mode at once");
         return NULL;
     }
 
-    if (reading + writing + appending > 1) {
+    if (creating + reading + writing + appending > 1) {
         PyErr_SetString(PyExc_ValueError,
-                        "must have exactly one of read/write/append mode");
+                        "must have exactly one of create/read/write/append mode");
         return NULL;
     }
 
     if (binary && encoding != NULL) {
         PyErr_SetString(PyExc_ValueError,
                         "binary mode doesn't take an encoding argument");
         return NULL;
     }
 
     if (binary && errors != NULL) {
@@ skipping 73 matching lines @@
         Py_DECREF(modeobj);
         return raw;
     }
 
     /* wraps into a buffered file */
     {
         PyObject *Buffered_class;
 
         if (updating)
             Buffered_class = (PyObject *)&PyBufferedRandom_Type;
-        else if (writing || appending)
+        else if (creating || writing || appending)
             Buffered_class = (PyObject *)&PyBufferedWriter_Type;
         else if (reading)
             Buffered_class = (PyObject *)&PyBufferedReader_Type;
         else {
             PyErr_Format(PyExc_ValueError,
                          "unknown mode: '%s'", mode);
             goto error;
         }
 
         buffer = PyObject_CallFunction(Buffered_class, "Oi", raw, buffering);
@@ skipping 306 matching lines @@
     state->initialized = 1;
 
     return m;
 
   fail:
     Py_XDECREF(state->os_module);
     Py_XDECREF(state->unsupported_operation);
     Py_DECREF(m);
     return NULL;
 }