AppPkg/Applications/Python/Python-2.7.10/Objects/bytes_methods.c

   1 #include "Python.h"
   2 #include "bytes_methods.h"
   3
   4 PyDoc_STRVAR_shared(_Py_isspace__doc__,
   5 "B.isspace() -> bool\n\
   6 \n\
   7 Return True if all characters in B are whitespace\n\
   8 and there is at least one character in B, False otherwise.");
   9
  10 PyObject*
  11 _Py_bytes_isspace(const char *cptr, Py_ssize_t len)
  12 {
  13     register const unsigned char *p
  14         = (unsigned char *) cptr;
  15     register const unsigned char *e;
  16
  17     /* Shortcut for single character strings */
  18     if (len == 1 && Py_ISSPACE(*p))
  19         Py_RETURN_TRUE;
  20
  21     /* Special case for empty strings */
  22     if (len == 0)
  23         Py_RETURN_FALSE;
  24
  25     e = p + len;
  26     for (; p < e; p++) {
  27         if (!Py_ISSPACE(*p))
  28             Py_RETURN_FALSE;
  29     }
  30     Py_RETURN_TRUE;
  31 }
  32
  33
  34 PyDoc_STRVAR_shared(_Py_isalpha__doc__,
  35 "B.isalpha() -> bool\n\
  36 \n\
  37 Return True if all characters in B are alphabetic\n\
  38 and there is at least one character in B, False otherwise.");
  39
  40 PyObject*
  41 _Py_bytes_isalpha(const char *cptr, Py_ssize_t len)
  42 {
  43     register const unsigned char *p
  44         = (unsigned char *) cptr;
  45     register const unsigned char *e;
  46
  47     /* Shortcut for single character strings */
  48     if (len == 1 && Py_ISALPHA(*p))
  49         Py_RETURN_TRUE;
  50
  51     /* Special case for empty strings */
  52     if (len == 0)
  53         Py_RETURN_FALSE;
  54
  55     e = p + len;
  56     for (; p < e; p++) {
  57         if (!Py_ISALPHA(*p))
  58             Py_RETURN_FALSE;
  59     }
  60     Py_RETURN_TRUE;
  61 }
  62
  63
  64 PyDoc_STRVAR_shared(_Py_isalnum__doc__,
  65 "B.isalnum() -> bool\n\
  66 \n\
  67 Return True if all characters in B are alphanumeric\n\
  68 and there is at least one character in B, False otherwise.");
  69
  70 PyObject*
  71 _Py_bytes_isalnum(const char *cptr, Py_ssize_t len)
  72 {
  73     register const unsigned char *p
  74         = (unsigned char *) cptr;
  75     register const unsigned char *e;
  76
  77     /* Shortcut for single character strings */
  78     if (len == 1 && Py_ISALNUM(*p))
  79         Py_RETURN_TRUE;
  80
  81     /* Special case for empty strings */
  82     if (len == 0)
  83         Py_RETURN_FALSE;
  84
  85     e = p + len;
  86     for (; p < e; p++) {
  87         if (!Py_ISALNUM(*p))
  88             Py_RETURN_FALSE;
  89     }
  90     Py_RETURN_TRUE;
  91 }
  92
  93
  94 PyDoc_STRVAR_shared(_Py_isdigit__doc__,
  95 "B.isdigit() -> bool\n\
  96 \n\
  97 Return True if all characters in B are digits\n\
  98 and there is at least one character in B, False otherwise.");
  99
 100 PyObject*
 101 _Py_bytes_isdigit(const char *cptr, Py_ssize_t len)
 102 {
 103     register const unsigned char *p
 104         = (unsigned char *) cptr;
 105     register const unsigned char *e;
 106
 107     /* Shortcut for single character strings */
 108     if (len == 1 && Py_ISDIGIT(*p))
 109         Py_RETURN_TRUE;
 110
 111     /* Special case for empty strings */
 112     if (len == 0)
 113         Py_RETURN_FALSE;
 114
 115     e = p + len;
 116     for (; p < e; p++) {
 117         if (!Py_ISDIGIT(*p))
 118             Py_RETURN_FALSE;
 119     }
 120     Py_RETURN_TRUE;
 121 }
 122
 123
 124 PyDoc_STRVAR_shared(_Py_islower__doc__,
 125 "B.islower() -> bool\n\
 126 \n\
 127 Return True if all cased characters in B are lowercase and there is\n\
 128 at least one cased character in B, False otherwise.");
 129
 130 PyObject*
 131 _Py_bytes_islower(const char *cptr, Py_ssize_t len)
 132 {
 133     register const unsigned char *p
 134         = (unsigned char *) cptr;
 135     register const unsigned char *e;
 136     int cased;
 137
 138     /* Shortcut for single character strings */
 139     if (len == 1)
 140         return PyBool_FromLong(Py_ISLOWER(*p));
 141
 142     /* Special case for empty strings */
 143     if (len == 0)
 144         Py_RETURN_FALSE;
 145
 146     e = p + len;
 147     cased = 0;
 148     for (; p < e; p++) {
 149         if (Py_ISUPPER(*p))
 150             Py_RETURN_FALSE;
 151         else if (!cased && Py_ISLOWER(*p))
 152             cased = 1;
 153     }
 154     return PyBool_FromLong(cased);
 155 }
 156
 157
 158 PyDoc_STRVAR_shared(_Py_isupper__doc__,
 159 "B.isupper() -> bool\n\
 160 \n\
 161 Return True if all cased characters in B are uppercase and there is\n\
 162 at least one cased character in B, False otherwise.");
 163
 164 PyObject*
 165 _Py_bytes_isupper(const char *cptr, Py_ssize_t len)
 166 {
 167     register const unsigned char *p
 168         = (unsigned char *) cptr;
 169     register const unsigned char *e;
 170     int cased;
 171
 172     /* Shortcut for single character strings */
 173     if (len == 1)
 174         return PyBool_FromLong(Py_ISUPPER(*p));
 175
 176     /* Special case for empty strings */
 177     if (len == 0)
 178         Py_RETURN_FALSE;
 179
 180     e = p + len;
 181     cased = 0;
 182     for (; p < e; p++) {
 183         if (Py_ISLOWER(*p))
 184             Py_RETURN_FALSE;
 185         else if (!cased && Py_ISUPPER(*p))
 186             cased = 1;
 187     }
 188     return PyBool_FromLong(cased);
 189 }
 190
 191
 192 PyDoc_STRVAR_shared(_Py_istitle__doc__,
 193 "B.istitle() -> bool\n\
 194 \n\
 195 Return True if B is a titlecased string and there is at least one\n\
 196 character in B, i.e. uppercase characters may only follow uncased\n\
 197 characters and lowercase characters only cased ones. Return False\n\
 198 otherwise.");
 199
 200 PyObject*
 201 _Py_bytes_istitle(const char *cptr, Py_ssize_t len)
 202 {
 203     register const unsigned char *p
 204         = (unsigned char *) cptr;
 205     register const unsigned char *e;
 206     int cased, previous_is_cased;
 207
 208     /* Shortcut for single character strings */
 209     if (len == 1)
 210         return PyBool_FromLong(Py_ISUPPER(*p));
 211
 212     /* Special case for empty strings */
 213     if (len == 0)
 214         Py_RETURN_FALSE;
 215
 216     e = p + len;
 217     cased = 0;
 218     previous_is_cased = 0;
 219     for (; p < e; p++) {
 220         register const unsigned char ch = *p;
 221
 222         if (Py_ISUPPER(ch)) {
 223             if (previous_is_cased)
 224                 Py_RETURN_FALSE;
 225             previous_is_cased = 1;
 226             cased = 1;
 227         }
 228         else if (Py_ISLOWER(ch)) {
 229             if (!previous_is_cased)
 230                 Py_RETURN_FALSE;
 231             previous_is_cased = 1;
 232             cased = 1;
 233         }
 234         else
 235             previous_is_cased = 0;
 236     }
 237     return PyBool_FromLong(cased);
 238 }
 239
 240
 241 PyDoc_STRVAR_shared(_Py_lower__doc__,
 242 "B.lower() -> copy of B\n\
 243 \n\
 244 Return a copy of B with all ASCII characters converted to lowercase.");
 245
 246 void
 247 _Py_bytes_lower(char *result, const char *cptr, Py_ssize_t len)
 248 {
 249         Py_ssize_t i;
 250
 251         /*
 252         newobj = PyString_FromStringAndSize(NULL, len);
 253         if (!newobj)
 254                 return NULL;
 255
 256         s = PyString_AS_STRING(newobj);
 257         */
 258
 259         Py_MEMCPY(result, cptr, len);
 260
 261         for (i = 0; i < len; i++) {
 262                 int c = Py_CHARMASK(result[i]);
 263                 if (Py_ISUPPER(c))
 264                         result[i] = Py_TOLOWER(c);
 265         }
 266 }
 267
 268
 269 PyDoc_STRVAR_shared(_Py_upper__doc__,
 270 "B.upper() -> copy of B\n\
 271 \n\
 272 Return a copy of B with all ASCII characters converted to uppercase.");
 273
 274 void
 275 _Py_bytes_upper(char *result, const char *cptr, Py_ssize_t len)
 276 {
 277         Py_ssize_t i;
 278
 279         /*
 280         newobj = PyString_FromStringAndSize(NULL, len);
 281         if (!newobj)
 282                 return NULL;
 283
 284         s = PyString_AS_STRING(newobj);
 285         */
 286
 287         Py_MEMCPY(result, cptr, len);
 288
 289         for (i = 0; i < len; i++) {
 290                 int c = Py_CHARMASK(result[i]);
 291                 if (Py_ISLOWER(c))
 292                         result[i] = Py_TOUPPER(c);
 293         }
 294 }
 295
 296
 297 PyDoc_STRVAR_shared(_Py_title__doc__,
 298 "B.title() -> copy of B\n\
 299 \n\
 300 Return a titlecased version of B, i.e. ASCII words start with uppercase\n\
 301 characters, all remaining cased characters have lowercase.");
 302
 303 void
 304 _Py_bytes_title(char *result, char *s, Py_ssize_t len)
 305 {
 306         Py_ssize_t i;
 307         int previous_is_cased = 0;
 308
 309         /*
 310         newobj = PyString_FromStringAndSize(NULL, len);
 311         if (newobj == NULL)
 312                 return NULL;
 313         s_new = PyString_AsString(newobj);
 314         */
 315         for (i = 0; i < len; i++) {
 316                 int c = Py_CHARMASK(*s++);
 317                 if (Py_ISLOWER(c)) {
 318                         if (!previous_is_cased)
 319                             c = Py_TOUPPER(c);
 320                         previous_is_cased = 1;
 321                 } else if (Py_ISUPPER(c)) {
 322                         if (previous_is_cased)
 323                             c = Py_TOLOWER(c);
 324                         previous_is_cased = 1;
 325                 } else
 326                         previous_is_cased = 0;
 327                 *result++ = c;
 328         }
 329 }
 330
 331
 332 PyDoc_STRVAR_shared(_Py_capitalize__doc__,
 333 "B.capitalize() -> copy of B\n\
 334 \n\
 335 Return a copy of B with only its first character capitalized (ASCII)\n\
 336 and the rest lower-cased.");
 337
 338 void
 339 _Py_bytes_capitalize(char *result, char *s, Py_ssize_t len)
 340 {
 341         Py_ssize_t i;
 342
 343         /*
 344         newobj = PyString_FromStringAndSize(NULL, len);
 345         if (newobj == NULL)
 346                 return NULL;
 347         s_new = PyString_AsString(newobj);
 348         */
 349         if (0 < len) {
 350                 int c = Py_CHARMASK(*s++);
 351                 if (Py_ISLOWER(c))
 352                         *result = Py_TOUPPER(c);
 353                 else
 354                         *result = c;
 355                 result++;
 356         }
 357         for (i = 1; i < len; i++) {
 358                 int c = Py_CHARMASK(*s++);
 359                 if (Py_ISUPPER(c))
 360                         *result = Py_TOLOWER(c);
 361                 else
 362                         *result = c;
 363                 result++;
 364         }
 365 }
 366
 367
 368 PyDoc_STRVAR_shared(_Py_swapcase__doc__,
 369 "B.swapcase() -> copy of B\n\
 370 \n\
 371 Return a copy of B with uppercase ASCII characters converted\n\
 372 to lowercase ASCII and vice versa.");
 373
 374 void
 375 _Py_bytes_swapcase(char *result, char *s, Py_ssize_t len)
 376 {
 377         Py_ssize_t i;
 378
 379         /*
 380         newobj = PyString_FromStringAndSize(NULL, len);
 381         if (newobj == NULL)
 382                 return NULL;
 383         s_new = PyString_AsString(newobj);
 384         */
 385         for (i = 0; i < len; i++) {
 386                 int c = Py_CHARMASK(*s++);
 387                 if (Py_ISLOWER(c)) {
 388                         *result = Py_TOUPPER(c);
 389                 }
 390                 else if (Py_ISUPPER(c)) {
 391                         *result = Py_TOLOWER(c);
 392                 }
 393                 else
 394                         *result = c;
 395                 result++;
 396         }
 397 }
 398