Commits

Victor Stinner  committed 0d9067c

Rename unicode_write_t structure and its methods to "_PyUnicodeWriter"

  • Participants
  • Parent commits 6c8a117

Comments (0)

Files changed (2)

File Objects/stringlib/unicode_format.h

     appends to the output.
 */
 static int
-render_field(PyObject *fieldobj, SubString *format_spec, unicode_writer_t *writer)
+render_field(PyObject *fieldobj, SubString *format_spec, _PyUnicodeWriter *writer)
 {
     int ok = 0;
     PyObject *result = NULL;
         goto done;
 
     len = PyUnicode_GET_LENGTH(result);
-    if (unicode_writer_prepare(writer,
+    if (_PyUnicodeWriter_Prepare(writer,
                                len, PyUnicode_MAX_CHAR_VALUE(result)) == -1)
         goto done;
     copy_characters(writer->buffer, writer->pos,
 static int
 output_markup(SubString *field_name, SubString *format_spec,
               int format_spec_needs_expanding, Py_UCS4 conversion,
-              unicode_writer_t *writer, PyObject *args, PyObject *kwargs,
+              _PyUnicodeWriter *writer, PyObject *args, PyObject *kwargs,
               int recursion_depth, AutoNumber *auto_number)
 {
     PyObject *tmp = NULL;
 */
 static int
 do_markup(SubString *input, PyObject *args, PyObject *kwargs,
-          unicode_writer_t *writer, int recursion_depth, AutoNumber *auto_number)
+          _PyUnicodeWriter *writer, int recursion_depth, AutoNumber *auto_number)
 {
     MarkupIterator iter;
     int format_spec_needs_expanding;
         if (sublen) {
             maxchar = _PyUnicode_FindMaxChar(literal.str,
                                              literal.start, literal.end);
-            err = unicode_writer_prepare(writer, sublen, maxchar);
+            err = _PyUnicodeWriter_Prepare(writer, sublen, maxchar);
             if (err == -1)
                 return 0;
             copy_characters(writer->buffer, writer->pos,
 build_string(SubString *input, PyObject *args, PyObject *kwargs,
              int recursion_depth, AutoNumber *auto_number)
 {
-    unicode_writer_t writer;
+    _PyUnicodeWriter writer;
     Py_ssize_t initlen;
 
     /* check the recursion level */
     }
 
     initlen = PyUnicode_GET_LENGTH(input->str) + 100;
-    if (unicode_writer_init(&writer, initlen, 127) == -1)
+    if (_PyUnicodeWriter_Init(&writer, initlen, 127) == -1)
         return NULL;
 
     if (!do_markup(input, args, kwargs, &writer, recursion_depth,
                    auto_number)) {
-        unicode_writer_dealloc(&writer);
+        _PyUnicodeWriter_Dealloc(&writer);
         return NULL;
     }
 
-    return unicode_writer_finish(&writer);
+    return _PyUnicodeWriter_Finish(&writer);
 }
 
 /************************************************************************/

File Objects/unicodeobject.c

     enum PyUnicode_Kind kind;
     Py_UCS4 maxchar;
     Py_ssize_t pos;
-} unicode_writer_t;
+} _PyUnicodeWriter ;
 
 Py_LOCAL_INLINE(void)
-unicode_writer_update(unicode_writer_t *writer)
+_PyUnicodeWriter_Update(_PyUnicodeWriter *writer)
 {
     writer->maxchar = PyUnicode_MAX_CHAR_VALUE(writer->buffer);
     writer->data = PyUnicode_DATA(writer->buffer);
 }
 
 Py_LOCAL(int)
-unicode_writer_init(unicode_writer_t *writer,
+_PyUnicodeWriter_Init(_PyUnicodeWriter *writer,
                     Py_ssize_t length, Py_UCS4 maxchar)
 {
     writer->pos = 0;
     writer->buffer = PyUnicode_New(length, maxchar);
     if (writer->buffer == NULL)
         return -1;
-    unicode_writer_update(writer);
+    _PyUnicodeWriter_Update(writer);
     return 0;
 }
 
 Py_LOCAL_INLINE(int)
-unicode_writer_prepare(unicode_writer_t *writer,
+_PyUnicodeWriter_Prepare(_PyUnicodeWriter *writer,
                        Py_ssize_t length, Py_UCS4 maxchar)
 {
     Py_ssize_t newlen;
                 return -1;
         }
         writer->buffer = newbuffer;
-        unicode_writer_update(writer);
+        _PyUnicodeWriter_Update(writer);
     }
     else if (maxchar > writer->maxchar) {
         if (unicode_widen(&writer->buffer, writer->pos, maxchar) < 0)
             return -1;
-        unicode_writer_update(writer);
+        _PyUnicodeWriter_Update(writer);
     }
     return 0;
 }
 
 Py_LOCAL(PyObject *)
-unicode_writer_finish(unicode_writer_t *writer)
+_PyUnicodeWriter_Finish(_PyUnicodeWriter *writer)
 {
     if (PyUnicode_Resize(&writer->buffer, writer->pos) < 0) {
         Py_DECREF(writer->buffer);
 }
 
 Py_LOCAL(void)
-unicode_writer_dealloc(unicode_writer_t *writer)
+_PyUnicodeWriter_Dealloc(_PyUnicodeWriter *writer)
 {
     Py_CLEAR(writer->buffer);
 }
     PyObject *uformat;
     void *fmt;
     enum PyUnicode_Kind kind, fmtkind;
-    unicode_writer_t writer;
+    _PyUnicodeWriter writer;
     Py_ssize_t sublen;
     Py_UCS4 maxchar;
 
     fmtcnt = PyUnicode_GET_LENGTH(uformat);
     fmtpos = 0;
 
-    if (unicode_writer_init(&writer, fmtcnt + 100, 127) < 0)
+    if (_PyUnicodeWriter_Init(&writer, fmtcnt + 100, 127) < 0)
         goto onError;
 
     if (PyTuple_Check(args)) {
             sublen = fmtpos - nonfmtpos;
             maxchar = _PyUnicode_FindMaxChar(uformat,
                                              nonfmtpos, nonfmtpos + sublen);
-            if (unicode_writer_prepare(&writer, sublen, maxchar) == -1)
+            if (_PyUnicodeWriter_Prepare(&writer, sublen, maxchar) == -1)
                 goto onError;
 
             copy_characters(writer.buffer, writer.pos,
             }
 
             if (c == '%') {
-                if (unicode_writer_prepare(&writer, 1, '%') == -1)
+                if (_PyUnicodeWriter_Prepare(&writer, 1, '%') == -1)
                     goto onError;
                 PyUnicode_WRITE(writer.kind, writer.data, writer.pos, '%');
                 writer.pos += 1;
             if (sign && len == width)
                 buflen++;
 
-            if (unicode_writer_prepare(&writer, buflen, bufmaxchar) == -1)
+            if (_PyUnicodeWriter_Prepare(&writer, buflen, bufmaxchar) == -1)
                 goto onError;
 
             /* Write characters */
     Py_DECREF(uformat);
     Py_XDECREF(temp);
     Py_XDECREF(second);
-    return unicode_writer_finish(&writer);
+    return _PyUnicodeWriter_Finish(&writer);
 
   onError:
     Py_DECREF(uformat);
     Py_XDECREF(temp);
     Py_XDECREF(second);
-    unicode_writer_dealloc(&writer);
+    _PyUnicodeWriter_Dealloc(&writer);
     if (args_owned) {
         Py_DECREF(args);
     }