Objects/stringlib/transmogrify.h

   1 /* NOTE: this API is -ONLY- for use with single byte character strings. */
   2 /* Do not use it with Unicode. */
   3
   4 #include "bytes_methods.h"
   5
   6 #ifndef STRINGLIB_MUTABLE
   7 #warning "STRINGLIB_MUTABLE not defined before #include, assuming 0"
   8 #define STRINGLIB_MUTABLE 0
   9 #endif
  10
  11 /* the more complicated methods.  parts of these should be pulled out into the
  12    shared code in bytes_methods.c to cut down on duplicate code bloat.  */
  13
  14 PyDoc_STRVAR(expandtabs__doc__,
  15 "B.expandtabs([tabsize]) -> copy of B\n\
  16 \n\
  17 Return a copy of B where all tab characters are expanded using spaces.\n\
  18 If tabsize is not given, a tab size of 8 characters is assumed.");
  19
  20 static PyObject*
  21 stringlib_expandtabs(PyObject *self, PyObject *args)
  22 {
  23     const char *e, *p;
  24     char *q;
  25     Py_ssize_t i, j, old_j;
  26     PyObject *u;
  27     int tabsize = 8;
  28
  29     if (!PyArg_ParseTuple(args, "|i:expandtabs", &tabsize))
  30         return NULL;
  31
  32     /* First pass: determine size of output string */
  33     i = j = old_j = 0;
  34     e = STRINGLIB_STR(self) + STRINGLIB_LEN(self);
  35     for (p = STRINGLIB_STR(self); p < e; p++)
  36         if (*p == '\t') {
  37             if (tabsize > 0) {
  38                 j += tabsize - (j % tabsize);
  39                 /* XXX: this depends on a signed integer overflow to < 0 */
  40                 /* C compilers, including gcc, do -NOT- guarantee this. */
  41                 if (old_j > j) {
  42                     PyErr_SetString(PyExc_OverflowError,
  43                                     "result is too long");
  44                     return NULL;
  45                 }
  46                 old_j = j;
  47             }
  48         }
  49         else {
  50             j++;
  51             if (*p == '\n' || *p == '\r') {
  52                 i += j;
  53                 old_j = j = 0;
  54                 /* XXX: this depends on a signed integer overflow to < 0 */
  55                 /* C compilers, including gcc, do -NOT- guarantee this. */
  56                 if (i < 0) {
  57                     PyErr_SetString(PyExc_OverflowError,
  58                                     "result is too long");
  59                     return NULL;
  60                 }
  61             }
  62         }
  63
  64     if ((i + j) < 0) {
  65         /* XXX: this depends on a signed integer overflow to < 0 */
  66         /* C compilers, including gcc, do -NOT- guarantee this. */
  67         PyErr_SetString(PyExc_OverflowError, "result is too long");
  68         return NULL;
  69     }
  70
  71     /* Second pass: create output string and fill it */
  72     u = STRINGLIB_NEW(NULL, i + j);
  73     if (!u)
  74         return NULL;
  75
  76     j = 0;
  77     q = STRINGLIB_STR(u);
  78
  79     for (p = STRINGLIB_STR(self); p < e; p++)
  80         if (*p == '\t') {
  81             if (tabsize > 0) {
  82                 i = tabsize - (j % tabsize);
  83                 j += i;
  84                 while (i--)
  85                     *q++ = ' ';
  86             }
  87         }
  88         else {
  89             j++;
  90             *q++ = *p;
  91             if (*p == '\n' || *p == '\r')
  92                 j = 0;
  93         }
  94
  95     return u;
  96 }
  97
  98 Py_LOCAL_INLINE(PyObject *)
  99 pad(PyObject *self, Py_ssize_t left, Py_ssize_t right, char fill)
 100 {
 101     PyObject *u;
 102
 103     if (left < 0)
 104         left = 0;
 105     if (right < 0)
 106         right = 0;
 107
 108     if (left == 0 && right == 0 && STRINGLIB_CHECK_EXACT(self)) {
 109 #if STRINGLIB_MUTABLE
 110         /* We're defined as returning a copy;  If the object is mutable
 111          * that means we must make an identical copy. */
 112         return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));
 113 #else
 114         Py_INCREF(self);
 115         return (PyObject *)self;
 116 #endif /* STRINGLIB_MUTABLE */
 117     }
 118
 119     u = STRINGLIB_NEW(NULL,
 120                                    left + STRINGLIB_LEN(self) + right);
 121     if (u) {
 122         if (left)
 123             memset(STRINGLIB_STR(u), fill, left);
 124         Py_MEMCPY(STRINGLIB_STR(u) + left,
 125                STRINGLIB_STR(self),
 126                STRINGLIB_LEN(self));
 127         if (right)
 128             memset(STRINGLIB_STR(u) + left + STRINGLIB_LEN(self),
 129                    fill, right);
 130     }
 131
 132     return u;
 133 }
 134
 135 PyDoc_STRVAR(ljust__doc__,
 136 "B.ljust(width[, fillchar]) -> copy of B\n"
 137 "\n"
 138 "Return B left justified in a string of length width. Padding is\n"
 139 "done using the specified fill character (default is a space).");
 140
 141 static PyObject *
 142 stringlib_ljust(PyObject *self, PyObject *args)
 143 {
 144     Py_ssize_t width;
 145     char fillchar = ' ';
 146
 147     if (!PyArg_ParseTuple(args, "n|c:ljust", &width, &fillchar))
 148         return NULL;
 149
 150     if (STRINGLIB_LEN(self) >= width && STRINGLIB_CHECK_EXACT(self)) {
 151 #if STRINGLIB_MUTABLE
 152         /* We're defined as returning a copy;  If the object is mutable
 153          * that means we must make an identical copy. */
 154         return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));
 155 #else
 156         Py_INCREF(self);
 157         return (PyObject*) self;
 158 #endif
 159     }
 160
 161     return pad(self, 0, width - STRINGLIB_LEN(self), fillchar);
 162 }
 163
 164
 165 PyDoc_STRVAR(rjust__doc__,
 166 "B.rjust(width[, fillchar]) -> copy of B\n"
 167 "\n"
 168 "Return B right justified in a string of length width. Padding is\n"
 169 "done using the specified fill character (default is a space)");
 170
 171 static PyObject *
 172 stringlib_rjust(PyObject *self, PyObject *args)
 173 {
 174     Py_ssize_t width;
 175     char fillchar = ' ';
 176
 177     if (!PyArg_ParseTuple(args, "n|c:rjust", &width, &fillchar))
 178         return NULL;
 179
 180     if (STRINGLIB_LEN(self) >= width && STRINGLIB_CHECK_EXACT(self)) {
 181 #if STRINGLIB_MUTABLE
 182         /* We're defined as returning a copy;  If the object is mutable
 183          * that means we must make an identical copy. */
 184         return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));
 185 #else
 186         Py_INCREF(self);
 187         return (PyObject*) self;
 188 #endif
 189     }
 190
 191     return pad(self, width - STRINGLIB_LEN(self), 0, fillchar);
 192 }
 193
 194
 195 PyDoc_STRVAR(center__doc__,
 196 "B.center(width[, fillchar]) -> copy of B\n"
 197 "\n"
 198 "Return B centered in a string of length width.  Padding is\n"
 199 "done using the specified fill character (default is a space).");
 200
 201 static PyObject *
 202 stringlib_center(PyObject *self, PyObject *args)
 203 {
 204     Py_ssize_t marg, left;
 205     Py_ssize_t width;
 206     char fillchar = ' ';
 207
 208     if (!PyArg_ParseTuple(args, "n|c:center", &width, &fillchar))
 209         return NULL;
 210
 211     if (STRINGLIB_LEN(self) >= width && STRINGLIB_CHECK_EXACT(self)) {
 212 #if STRINGLIB_MUTABLE
 213         /* We're defined as returning a copy;  If the object is mutable
 214          * that means we must make an identical copy. */
 215         return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));
 216 #else
 217         Py_INCREF(self);
 218         return (PyObject*) self;
 219 #endif
 220     }
 221
 222     marg = width - STRINGLIB_LEN(self);
 223     left = marg / 2 + (marg & width & 1);
 224
 225     return pad(self, left, marg - left, fillchar);
 226 }
 227
 228 PyDoc_STRVAR(zfill__doc__,
 229 "B.zfill(width) -> copy of B\n"
 230 "\n"
 231 "Pad a numeric string B with zeros on the left, to fill a field\n"
 232 "of the specified width.  B is never truncated.");
 233
 234 static PyObject *
 235 stringlib_zfill(PyObject *self, PyObject *args)
 236 {
 237     Py_ssize_t fill;
 238     PyObject *s;
 239     char *p;
 240     Py_ssize_t width;
 241
 242     if (!PyArg_ParseTuple(args, "n:zfill", &width))
 243         return NULL;
 244
 245     if (STRINGLIB_LEN(self) >= width) {
 246         if (STRINGLIB_CHECK_EXACT(self)) {
 247 #if STRINGLIB_MUTABLE
 248             /* We're defined as returning a copy;  If the object is mutable
 249              * that means we must make an identical copy. */
 250             return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));
 251 #else
 252             Py_INCREF(self);
 253             return (PyObject*) self;
 254 #endif
 255         }
 256         else
 257             return STRINGLIB_NEW(
 258                 STRINGLIB_STR(self),
 259                 STRINGLIB_LEN(self)
 260             );
 261     }
 262
 263     fill = width - STRINGLIB_LEN(self);
 264
 265     s = pad(self, fill, 0, '0');
 266
 267     if (s == NULL)
 268         return NULL;
 269
 270     p = STRINGLIB_STR(s);
 271     if (p[fill] == '+' || p[fill] == '-') {
 272         /* move sign to beginning of string */
 273         p[0] = p[fill];
 274         p[fill] = '0';
 275     }
 276
 277     return (PyObject*) s;
 278 }
 279
 280
 281 #define _STRINGLIB_SPLIT_APPEND(data, left, right)              \
 282         str = STRINGLIB_NEW((data) + (left),                    \
 283                                          (right) - (left));     \
 284         if (str == NULL)                                        \
 285                 goto onError;                                   \
 286         if (PyList_Append(list, str)) {                         \
 287                 Py_DECREF(str);                                 \
 288                 goto onError;                                   \
 289         }                                                       \
 290         else                                                    \
 291                 Py_DECREF(str);
 292
 293 PyDoc_STRVAR(splitlines__doc__,
 294 "B.splitlines([keepends]) -> list of lines\n\
 295 \n\
 296 Return a list of the lines in B, breaking at line boundaries.\n\
 297 Line breaks are not included in the resulting list unless keepends\n\
 298 is given and true.");
 299
 300 static PyObject*
 301 stringlib_splitlines(PyObject *self, PyObject *args)
 302 {
 303     register Py_ssize_t i;
 304     register Py_ssize_t j;
 305     Py_ssize_t len;
 306     int keepends = 0;
 307     PyObject *list;
 308     PyObject *str;
 309     char *data;
 310
 311     if (!PyArg_ParseTuple(args, "|i:splitlines", &keepends))
 312         return NULL;
 313
 314     data = STRINGLIB_STR(self);
 315     len = STRINGLIB_LEN(self);
 316
 317     /* This does not use the preallocated list because splitlines is
 318        usually run with hundreds of newlines.  The overhead of
 319        switching between PyList_SET_ITEM and append causes about a
 320        2-3% slowdown for that common case.  A smarter implementation
 321        could move the if check out, so the SET_ITEMs are done first
 322        and the appends only done when the prealloc buffer is full.
 323        That's too much work for little gain.*/
 324
 325     list = PyList_New(0);
 326     if (!list)
 327         goto onError;
 328
 329     for (i = j = 0; i < len; ) {
 330         Py_ssize_t eol;
 331
 332         /* Find a line and append it */
 333         while (i < len && data[i] != '\n' && data[i] != '\r')
 334             i++;
 335
 336         /* Skip the line break reading CRLF as one line break */
 337         eol = i;
 338         if (i < len) {
 339             if (data[i] == '\r' && i + 1 < len &&
 340                 data[i+1] == '\n')
 341                 i += 2;
 342             else
 343                 i++;
 344             if (keepends)
 345                 eol = i;
 346         }
 347         _STRINGLIB_SPLIT_APPEND(data, j, eol);
 348         j = i;
 349     }
 350     if (j < len) {
 351         _STRINGLIB_SPLIT_APPEND(data, j, len);
 352     }
 353
 354     return list;
 355
 356  onError:
 357     Py_XDECREF(list);
 358     return NULL;
 359 }
 360
 361 #undef _STRINGLIB_SPLIT_APPEND
 362