Back to index

python3.2  3.2.2
Classes | Defines | Functions | Variables
bytearrayobject.c File Reference
#include "Python.h"
#include "structmember.h"
#include "bytes_methods.h"
#include "stringlib/fastsearch.h"
#include "stringlib/count.h"
#include "stringlib/find.h"
#include "stringlib/partition.h"
#include "stringlib/split.h"
#include "stringlib/ctype.h"
#include "stringlib/transmogrify.h"

Go to the source code of this file.

Classes

struct  bytesiterobject

Defines

#define PY_SSIZE_T_CLEAN
#define STRINGLIB_CHAR   char
#define STRINGLIB_LEN   PyByteArray_GET_SIZE
#define STRINGLIB_STR   PyByteArray_AS_STRING
#define STRINGLIB_NEW   PyByteArray_FromStringAndSize
#define STRINGLIB_ISSPACE   Py_ISSPACE
#define STRINGLIB_ISLINEBREAK(x)   ((x == '\n') || (x == '\r'))
#define STRINGLIB_CHECK_EXACT   PyByteArray_CheckExact
#define STRINGLIB_MUTABLE   1
#define ADJUST_INDICES(start, end, len)
#define findchar(target, target_len, c)   ((char *)memchr((const void *)(target), c, target_len))

Functions

void PyByteArray_Fini (void)
int PyByteArray_Init (void)
static int _getbytevalue (PyObject *arg, int *value)
static int bytearray_getbuffer (PyByteArrayObject *obj, Py_buffer *view, int flags)
static void bytearray_releasebuffer (PyByteArrayObject *obj, Py_buffer *view)
static Py_ssize_t _getbuffer (PyObject *obj, Py_buffer *view)
static int _canresize (PyByteArrayObject *self)
PyObjectPyByteArray_FromObject (PyObject *input)
PyObjectPyByteArray_FromStringAndSize (const char *bytes, Py_ssize_t size)
Py_ssize_t PyByteArray_Size (PyObject *self)
char * PyByteArray_AsString (PyObject *self)
int PyByteArray_Resize (PyObject *self, Py_ssize_t size)
PyObjectPyByteArray_Concat (PyObject *a, PyObject *b)
static Py_ssize_t bytearray_length (PyByteArrayObject *self)
static PyObjectbytearray_iconcat (PyByteArrayObject *self, PyObject *other)
static PyObjectbytearray_repeat (PyByteArrayObject *self, Py_ssize_t count)
static PyObjectbytearray_irepeat (PyByteArrayObject *self, Py_ssize_t count)
static PyObjectbytearray_getitem (PyByteArrayObject *self, Py_ssize_t i)
static PyObjectbytearray_subscript (PyByteArrayObject *self, PyObject *index)
static int bytearray_setslice (PyByteArrayObject *self, Py_ssize_t lo, Py_ssize_t hi, PyObject *values)
static int bytearray_setitem (PyByteArrayObject *self, Py_ssize_t i, PyObject *value)
static int bytearray_ass_subscript (PyByteArrayObject *self, PyObject *index, PyObject *values)
static int bytearray_init (PyByteArrayObject *self, PyObject *args, PyObject *kwds)
static PyObjectbytearray_repr (PyByteArrayObject *self)
static PyObjectbytearray_str (PyObject *op)
static PyObjectbytearray_richcompare (PyObject *self, PyObject *other, int op)
static void bytearray_dealloc (PyByteArrayObject *self)
 Py_LOCAL_INLINE (Py_ssize_t)
 PyDoc_STRVAR (find__doc__,"B.find(sub[, start[, end]]) -> int\n\ \n\ Return the lowest index in B where subsection sub is found,\n\ such that sub is contained within B[start,end]. Optional\n\ arguments start and end are interpreted as in slice notation.\n\ \n\ Return -1 on failure.")
static PyObjectbytearray_find (PyByteArrayObject *self, PyObject *args)
 PyDoc_STRVAR (count__doc__,"B.count(sub[, start[, end]]) -> int\n\ \n\ Return the number of non-overlapping occurrences of subsection sub in\n\ bytes B[start:end]. Optional arguments start and end are interpreted\n\ as in slice notation.")
static PyObjectbytearray_count (PyByteArrayObject *self, PyObject *args)
 PyDoc_STRVAR (index__doc__,"B.index(sub[, start[, end]]) -> int\n\ \n\ Like B.find() but raise ValueError when the subsection is not found.")
static PyObjectbytearray_index (PyByteArrayObject *self, PyObject *args)
 PyDoc_STRVAR (rfind__doc__,"B.rfind(sub[, start[, end]]) -> int\n\ \n\ Return the highest index in B where subsection sub is found,\n\ such that sub is contained within B[start,end]. Optional\n\ arguments start and end are interpreted as in slice notation.\n\ \n\ Return -1 on failure.")
static PyObjectbytearray_rfind (PyByteArrayObject *self, PyObject *args)
 PyDoc_STRVAR (rindex__doc__,"B.rindex(sub[, start[, end]]) -> int\n\ \n\ Like B.rfind() but raise ValueError when the subsection is not found.")
static PyObjectbytearray_rindex (PyByteArrayObject *self, PyObject *args)
static int bytearray_contains (PyObject *self, PyObject *arg)
 Py_LOCAL (int)
 PyDoc_STRVAR (startswith__doc__,"B.startswith(prefix[, start[, end]]) -> bool\n\ \n\ Return True if B starts with the specified prefix, False otherwise.\n\ With optional start, test B beginning at that position.\n\ With optional end, stop comparing B at that position.\n\ prefix can also be a tuple of bytes to try.")
static PyObjectbytearray_startswith (PyByteArrayObject *self, PyObject *args)
 PyDoc_STRVAR (endswith__doc__,"B.endswith(suffix[, start[, end]]) -> bool\n\ \n\ Return True if B ends with the specified suffix, False otherwise.\n\ With optional start, test B beginning at that position.\n\ With optional end, stop comparing B at that position.\n\ suffix can also be a tuple of bytes to try.")
static PyObjectbytearray_endswith (PyByteArrayObject *self, PyObject *args)
 PyDoc_STRVAR (translate__doc__,"B.translate(table[, deletechars]) -> bytearray\n\ \n\ Return a copy of B, where all characters occurring in the\n\ optional argument deletechars are removed, and the remaining\n\ characters have been mapped through the given translation\n\ table, which must be a bytes object of length 256.")
static PyObjectbytearray_translate (PyByteArrayObject *self, PyObject *args)
static PyObjectbytearray_maketrans (PyObject *null, PyObject *args)
 Py_LOCAL (PyByteArrayObject *)
 PyDoc_STRVAR (replace__doc__,"B.replace(old, new[, count]) -> bytearray\n\ \n\ Return a copy of B with all occurrences of subsection\n\ old replaced by new. If the optional argument count is\n\ given, only the first count occurrences are replaced.")
static PyObjectbytearray_replace (PyByteArrayObject *self, PyObject *args)
 PyDoc_STRVAR (split__doc__,"B.split([sep[, maxsplit]]) -> list of bytearrays\n\ \n\ Return a list of the sections in B, using sep as the delimiter.\n\ If sep is not given, B is split on ASCII whitespace characters\n\ (space, tab, return, newline, formfeed, vertical tab).\n\ If maxsplit is given, at most maxsplit splits are done.")
static PyObjectbytearray_split (PyByteArrayObject *self, PyObject *args)
 PyDoc_STRVAR (partition__doc__,"B.partition(sep) -> (head, sep, tail)\n\ \n\ Search for the separator sep in B, and return the part before it,\n\ the separator itself, and the part after it. If the separator is not\n\ found, returns B and two empty bytearray objects.")
static PyObjectbytearray_partition (PyByteArrayObject *self, PyObject *sep_obj)
 PyDoc_STRVAR (rpartition__doc__,"B.rpartition(sep) -> (head, sep, tail)\n\ \n\ Search for the separator sep in B, starting at the end of B,\n\ and return the part before it, the separator itself, and the\n\ part after it. If the separator is not found, returns two empty\n\ bytearray objects and B.")
static PyObjectbytearray_rpartition (PyByteArrayObject *self, PyObject *sep_obj)
 PyDoc_STRVAR (rsplit__doc__,"B.rsplit(sep[, maxsplit]) -> list of bytearrays\n\ \n\ Return a list of the sections in B, using sep as the delimiter,\n\ starting at the end of B and working to the front.\n\ If sep is not given, B is split on ASCII whitespace characters\n\ (space, tab, return, newline, formfeed, vertical tab).\n\ If maxsplit is given, at most maxsplit splits are done.")
static PyObjectbytearray_rsplit (PyByteArrayObject *self, PyObject *args)
 PyDoc_STRVAR (reverse__doc__,"B.reverse() -> None\n\ \n\ Reverse the order of the values in B in place.")
static PyObjectbytearray_reverse (PyByteArrayObject *self, PyObject *unused)
 PyDoc_STRVAR (insert__doc__,"B.insert(index, int) -> None\n\ \n\ Insert a single item into the bytearray before the given index.")
static PyObjectbytearray_insert (PyByteArrayObject *self, PyObject *args)
 PyDoc_STRVAR (append__doc__,"B.append(int) -> None\n\ \n\ Append a single item to the end of B.")
static PyObjectbytearray_append (PyByteArrayObject *self, PyObject *arg)
 PyDoc_STRVAR (extend__doc__,"B.extend(iterable_of_ints) -> None\n\ \n\ Append all the elements from the iterator or sequence to the\n\ end of B.")
static PyObjectbytearray_extend (PyByteArrayObject *self, PyObject *arg)
 PyDoc_STRVAR (pop__doc__,"B.pop([index]) -> int\n\ \n\ Remove and return a single item from B. If no index\n\ argument is given, will pop the last value.")
static PyObjectbytearray_pop (PyByteArrayObject *self, PyObject *args)
 PyDoc_STRVAR (remove__doc__,"B.remove(int) -> None\n\ \n\ Remove the first occurrence of a value in B.")
static PyObjectbytearray_remove (PyByteArrayObject *self, PyObject *arg)
static Py_ssize_t lstrip_helper (unsigned char *myptr, Py_ssize_t mysize, void *argptr, Py_ssize_t argsize)
static Py_ssize_t rstrip_helper (unsigned char *myptr, Py_ssize_t mysize, void *argptr, Py_ssize_t argsize)
 PyDoc_STRVAR (strip__doc__,"B.strip([bytes]) -> bytearray\n\ \n\ Strip leading and trailing bytes contained in the argument\n\ and return the result as a new bytearray.\n\ If the argument is omitted, strip ASCII whitespace.")
static PyObjectbytearray_strip (PyByteArrayObject *self, PyObject *args)
 PyDoc_STRVAR (lstrip__doc__,"B.lstrip([bytes]) -> bytearray\n\ \n\ Strip leading bytes contained in the argument\n\ and return the result as a new bytearray.\n\ If the argument is omitted, strip leading ASCII whitespace.")
static PyObjectbytearray_lstrip (PyByteArrayObject *self, PyObject *args)
 PyDoc_STRVAR (rstrip__doc__,"B.rstrip([bytes]) -> bytearray\n\ \n\ Strip trailing bytes contained in the argument\n\ and return the result as a new bytearray.\n\ If the argument is omitted, strip trailing ASCII whitespace.")
static PyObjectbytearray_rstrip (PyByteArrayObject *self, PyObject *args)
 PyDoc_STRVAR (decode_doc,"B.decode(encoding='utf-8', errors='strict') -> str\n\ \n\ Decode B using the codec registered for encoding. Default encoding\n\ is 'utf-8'. errors may be given to set a different error\n\ handling scheme. Default is 'strict' meaning that encoding errors raise\n\ a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'\n\ as well as any other name registered with codecs.register_error that is\n\ able to handle UnicodeDecodeErrors.")
static PyObjectbytearray_decode (PyObject *self, PyObject *args, PyObject *kwargs)
 PyDoc_STRVAR (alloc_doc,"B.__alloc__() -> int\n\ \n\ Return the number of bytes actually allocated.")
static PyObjectbytearray_alloc (PyByteArrayObject *self)
 PyDoc_STRVAR (join_doc,"B.join(iterable_of_bytes) -> bytearray\n\ \n\ Concatenate any number of bytes/bytearray objects, with B\n\ in between each pair, and return the result as a new bytearray.")
static PyObjectbytearray_join (PyByteArrayObject *self, PyObject *it)
 PyDoc_STRVAR (splitlines__doc__,"B.splitlines([keepends]) -> list of lines\n\ \n\ Return a list of the lines in B, breaking at line boundaries.\n\ Line breaks are not included in the resulting list unless keepends\n\ is given and true.")
static PyObjectbytearray_splitlines (PyObject *self, PyObject *args)
 PyDoc_STRVAR (fromhex_doc,"bytearray.fromhex(string) -> bytearray (static method)\n\ \n\ Create a bytearray object from a string of hexadecimal numbers.\n\ Spaces between two numbers are accepted.\n\ Example: bytearray.fromhex('B9 01EF') -> bytearray(b'\\xb9\\x01\\xef').")
static int hex_digit_to_int (Py_UNICODE c)
static PyObjectbytearray_fromhex (PyObject *cls, PyObject *args)
 PyDoc_STRVAR (reduce_doc,"Return state information for pickling.")
static PyObjectbytearray_reduce (PyByteArrayObject *self)
 PyDoc_STRVAR (sizeof_doc,"B.__sizeof__() -> int\n\ \n\ Returns the size of B in memory, in bytes")
static PyObjectbytearray_sizeof (PyByteArrayObject *self)
 PyDoc_STRVAR (bytearray_doc,"bytearray(iterable_of_ints) -> bytearray\n\ bytearray(string, encoding[, errors]) -> bytearray\n\ bytearray(bytes_or_bytearray) -> mutable copy of bytes_or_bytearray\n\ bytearray(memory_view) -> bytearray\n\ \n\ Construct an mutable bytearray object from:\n\ - an iterable yielding integers in range(256)\n\ - a text string encoded using the specified encoding\n\ - a bytes or a bytearray object\n\ - any object implementing the buffer API.\n\ \n\ bytearray(int) -> bytearray\n\ \n\ Construct a zero-initialized bytearray of the given length.")
static PyObjectbytearray_iter (PyObject *seq)
static void bytearrayiter_dealloc (bytesiterobject *it)
static int bytearrayiter_traverse (bytesiterobject *it, visitproc visit, void *arg)
static PyObjectbytearrayiter_next (bytesiterobject *it)
static PyObjectbytesarrayiter_length_hint (bytesiterobject *it)
 PyDoc_STRVAR (length_hint_doc,"Private method returning an estimate of len(list(it)).")

Variables

char _PyByteArray_empty_string [] = ""
static PySequenceMethods bytearray_as_sequence
static PyMappingMethods bytearray_as_mapping
static PyBufferProcs bytearray_as_buffer
static PyMethodDef bytearray_methods []
PyTypeObject PyByteArray_Type
static PyMethodDef bytearrayiter_methods []
PyTypeObject PyByteArrayIter_Type

Class Documentation

struct bytesiterobject

Definition at line 2860 of file bytearrayobject.c.

Collaboration diagram for bytesiterobject:
Class Members
PyObject_HEAD Py_ssize_t it_index
PyByteArrayObject * it_seq

Define Documentation

#define ADJUST_INDICES (   start,
  end,
  len 
)
Value:
if (end > len)                              \
        end = len;                              \
    else if (end < 0) {                         \
        end += len;                             \
        if (end < 0)                            \
            end = 0;                            \
    }                                           \
    if (start < 0) {                            \
        start += len;                           \
        if (start < 0)                          \
            start = 0;                          \
    }

Definition at line 1062 of file bytearrayobject.c.

#define findchar (   target,
  target_len,
  c 
)    ((char *)memchr((const void *)(target), c, target_len))

Definition at line 1472 of file bytearrayobject.c.

Definition at line 3 of file bytearrayobject.c.

#define STRINGLIB_CHAR   char

Definition at line 1040 of file bytearrayobject.c.

Definition at line 1046 of file bytearrayobject.c.

#define STRINGLIB_ISLINEBREAK (   x)    ((x == '\n') || (x == '\r'))

Definition at line 1045 of file bytearrayobject.c.

Definition at line 1044 of file bytearrayobject.c.

Definition at line 1041 of file bytearrayobject.c.

#define STRINGLIB_MUTABLE   1

Definition at line 1047 of file bytearrayobject.c.

Definition at line 1043 of file bytearrayobject.c.

Definition at line 1042 of file bytearrayobject.c.


Function Documentation

static int _canresize ( PyByteArrayObject self) [static]

Definition at line 96 of file bytearrayobject.c.

{
    if (self->ob_exports > 0) {
        PyErr_SetString(PyExc_BufferError,
                "Existing exports of data: object cannot be re-sized");
        return 0;
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Py_ssize_t _getbuffer ( PyObject obj,
Py_buffer view 
) [static]

Definition at line 78 of file bytearrayobject.c.

{
    PyBufferProcs *buffer = Py_TYPE(obj)->tp_as_buffer;

    if (buffer == NULL || buffer->bf_getbuffer == NULL)
    {
        PyErr_Format(PyExc_TypeError,
                     "Type %.100s doesn't support the buffer API",
                     Py_TYPE(obj)->tp_name);
        return -1;
    }

    if (buffer->bf_getbuffer(obj, view, PyBUF_SIMPLE) < 0)
            return -1;
    return view->len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int _getbytevalue ( PyObject arg,
int value 
) [static]

Definition at line 26 of file bytearrayobject.c.

{
    long face_value;

    if (PyLong_Check(arg)) {
        face_value = PyLong_AsLong(arg);
    } else {
        PyObject *index = PyNumber_Index(arg);
        if (index == NULL) {
            PyErr_Format(PyExc_TypeError, "an integer is required");
            *value = -1;
            return 0;
        }
        face_value = PyLong_AsLong(index);
        Py_DECREF(index);
    }

    if (face_value < 0 || face_value >= 256) {
        /* this includes the OverflowError in case the long is too large */
        PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)");
        *value = -1;
        return 0;
    }

    *value = face_value;
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* bytearray_alloc ( PyByteArrayObject self) [static]

Definition at line 2502 of file bytearrayobject.c.

{
    return PyLong_FromSsize_t(self->ob_alloc);
}
static PyObject* bytearray_append ( PyByteArrayObject self,
PyObject arg 
) [static]

Definition at line 2184 of file bytearrayobject.c.

{
    int value;
    Py_ssize_t n = Py_SIZE(self);

    if (! _getbytevalue(arg, &value))
        return NULL;
    if (n == PY_SSIZE_T_MAX) {
        PyErr_SetString(PyExc_OverflowError,
                        "cannot add more objects to bytearray");
        return NULL;
    }
    if (PyByteArray_Resize((PyObject *)self, n + 1) < 0)
        return NULL;

    self->ob_bytes[n] = value;

    Py_RETURN_NONE;
}

Here is the call graph for this function:

static int bytearray_ass_subscript ( PyByteArrayObject self,
PyObject index,
PyObject values 
) [static]

Definition at line 541 of file bytearrayobject.c.

{
    Py_ssize_t start, stop, step, slicelen, needed;
    char *bytes;

    if (PyIndex_Check(index)) {
        Py_ssize_t i = PyNumber_AsSsize_t(index, PyExc_IndexError);

        if (i == -1 && PyErr_Occurred())
            return -1;

        if (i < 0)
            i += PyByteArray_GET_SIZE(self);

        if (i < 0 || i >= Py_SIZE(self)) {
            PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
            return -1;
        }

        if (values == NULL) {
            /* Fall through to slice assignment */
            start = i;
            stop = i + 1;
            step = 1;
            slicelen = 1;
        }
        else {
            int ival;
            if (!_getbytevalue(values, &ival))
                return -1;
            self->ob_bytes[i] = (char)ival;
            return 0;
        }
    }
    else if (PySlice_Check(index)) {
        if (PySlice_GetIndicesEx(index,
                                 PyByteArray_GET_SIZE(self),
                                 &start, &stop, &step, &slicelen) < 0) {
            return -1;
        }
    }
    else {
        PyErr_SetString(PyExc_TypeError, "bytearray indices must be integer");
        return -1;
    }

    if (values == NULL) {
        bytes = NULL;
        needed = 0;
    }
    else if (values == (PyObject *)self || !PyByteArray_Check(values)) {
        /* Make a copy and call this function recursively */
        int err;
        values = PyByteArray_FromObject(values);
        if (values == NULL)
            return -1;
        err = bytearray_ass_subscript(self, index, values);
        Py_DECREF(values);
        return err;
    }
    else {
        assert(PyByteArray_Check(values));
        bytes = ((PyByteArrayObject *)values)->ob_bytes;
        needed = Py_SIZE(values);
    }
    /* Make sure b[5:2] = ... inserts before 5, not before 2. */
    if ((step < 0 && start < stop) ||
        (step > 0 && start > stop))
        stop = start;
    if (step == 1) {
        if (slicelen != needed) {
            if (!_canresize(self))
                return -1;
            if (slicelen > needed) {
                /*
                  0   start           stop              old_size
                  |   |<---slicelen--->|<-----tomove------>|
                  |   |<-needed->|<-----tomove------>|
                  0   lo      new_hi              new_size
                */
                memmove(self->ob_bytes + start + needed, self->ob_bytes + stop,
                        Py_SIZE(self) - stop);
            }
            if (PyByteArray_Resize((PyObject *)self,
                               Py_SIZE(self) + needed - slicelen) < 0)
                return -1;
            if (slicelen < needed) {
                /*
                  0   lo        hi               old_size
                  |   |<-avail->|<-----tomove------>|
                  |   |<----needed---->|<-----tomove------>|
                  0   lo            new_hi              new_size
                 */
                memmove(self->ob_bytes + start + needed, self->ob_bytes + stop,
                        Py_SIZE(self) - start - needed);
            }
        }

        if (needed > 0)
            memcpy(self->ob_bytes + start, bytes, needed);

        return 0;
    }
    else {
        if (needed == 0) {
            /* Delete slice */
            size_t cur;
            Py_ssize_t i;

            if (!_canresize(self))
                return -1;

            if (slicelen == 0)
                /* Nothing to do here. */
                return 0;

            if (step < 0) {
                stop = start + 1;
                start = stop + step * (slicelen - 1) - 1;
                step = -step;
            }
            for (cur = start, i = 0;
                 i < slicelen; cur += step, i++) {
                Py_ssize_t lim = step - 1;

                if (cur + step >= (size_t)PyByteArray_GET_SIZE(self))
                    lim = PyByteArray_GET_SIZE(self) - cur - 1;

                memmove(self->ob_bytes + cur - i,
                        self->ob_bytes + cur + 1, lim);
            }
            /* Move the tail of the bytes, in one chunk */
            cur = start + (size_t)slicelen*step;
            if (cur < (size_t)PyByteArray_GET_SIZE(self)) {
                memmove(self->ob_bytes + cur - slicelen,
                        self->ob_bytes + cur,
                        PyByteArray_GET_SIZE(self) - cur);
            }
            if (PyByteArray_Resize((PyObject *)self,
                               PyByteArray_GET_SIZE(self) - slicelen) < 0)
                return -1;

            return 0;
        }
        else {
            /* Assign slice */
            Py_ssize_t i;
            size_t cur;

            if (needed != slicelen) {
                PyErr_Format(PyExc_ValueError,
                             "attempt to assign bytes of size %zd "
                             "to extended slice of size %zd",
                             needed, slicelen);
                return -1;
            }
            for (cur = start, i = 0; i < slicelen; cur += step, i++)
                self->ob_bytes[cur] = bytes[i];
            return 0;
        }
    }
}

Here is the call graph for this function:

static int bytearray_contains ( PyObject self,
PyObject arg 
) [static]

Definition at line 1211 of file bytearrayobject.c.

{
    Py_ssize_t ival = PyNumber_AsSsize_t(arg, PyExc_ValueError);
    if (ival == -1 && PyErr_Occurred()) {
        Py_buffer varg;
        Py_ssize_t pos;
        PyErr_Clear();
        if (_getbuffer(arg, &varg) < 0)
            return -1;
        pos = stringlib_find(PyByteArray_AS_STRING(self), Py_SIZE(self),
                             varg.buf, varg.len, 0);
        PyBuffer_Release(&varg);
        return pos >= 0;
    }
    if (ival < 0 || ival >= 256) {
        PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)");
        return -1;
    }

    return memchr(PyByteArray_AS_STRING(self), (int) ival, Py_SIZE(self)) != NULL;
}

Here is the call graph for this function:

static PyObject* bytearray_count ( PyByteArrayObject self,
PyObject args 
) [static]

Definition at line 1127 of file bytearrayobject.c.

{
    PyObject *sub_obj;
    const char *str = PyByteArray_AS_STRING(self);
    Py_ssize_t start = 0, end = PY_SSIZE_T_MAX;
    Py_buffer vsub;
    PyObject *count_obj;

    if (!stringlib_parse_args_finds("count", args, &sub_obj, &start, &end))
        return NULL;

    if (_getbuffer(sub_obj, &vsub) < 0)
        return NULL;

    ADJUST_INDICES(start, end, PyByteArray_GET_SIZE(self));

    count_obj = PyLong_FromSsize_t(
        stringlib_count(str + start, end - start, vsub.buf, vsub.len, PY_SSIZE_T_MAX)
        );
    PyBuffer_Release(&vsub);
    return count_obj;
}

Here is the call graph for this function:

static void bytearray_dealloc ( PyByteArrayObject self) [static]

Definition at line 1023 of file bytearrayobject.c.

{
    if (self->ob_exports > 0) {
        PyErr_SetString(PyExc_SystemError,
                        "deallocated bytearray object has exported buffers");
        PyErr_Print();
    }
    if (self->ob_bytes != 0) {
        PyMem_Free(self->ob_bytes);
    }
    Py_TYPE(self)->tp_free((PyObject *)self);
}

Here is the call graph for this function:

static PyObject* bytearray_decode ( PyObject self,
PyObject args,
PyObject kwargs 
) [static]

Definition at line 2483 of file bytearrayobject.c.

{
    const char *encoding = NULL;
    const char *errors = NULL;
    static char *kwlist[] = {"encoding", "errors", 0};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ss:decode", kwlist, &encoding, &errors))
        return NULL;
    if (encoding == NULL)
        encoding = PyUnicode_GetDefaultEncoding();
    return PyUnicode_FromEncodedObject(self, encoding, errors);
}

Here is the call graph for this function:

static PyObject* bytearray_endswith ( PyByteArrayObject self,
PyObject args 
) [static]

Definition at line 1329 of file bytearrayobject.c.

{
    Py_ssize_t start = 0;
    Py_ssize_t end = PY_SSIZE_T_MAX;
    PyObject *subobj;
    int result;

    if (!stringlib_parse_args_finds("endswith", args, &subobj, &start, &end))
        return NULL;
    if (PyTuple_Check(subobj)) {
        Py_ssize_t i;
        for (i = 0; i < PyTuple_GET_SIZE(subobj); i++) {
            result = _bytearray_tailmatch(self,
                                      PyTuple_GET_ITEM(subobj, i),
                                      start, end, +1);
            if (result == -1)
                return NULL;
            else if (result) {
                Py_RETURN_TRUE;
            }
        }
        Py_RETURN_FALSE;
    }
    result = _bytearray_tailmatch(self, subobj, start, end, +1);
    if (result == -1) {
        if (PyErr_ExceptionMatches(PyExc_TypeError))
            PyErr_Format(PyExc_TypeError, "endswith first arg must be bytes or "
                         "a tuple of bytes, not %s", Py_TYPE(subobj)->tp_name);
        return NULL;
    }
    else
        return PyBool_FromLong(result);
}

Here is the call graph for this function:

static PyObject* bytearray_extend ( PyByteArrayObject self,
PyObject arg 
) [static]

Definition at line 2210 of file bytearrayobject.c.

{
    PyObject *it, *item, *bytearray_obj;
    Py_ssize_t buf_size = 0, len = 0;
    int value;
    char *buf;

    /* bytearray_setslice code only accepts something supporting PEP 3118. */
    if (PyObject_CheckBuffer(arg)) {
        if (bytearray_setslice(self, Py_SIZE(self), Py_SIZE(self), arg) == -1)
            return NULL;

        Py_RETURN_NONE;
    }

    it = PyObject_GetIter(arg);
    if (it == NULL)
        return NULL;

    /* Try to determine the length of the argument. 32 is arbitrary. */
    buf_size = _PyObject_LengthHint(arg, 32);
    if (buf_size == -1) {
        Py_DECREF(it);
        return NULL;
    }

    bytearray_obj = PyByteArray_FromStringAndSize(NULL, buf_size);
    if (bytearray_obj == NULL)
        return NULL;
    buf = PyByteArray_AS_STRING(bytearray_obj);

    while ((item = PyIter_Next(it)) != NULL) {
        if (! _getbytevalue(item, &value)) {
            Py_DECREF(item);
            Py_DECREF(it);
            Py_DECREF(bytearray_obj);
            return NULL;
        }
        buf[len++] = value;
        Py_DECREF(item);

        if (len >= buf_size) {
            buf_size = len + (len >> 1) + 1;
            if (PyByteArray_Resize((PyObject *)bytearray_obj, buf_size) < 0) {
                Py_DECREF(it);
                Py_DECREF(bytearray_obj);
                return NULL;
            }
            /* Recompute the `buf' pointer, since the resizing operation may
               have invalidated it. */
            buf = PyByteArray_AS_STRING(bytearray_obj);
        }
    }
    Py_DECREF(it);

    /* Resize down to exact size. */
    if (PyByteArray_Resize((PyObject *)bytearray_obj, len) < 0) {
        Py_DECREF(bytearray_obj);
        return NULL;
    }

    if (bytearray_setslice(self, Py_SIZE(self), Py_SIZE(self), bytearray_obj) == -1)
        return NULL;
    Py_DECREF(bytearray_obj);

    Py_RETURN_NONE;
}

Here is the call graph for this function:

static PyObject* bytearray_find ( PyByteArrayObject self,
PyObject args 
) [static]

Definition at line 1111 of file bytearrayobject.c.

{
    Py_ssize_t result = bytearray_find_internal(self, args, +1);
    if (result == -2)
        return NULL;
    return PyLong_FromSsize_t(result);
}
static PyObject* bytearray_fromhex ( PyObject cls,
PyObject args 
) [static]

Definition at line 2628 of file bytearrayobject.c.

{
    PyObject *newbytes, *hexobj;
    char *buf;
    Py_UNICODE *hex;
    Py_ssize_t hexlen, byteslen, i, j;
    int top, bot;

    if (!PyArg_ParseTuple(args, "U:fromhex", &hexobj))
        return NULL;
    assert(PyUnicode_Check(hexobj));
    hexlen = PyUnicode_GET_SIZE(hexobj);
    hex = PyUnicode_AS_UNICODE(hexobj);
    byteslen = hexlen/2; /* This overestimates if there are spaces */
    newbytes = PyByteArray_FromStringAndSize(NULL, byteslen);
    if (!newbytes)
        return NULL;
    buf = PyByteArray_AS_STRING(newbytes);
    for (i = j = 0; i < hexlen; i += 2) {
        /* skip over spaces in the input */
        while (hex[i] == ' ')
            i++;
        if (i >= hexlen)
            break;
        top = hex_digit_to_int(hex[i]);
        bot = hex_digit_to_int(hex[i+1]);
        if (top == -1 || bot == -1) {
            PyErr_Format(PyExc_ValueError,
                         "non-hexadecimal number found in "
                         "fromhex() arg at position %zd", i);
            goto error;
        }
        buf[j++] = (top << 4) + bot;
    }
    if (PyByteArray_Resize(newbytes, j) < 0)
        goto error;
    return newbytes;

  error:
    Py_DECREF(newbytes);
    return NULL;
}

Here is the call graph for this function:

static int bytearray_getbuffer ( PyByteArrayObject obj,
Py_buffer view,
int  flags 
) [static]

Definition at line 55 of file bytearrayobject.c.

{
    int ret;
    void *ptr;
    if (view == NULL) {
        obj->ob_exports++;
        return 0;
    }
    ptr = (void *) PyByteArray_AS_STRING(obj);
    ret = PyBuffer_FillInfo(view, (PyObject*)obj, ptr, Py_SIZE(obj), 0, flags);
    if (ret >= 0) {
        obj->ob_exports++;
    }
    return ret;
}

Here is the call graph for this function:

static PyObject* bytearray_getitem ( PyByteArrayObject self,
Py_ssize_t  i 
) [static]

Definition at line 361 of file bytearrayobject.c.

{
    if (i < 0)
        i += Py_SIZE(self);
    if (i < 0 || i >= Py_SIZE(self)) {
        PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
        return NULL;
    }
    return PyLong_FromLong((unsigned char)(self->ob_bytes[i]));
}

Here is the call graph for this function:

static PyObject* bytearray_iconcat ( PyByteArrayObject self,
PyObject other 
) [static]

Definition at line 271 of file bytearrayobject.c.

{
    Py_ssize_t mysize;
    Py_ssize_t size;
    Py_buffer vo;

    if (_getbuffer(other, &vo) < 0) {
        PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",
                     Py_TYPE(other)->tp_name, Py_TYPE(self)->tp_name);
        return NULL;
    }

    mysize = Py_SIZE(self);
    size = mysize + vo.len;
    if (size < 0) {
        PyBuffer_Release(&vo);
        return PyErr_NoMemory();
    }
    if (size < self->ob_alloc) {
        Py_SIZE(self) = size;
        self->ob_bytes[Py_SIZE(self)] = '\0'; /* Trailing null byte */
    }
    else if (PyByteArray_Resize((PyObject *)self, size) < 0) {
        PyBuffer_Release(&vo);
        return NULL;
    }
    memcpy(self->ob_bytes + mysize, vo.buf, vo.len);
    PyBuffer_Release(&vo);
    Py_INCREF(self);
    return (PyObject *)self;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* bytearray_index ( PyByteArrayObject self,
PyObject args 
) [static]

Definition at line 1157 of file bytearrayobject.c.

{
    Py_ssize_t result = bytearray_find_internal(self, args, +1);
    if (result == -2)
        return NULL;
    if (result == -1) {
        PyErr_SetString(PyExc_ValueError,
                        "subsection not found");
        return NULL;
    }
    return PyLong_FromSsize_t(result);
}

Here is the call graph for this function:

static int bytearray_init ( PyByteArrayObject self,
PyObject args,
PyObject kwds 
) [static]

Definition at line 705 of file bytearrayobject.c.

{
    static char *kwlist[] = {"source", "encoding", "errors", 0};
    PyObject *arg = NULL;
    const char *encoding = NULL;
    const char *errors = NULL;
    Py_ssize_t count;
    PyObject *it;
    PyObject *(*iternext)(PyObject *);

    if (Py_SIZE(self) != 0) {
        /* Empty previous contents (yes, do this first of all!) */
        if (PyByteArray_Resize((PyObject *)self, 0) < 0)
            return -1;
    }

    /* Parse arguments */
    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oss:bytearray", kwlist,
                                     &arg, &encoding, &errors))
        return -1;

    /* Make a quick exit if no first argument */
    if (arg == NULL) {
        if (encoding != NULL || errors != NULL) {
            PyErr_SetString(PyExc_TypeError,
                            "encoding or errors without sequence argument");
            return -1;
        }
        return 0;
    }

    if (PyUnicode_Check(arg)) {
        /* Encode via the codec registry */
        PyObject *encoded, *new;
        if (encoding == NULL) {
            PyErr_SetString(PyExc_TypeError,
                            "string argument without an encoding");
            return -1;
        }
        encoded = PyUnicode_AsEncodedString(arg, encoding, errors);
        if (encoded == NULL)
            return -1;
        assert(PyBytes_Check(encoded));
        new = bytearray_iconcat(self, encoded);
        Py_DECREF(encoded);
        if (new == NULL)
            return -1;
        Py_DECREF(new);
        return 0;
    }

    /* If it's not unicode, there can't be encoding or errors */
    if (encoding != NULL || errors != NULL) {
        PyErr_SetString(PyExc_TypeError,
                        "encoding or errors without a string argument");
        return -1;
    }

    /* Is it an int? */
    count = PyNumber_AsSsize_t(arg, PyExc_OverflowError);
    if (count == -1 && PyErr_Occurred()) {
        if (PyErr_ExceptionMatches(PyExc_OverflowError))
            return -1;
        PyErr_Clear();
    }
    else if (count < 0) {
        PyErr_SetString(PyExc_ValueError, "negative count");
        return -1;
    }
    else {
        if (count > 0) {
            if (PyByteArray_Resize((PyObject *)self, count))
                return -1;
            memset(self->ob_bytes, 0, count);
        }
        return 0;
    }

    /* Use the buffer API */
    if (PyObject_CheckBuffer(arg)) {
        Py_ssize_t size;
        Py_buffer view;
        if (PyObject_GetBuffer(arg, &view, PyBUF_FULL_RO) < 0)
            return -1;
        size = view.len;
        if (PyByteArray_Resize((PyObject *)self, size) < 0) goto fail;
        if (PyBuffer_ToContiguous(self->ob_bytes, &view, size, 'C') < 0)
                goto fail;
        PyBuffer_Release(&view);
        return 0;
    fail:
        PyBuffer_Release(&view);
        return -1;
    }

    /* XXX Optimize this if the arguments is a list, tuple */

    /* Get the iterator */
    it = PyObject_GetIter(arg);
    if (it == NULL)
        return -1;
    iternext = *Py_TYPE(it)->tp_iternext;

    /* Run the iterator to exhaustion */
    for (;;) {
        PyObject *item;
        int rc, value;

        /* Get the next item */
        item = iternext(it);
        if (item == NULL) {
            if (PyErr_Occurred()) {
                if (!PyErr_ExceptionMatches(PyExc_StopIteration))
                    goto error;
                PyErr_Clear();
            }
            break;
        }

        /* Interpret it as an int (__index__) */
        rc = _getbytevalue(item, &value);
        Py_DECREF(item);
        if (!rc)
            goto error;

        /* Append the byte */
        if (Py_SIZE(self) < self->ob_alloc)
            Py_SIZE(self)++;
        else if (PyByteArray_Resize((PyObject *)self, Py_SIZE(self)+1) < 0)
            goto error;
        self->ob_bytes[Py_SIZE(self)-1] = value;
    }

    /* Clean up and return success */
    Py_DECREF(it);
    return 0;

 error:
    /* Error handling when it != NULL */
    Py_DECREF(it);
    return -1;
}

Here is the call graph for this function:

static PyObject* bytearray_insert ( PyByteArrayObject self,
PyObject args 
) [static]

Definition at line 2147 of file bytearrayobject.c.

{
    PyObject *value;
    int ival;
    Py_ssize_t where, n = Py_SIZE(self);

    if (!PyArg_ParseTuple(args, "nO:insert", &where, &value))
        return NULL;

    if (n == PY_SSIZE_T_MAX) {
        PyErr_SetString(PyExc_OverflowError,
                        "cannot add more objects to bytearray");
        return NULL;
    }
    if (!_getbytevalue(value, &ival))
        return NULL;
    if (PyByteArray_Resize((PyObject *)self, n + 1) < 0)
        return NULL;

    if (where < 0) {
        where += n;
        if (where < 0)
            where = 0;
    }
    if (where > n)
        where = n;
    memmove(self->ob_bytes + where + 1, self->ob_bytes + where, n - where);
    self->ob_bytes[where] = ival;

    Py_RETURN_NONE;
}

Here is the call graph for this function:

static PyObject* bytearray_irepeat ( PyByteArrayObject self,
Py_ssize_t  count 
) [static]

Definition at line 330 of file bytearrayobject.c.

{
    Py_ssize_t mysize;
    Py_ssize_t size;

    if (count < 0)
        count = 0;
    mysize = Py_SIZE(self);
    if (count > 0 && mysize > PY_SSIZE_T_MAX / count)
        return PyErr_NoMemory();
    size = mysize * count;
    if (size < self->ob_alloc) {
        Py_SIZE(self) = size;
        self->ob_bytes[Py_SIZE(self)] = '\0'; /* Trailing null byte */
    }
    else if (PyByteArray_Resize((PyObject *)self, size) < 0)
        return NULL;

    if (mysize == 1)
        memset(self->ob_bytes, self->ob_bytes[0], size);
    else {
        Py_ssize_t i;
        for (i = 1; i < count; i++)
            memcpy(self->ob_bytes + i*mysize, self->ob_bytes, mysize);
    }

    Py_INCREF(self);
    return (PyObject *)self;
}

Here is the call graph for this function:

static PyObject * bytearray_iter ( PyObject seq) [static]

Definition at line 2958 of file bytearrayobject.c.

{
    bytesiterobject *it;

    if (!PyByteArray_Check(seq)) {
        PyErr_BadInternalCall();
        return NULL;
    }
    it = PyObject_GC_New(bytesiterobject, &PyByteArrayIter_Type);
    if (it == NULL)
        return NULL;
    it->it_index = 0;
    Py_INCREF(seq);
    it->it_seq = (PyByteArrayObject *)seq;
    _PyObject_GC_TRACK(it);
    return (PyObject *)it;
}
static PyObject* bytearray_join ( PyByteArrayObject self,
PyObject it 
) [static]

Definition at line 2514 of file bytearrayobject.c.

{
    PyObject *seq;
    Py_ssize_t mysize = Py_SIZE(self);
    Py_ssize_t i;
    Py_ssize_t n;
    PyObject **items;
    Py_ssize_t totalsize = 0;
    PyObject *result;
    char *dest;

    seq = PySequence_Fast(it, "can only join an iterable");
    if (seq == NULL)
        return NULL;
    n = PySequence_Fast_GET_SIZE(seq);
    items = PySequence_Fast_ITEMS(seq);

    /* Compute the total size, and check that they are all bytes */
    /* XXX Shouldn't we use _getbuffer() on these items instead? */
    for (i = 0; i < n; i++) {
        PyObject *obj = items[i];
        if (!PyByteArray_Check(obj) && !PyBytes_Check(obj)) {
            PyErr_Format(PyExc_TypeError,
                         "can only join an iterable of bytes "
                         "(item %ld has type '%.100s')",
                         /* XXX %ld isn't right on Win64 */
                         (long)i, Py_TYPE(obj)->tp_name);
            goto error;
        }
        if (i > 0)
            totalsize += mysize;
        totalsize += Py_SIZE(obj);
        if (totalsize < 0) {
            PyErr_NoMemory();
            goto error;
        }
    }

    /* Allocate the result, and copy the bytes */
    result = PyByteArray_FromStringAndSize(NULL, totalsize);
    if (result == NULL)
        goto error;
    dest = PyByteArray_AS_STRING(result);
    for (i = 0; i < n; i++) {
        PyObject *obj = items[i];
        Py_ssize_t size = Py_SIZE(obj);
        char *buf;
        if (PyByteArray_Check(obj))
           buf = PyByteArray_AS_STRING(obj);
        else
           buf = PyBytes_AS_STRING(obj);
        if (i) {
            memcpy(dest, self->ob_bytes, mysize);
            dest += mysize;
        }
        memcpy(dest, buf, size);
        dest += size;
    }

    /* Done */
    Py_DECREF(seq);
    return result;

    /* Error handling */
  error:
    Py_DECREF(seq);
    return NULL;
}

Here is the call graph for this function:

static Py_ssize_t bytearray_length ( PyByteArrayObject self) [static]

Definition at line 265 of file bytearrayobject.c.

{
    return Py_SIZE(self);
}
static PyObject* bytearray_lstrip ( PyByteArrayObject self,
PyObject args 
) [static]

Definition at line 2411 of file bytearrayobject.c.

{
    Py_ssize_t left, right, mysize, argsize;
    void *myptr, *argptr;
    PyObject *arg = Py_None;
    Py_buffer varg;
    if (!PyArg_ParseTuple(args, "|O:lstrip", &arg))
        return NULL;
    if (arg == Py_None) {
        argptr = "\t\n\r\f\v ";
        argsize = 6;
    }
    else {
        if (_getbuffer(arg, &varg) < 0)
            return NULL;
        argptr = varg.buf;
        argsize = varg.len;
    }
    myptr = self->ob_bytes;
    mysize = Py_SIZE(self);
    left = lstrip_helper(myptr, mysize, argptr, argsize);
    right = mysize;
    if (arg != Py_None)
        PyBuffer_Release(&varg);
    return PyByteArray_FromStringAndSize(self->ob_bytes + left, right - left);
}

Here is the call graph for this function:

static PyObject* bytearray_maketrans ( PyObject null,
PyObject args 
) [static]

Definition at line 1464 of file bytearrayobject.c.

{
        return _Py_bytes_maketrans(args);
}

Here is the call graph for this function:

static PyObject* bytearray_partition ( PyByteArrayObject self,
PyObject sep_obj 
) [static]

Definition at line 2035 of file bytearrayobject.c.

{
    PyObject *bytesep, *result;

    bytesep = PyByteArray_FromObject(sep_obj);
    if (! bytesep)
        return NULL;

    result = stringlib_partition(
            (PyObject*) self,
            PyByteArray_AS_STRING(self), PyByteArray_GET_SIZE(self),
            bytesep,
            PyByteArray_AS_STRING(bytesep), PyByteArray_GET_SIZE(bytesep)
            );

    Py_DECREF(bytesep);
    return result;
}

Here is the call graph for this function:

static PyObject* bytearray_pop ( PyByteArrayObject self,
PyObject args 
) [static]

Definition at line 2284 of file bytearrayobject.c.

{
    int value;
    Py_ssize_t where = -1, n = Py_SIZE(self);

    if (!PyArg_ParseTuple(args, "|n:pop", &where))
        return NULL;

    if (n == 0) {
        PyErr_SetString(PyExc_IndexError,
                        "pop from empty bytearray");
        return NULL;
    }
    if (where < 0)
        where += Py_SIZE(self);
    if (where < 0 || where >= Py_SIZE(self)) {
        PyErr_SetString(PyExc_IndexError, "pop index out of range");
        return NULL;
    }
    if (!_canresize(self))
        return NULL;

    value = self->ob_bytes[where];
    memmove(self->ob_bytes + where, self->ob_bytes + where + 1, n - where);
    if (PyByteArray_Resize((PyObject *)self, n - 1) < 0)
        return NULL;

    return PyLong_FromLong((unsigned char)value);
}

Here is the call graph for this function:

static PyObject* bytearray_reduce ( PyByteArrayObject self) [static]

Definition at line 2674 of file bytearrayobject.c.

{
    PyObject *latin1, *dict;
    if (self->ob_bytes)
        latin1 = PyUnicode_DecodeLatin1(self->ob_bytes,
                                        Py_SIZE(self), NULL);
    else
        latin1 = PyUnicode_FromString("");

    dict = PyObject_GetAttrString((PyObject *)self, "__dict__");
    if (dict == NULL) {
        PyErr_Clear();
        dict = Py_None;
        Py_INCREF(dict);
    }

    return Py_BuildValue("(O(Ns)N)", Py_TYPE(self), latin1, "latin-1", dict);
}

Here is the call graph for this function:

static void bytearray_releasebuffer ( PyByteArrayObject obj,
Py_buffer view 
) [static]

Definition at line 72 of file bytearrayobject.c.

{
    obj->ob_exports--;
}
static PyObject* bytearray_remove ( PyByteArrayObject self,
PyObject arg 
) [static]

Definition at line 2319 of file bytearrayobject.c.

{
    int value;
    Py_ssize_t where, n = Py_SIZE(self);

    if (! _getbytevalue(arg, &value))
        return NULL;

    for (where = 0; where < n; where++) {
        if (self->ob_bytes[where] == value)
            break;
    }
    if (where == n) {
        PyErr_SetString(PyExc_ValueError, "value not found in bytearray");
        return NULL;
    }
    if (!_canresize(self))
        return NULL;

    memmove(self->ob_bytes + where, self->ob_bytes + where + 1, n - where);
    if (PyByteArray_Resize((PyObject *)self, n - 1) < 0)
        return NULL;

    Py_RETURN_NONE;
}

Here is the call graph for this function:

static PyObject* bytearray_repeat ( PyByteArrayObject self,
Py_ssize_t  count 
) [static]

Definition at line 304 of file bytearrayobject.c.

{
    PyByteArrayObject *result;
    Py_ssize_t mysize;
    Py_ssize_t size;

    if (count < 0)
        count = 0;
    mysize = Py_SIZE(self);
    if (count > 0 && mysize > PY_SSIZE_T_MAX / count)
        return PyErr_NoMemory();
    size = mysize * count;
    result = (PyByteArrayObject *)PyByteArray_FromStringAndSize(NULL, size);
    if (result != NULL && size != 0) {
        if (mysize == 1)
            memset(result->ob_bytes, self->ob_bytes[0], size);
        else {
            Py_ssize_t i;
            for (i = 0; i < count; i++)
                memcpy(result->ob_bytes + i*mysize, self->ob_bytes, mysize);
        }
    }
    return (PyObject *)result;
}

Here is the call graph for this function:

static PyObject* bytearray_replace ( PyByteArrayObject self,
PyObject args 
) [static]

Definition at line 1965 of file bytearrayobject.c.

{
    Py_ssize_t count = -1;
    PyObject *from, *to, *res;
    Py_buffer vfrom, vto;

    if (!PyArg_ParseTuple(args, "OO|n:replace", &from, &to, &count))
        return NULL;

    if (_getbuffer(from, &vfrom) < 0)
        return NULL;
    if (_getbuffer(to, &vto) < 0) {
        PyBuffer_Release(&vfrom);
        return NULL;
    }

    res = (PyObject *)replace((PyByteArrayObject *) self,
                              vfrom.buf, vfrom.len,
                              vto.buf, vto.len, count);

    PyBuffer_Release(&vfrom);
    PyBuffer_Release(&vto);
    return res;
}

Here is the call graph for this function:

static PyObject* bytearray_repr ( PyByteArrayObject self) [static]

Definition at line 851 of file bytearrayobject.c.

{
    static const char *hexdigits = "0123456789abcdef";
    const char *quote_prefix = "bytearray(b";
    const char *quote_postfix = ")";
    Py_ssize_t length = Py_SIZE(self);
    /* 14 == strlen(quote_prefix) + 2 + strlen(quote_postfix) */
    size_t newsize;
    PyObject *v;
    if (length > (PY_SSIZE_T_MAX - 14) / 4) {
        PyErr_SetString(PyExc_OverflowError,
            "bytearray object is too large to make repr");
        return NULL;
    }
    newsize = 14 + 4 * length;
    v = PyUnicode_FromUnicode(NULL, newsize);
    if (v == NULL) {
        return NULL;
    }
    else {
        register Py_ssize_t i;
        register Py_UNICODE c;
        register Py_UNICODE *p;
        int quote;

        /* Figure out which quote to use; single is preferred */
        quote = '\'';
        {
            char *test, *start;
            start = PyByteArray_AS_STRING(self);
            for (test = start; test < start+length; ++test) {
                if (*test == '"') {
                    quote = '\''; /* back to single */
                    goto decided;
                }
                else if (*test == '\'')
                    quote = '"';
            }
          decided:
            ;
        }

        p = PyUnicode_AS_UNICODE(v);
        while (*quote_prefix)
            *p++ = *quote_prefix++;
        *p++ = quote;

        for (i = 0; i < length; i++) {
            /* There's at least enough room for a hex escape
               and a closing quote. */
            assert(newsize - (p - PyUnicode_AS_UNICODE(v)) >= 5);
            c = self->ob_bytes[i];
            if (c == '\'' || c == '\\')
                *p++ = '\\', *p++ = c;
            else if (c == '\t')
                *p++ = '\\', *p++ = 't';
            else if (c == '\n')
                *p++ = '\\', *p++ = 'n';
            else if (c == '\r')
                *p++ = '\\', *p++ = 'r';
            else if (c == 0)
                *p++ = '\\', *p++ = 'x', *p++ = '0', *p++ = '0';
            else if (c < ' ' || c >= 0x7f) {
                *p++ = '\\';
                *p++ = 'x';
                *p++ = hexdigits[(c & 0xf0) >> 4];
                *p++ = hexdigits[c & 0xf];
            }
            else
                *p++ = c;
        }
        assert(newsize - (p - PyUnicode_AS_UNICODE(v)) >= 1);
        *p++ = quote;
        while (*quote_postfix) {
           *p++ = *quote_postfix++;
        }
        *p = '\0';
        if (PyUnicode_Resize(&v, (p - PyUnicode_AS_UNICODE(v)))) {
            Py_DECREF(v);
            return NULL;
        }
        return v;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* bytearray_reverse ( PyByteArrayObject self,
PyObject unused 
) [static]

Definition at line 2125 of file bytearrayobject.c.

{
    char swap, *head, *tail;
    Py_ssize_t i, j, n = Py_SIZE(self);

    j = n / 2;
    head = self->ob_bytes;
    tail = head + n - 1;
    for (i = 0; i < j; i++) {
        swap = *head;
        *head++ = *tail;
        *tail-- = swap;
    }

    Py_RETURN_NONE;
}

Here is the call graph for this function:

static PyObject* bytearray_rfind ( PyByteArrayObject self,
PyObject args 
) [static]

Definition at line 1181 of file bytearrayobject.c.

{
    Py_ssize_t result = bytearray_find_internal(self, args, -1);
    if (result == -2)
        return NULL;
    return PyLong_FromSsize_t(result);
}
static PyObject* bytearray_richcompare ( PyObject self,
PyObject other,
int  op 
) [static]

Definition at line 948 of file bytearrayobject.c.

{
    Py_ssize_t self_size, other_size;
    Py_buffer self_bytes, other_bytes;
    PyObject *res;
    Py_ssize_t minsize;
    int cmp;

    /* Bytes can be compared to anything that supports the (binary)
       buffer API.  Except that a comparison with Unicode is always an
       error, even if the comparison is for equality. */
    if (PyObject_IsInstance(self, (PyObject*)&PyUnicode_Type) ||
        PyObject_IsInstance(other, (PyObject*)&PyUnicode_Type)) {
        if (Py_BytesWarningFlag && (op == Py_EQ || op == Py_NE)) {
            if (PyErr_WarnEx(PyExc_BytesWarning,
                            "Comparison between bytearray and string", 1))
                return NULL;
        }

        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

    self_size = _getbuffer(self, &self_bytes);
    if (self_size < 0) {
        PyErr_Clear();
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

    other_size = _getbuffer(other, &other_bytes);
    if (other_size < 0) {
        PyErr_Clear();
        PyBuffer_Release(&self_bytes);
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

    if (self_size != other_size && (op == Py_EQ || op == Py_NE)) {
        /* Shortcut: if the lengths differ, the objects differ */
        cmp = (op == Py_NE);
    }
    else {
        minsize = self_size;
        if (other_size < minsize)
            minsize = other_size;

        cmp = memcmp(self_bytes.buf, other_bytes.buf, minsize);
        /* In ISO C, memcmp() guarantees to use unsigned bytes! */

        if (cmp == 0) {
            if (self_size < other_size)
                cmp = -1;
            else if (self_size > other_size)
                cmp = 1;
        }

        switch (op) {
        case Py_LT: cmp = cmp <  0; break;
        case Py_LE: cmp = cmp <= 0; break;
        case Py_EQ: cmp = cmp == 0; break;
        case Py_NE: cmp = cmp != 0; break;
        case Py_GT: cmp = cmp >  0; break;
        case Py_GE: cmp = cmp >= 0; break;
        }
    }

    res = cmp ? Py_True : Py_False;
    PyBuffer_Release(&self_bytes);
    PyBuffer_Release(&other_bytes);
    Py_INCREF(res);
    return res;
}

Here is the call graph for this function:

static PyObject* bytearray_rindex ( PyByteArrayObject self,
PyObject args 
) [static]

Definition at line 1196 of file bytearrayobject.c.

{
    Py_ssize_t result = bytearray_find_internal(self, args, -1);
    if (result == -2)
        return NULL;
    if (result == -1) {
        PyErr_SetString(PyExc_ValueError,
                        "subsection not found");
        return NULL;
    }
    return PyLong_FromSsize_t(result);
}

Here is the call graph for this function:

static PyObject* bytearray_rpartition ( PyByteArrayObject self,
PyObject sep_obj 
) [static]

Definition at line 2063 of file bytearrayobject.c.

{
    PyObject *bytesep, *result;

    bytesep = PyByteArray_FromObject(sep_obj);
    if (! bytesep)
        return NULL;

    result = stringlib_rpartition(
            (PyObject*) self,
            PyByteArray_AS_STRING(self), PyByteArray_GET_SIZE(self),
            bytesep,
            PyByteArray_AS_STRING(bytesep), PyByteArray_GET_SIZE(bytesep)
            );

    Py_DECREF(bytesep);
    return result;
}

Here is the call graph for this function:

static PyObject* bytearray_rsplit ( PyByteArrayObject self,
PyObject args 
) [static]

Definition at line 2092 of file bytearrayobject.c.

{
    Py_ssize_t len = PyByteArray_GET_SIZE(self), n;
    Py_ssize_t maxsplit = -1;
    const char *s = PyByteArray_AS_STRING(self), *sub;
    PyObject *list, *subobj = Py_None;
    Py_buffer vsub;

    if (!PyArg_ParseTuple(args, "|On:rsplit", &subobj, &maxsplit))
        return NULL;
    if (maxsplit < 0)
        maxsplit = PY_SSIZE_T_MAX;

    if (subobj == Py_None)
        return stringlib_rsplit_whitespace((PyObject*) self, s, len, maxsplit);

    if (_getbuffer(subobj, &vsub) < 0)
        return NULL;
    sub = vsub.buf;
    n = vsub.len;

    list = stringlib_rsplit(
        (PyObject*) self, s, len, sub, n, maxsplit
        );
    PyBuffer_Release(&vsub);
    return list;
}

Here is the call graph for this function:

static PyObject* bytearray_rstrip ( PyByteArrayObject self,
PyObject args 
) [static]

Definition at line 2445 of file bytearrayobject.c.

{
    Py_ssize_t left, right, mysize, argsize;
    void *myptr, *argptr;
    PyObject *arg = Py_None;
    Py_buffer varg;
    if (!PyArg_ParseTuple(args, "|O:rstrip", &arg))
        return NULL;
    if (arg == Py_None) {
        argptr = "\t\n\r\f\v ";
        argsize = 6;
    }
    else {
        if (_getbuffer(arg, &varg) < 0)
            return NULL;
        argptr = varg.buf;
        argsize = varg.len;
    }
    myptr = self->ob_bytes;
    mysize = Py_SIZE(self);
    left = 0;
    right = rstrip_helper(myptr, mysize, argptr, argsize);
    if (arg != Py_None)
        PyBuffer_Release(&varg);
    return PyByteArray_FromStringAndSize(self->ob_bytes + left, right - left);
}

Here is the call graph for this function:

static int bytearray_setitem ( PyByteArrayObject self,
Py_ssize_t  i,
PyObject value 
) [static]

Definition at line 518 of file bytearrayobject.c.

{
    int ival;

    if (i < 0)
        i += Py_SIZE(self);

    if (i < 0 || i >= Py_SIZE(self)) {
        PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
        return -1;
    }

    if (value == NULL)
        return bytearray_setslice(self, i, i+1, NULL);

    if (!_getbytevalue(value, &ival))
        return -1;

    self->ob_bytes[i] = ival;
    return 0;
}

Here is the call graph for this function:

static int bytearray_setslice ( PyByteArrayObject self,
Py_ssize_t  lo,
Py_ssize_t  hi,
PyObject values 
) [static]

Definition at line 428 of file bytearrayobject.c.

{
    Py_ssize_t avail, needed;
    void *bytes;
    Py_buffer vbytes;
    int res = 0;

    vbytes.len = -1;
    if (values == (PyObject *)self) {
        /* Make a copy and call this function recursively */
        int err;
        values = PyByteArray_FromObject(values);
        if (values == NULL)
            return -1;
        err = bytearray_setslice(self, lo, hi, values);
        Py_DECREF(values);
        return err;
    }
    if (values == NULL) {
        /* del b[lo:hi] */
        bytes = NULL;
        needed = 0;
    }
    else {
            if (_getbuffer(values, &vbytes) < 0) {
                    PyErr_Format(PyExc_TypeError,
                                 "can't set bytearray slice from %.100s",
                                 Py_TYPE(values)->tp_name);
                    return -1;
            }
            needed = vbytes.len;
            bytes = vbytes.buf;
    }

    if (lo < 0)
        lo = 0;
    if (hi < lo)
        hi = lo;
    if (hi > Py_SIZE(self))
        hi = Py_SIZE(self);

    avail = hi - lo;
    if (avail < 0)
        lo = hi = avail = 0;

    if (avail != needed) {
        if (avail > needed) {
            if (!_canresize(self)) {
                res = -1;
                goto finish;
            }
            /*
              0   lo               hi               old_size
              |   |<----avail----->|<-----tomove------>|
              |   |<-needed->|<-----tomove------>|
              0   lo      new_hi              new_size
            */
            memmove(self->ob_bytes + lo + needed, self->ob_bytes + hi,
                    Py_SIZE(self) - hi);
        }
        /* XXX(nnorwitz): need to verify this can't overflow! */
        if (PyByteArray_Resize((PyObject *)self,
                           Py_SIZE(self) + needed - avail) < 0) {
                res = -1;
                goto finish;
        }
        if (avail < needed) {
            /*
              0   lo        hi               old_size
              |   |<-avail->|<-----tomove------>|
              |   |<----needed---->|<-----tomove------>|
              0   lo            new_hi              new_size
             */
            memmove(self->ob_bytes + lo + needed, self->ob_bytes + hi,
                    Py_SIZE(self) - lo - needed);
        }
    }

    if (needed > 0)
        memcpy(self->ob_bytes + lo, bytes, needed);


 finish:
    if (vbytes.len != -1)
            PyBuffer_Release(&vbytes);
    return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* bytearray_sizeof ( PyByteArrayObject self) [static]

Definition at line 2698 of file bytearrayobject.c.

{
    Py_ssize_t res;

    res = sizeof(PyByteArrayObject) + self->ob_alloc * sizeof(char);
    return PyLong_FromSsize_t(res);
}
static PyObject* bytearray_split ( PyByteArrayObject self,
PyObject args 
) [static]

Definition at line 1999 of file bytearrayobject.c.

{
    Py_ssize_t len = PyByteArray_GET_SIZE(self), n;
    Py_ssize_t maxsplit = -1;
    const char *s = PyByteArray_AS_STRING(self), *sub;
    PyObject *list, *subobj = Py_None;
    Py_buffer vsub;

    if (!PyArg_ParseTuple(args, "|On:split", &subobj, &maxsplit))
        return NULL;
    if (maxsplit < 0)
        maxsplit = PY_SSIZE_T_MAX;

    if (subobj == Py_None)
        return stringlib_split_whitespace((PyObject*) self, s, len, maxsplit);

    if (_getbuffer(subobj, &vsub) < 0)
        return NULL;
    sub = vsub.buf;
    n = vsub.len;

    list = stringlib_split(
        (PyObject*) self, s, len, sub, n, maxsplit
        );
    PyBuffer_Release(&vsub);
    return list;
}

Here is the call graph for this function:

static PyObject* bytearray_splitlines ( PyObject self,
PyObject args 
) [static]

Definition at line 2591 of file bytearrayobject.c.

{
    int keepends = 0;

    if (!PyArg_ParseTuple(args, "|i:splitlines", &keepends))
        return NULL;

    return stringlib_splitlines(
        (PyObject*) self, PyByteArray_AS_STRING(self),
        PyByteArray_GET_SIZE(self), keepends
        );
}

Here is the call graph for this function:

static PyObject* bytearray_startswith ( PyByteArrayObject self,
PyObject args 
) [static]

Definition at line 1286 of file bytearrayobject.c.

{
    Py_ssize_t start = 0;
    Py_ssize_t end = PY_SSIZE_T_MAX;
    PyObject *subobj;
    int result;

    if (!stringlib_parse_args_finds("startswith", args, &subobj, &start, &end))
        return NULL;
    if (PyTuple_Check(subobj)) {
        Py_ssize_t i;
        for (i = 0; i < PyTuple_GET_SIZE(subobj); i++) {
            result = _bytearray_tailmatch(self,
                                      PyTuple_GET_ITEM(subobj, i),
                                      start, end, -1);
            if (result == -1)
                return NULL;
            else if (result) {
                Py_RETURN_TRUE;
            }
        }
        Py_RETURN_FALSE;
    }
    result = _bytearray_tailmatch(self, subobj, start, end, -1);
    if (result == -1) {
        if (PyErr_ExceptionMatches(PyExc_TypeError))
            PyErr_Format(PyExc_TypeError, "startswith first arg must be bytes "
                         "or a tuple of bytes, not %s", Py_TYPE(subobj)->tp_name);
        return NULL;
    }
    else
        return PyBool_FromLong(result);
}

Here is the call graph for this function:

static PyObject* bytearray_str ( PyObject op) [static]

Definition at line 937 of file bytearrayobject.c.

{
        if (Py_BytesWarningFlag) {
                if (PyErr_WarnEx(PyExc_BytesWarning,
                                 "str() on a bytearray instance", 1))
                        return NULL;
        }
        return bytearray_repr((PyByteArrayObject*)op);
}

Here is the call graph for this function:

static PyObject* bytearray_strip ( PyByteArrayObject self,
PyObject args 
) [static]

Definition at line 2374 of file bytearrayobject.c.

{
    Py_ssize_t left, right, mysize, argsize;
    void *myptr, *argptr;
    PyObject *arg = Py_None;
    Py_buffer varg;
    if (!PyArg_ParseTuple(args, "|O:strip", &arg))
        return NULL;
    if (arg == Py_None) {
        argptr = "\t\n\r\f\v ";
        argsize = 6;
    }
    else {
        if (_getbuffer(arg, &varg) < 0)
            return NULL;
        argptr = varg.buf;
        argsize = varg.len;
    }
    myptr = self->ob_bytes;
    mysize = Py_SIZE(self);
    left = lstrip_helper(myptr, mysize, argptr, argsize);
    if (left == mysize)
        right = left;
    else
        right = rstrip_helper(myptr, mysize, argptr, argsize);
    if (arg != Py_None)
        PyBuffer_Release(&varg);
    return PyByteArray_FromStringAndSize(self->ob_bytes + left, right - left);
}

Here is the call graph for this function:

static PyObject* bytearray_subscript ( PyByteArrayObject self,
PyObject index 
) [static]

Definition at line 373 of file bytearrayobject.c.

{
    if (PyIndex_Check(index)) {
        Py_ssize_t i = PyNumber_AsSsize_t(index, PyExc_IndexError);

        if (i == -1 && PyErr_Occurred())
            return NULL;

        if (i < 0)
            i += PyByteArray_GET_SIZE(self);

        if (i < 0 || i >= Py_SIZE(self)) {
            PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
            return NULL;
        }
        return PyLong_FromLong((unsigned char)(self->ob_bytes[i]));
    }
    else if (PySlice_Check(index)) {
        Py_ssize_t start, stop, step, slicelength, cur, i;
        if (PySlice_GetIndicesEx(index,
                                 PyByteArray_GET_SIZE(self),
                                 &start, &stop, &step, &slicelength) < 0) {
            return NULL;
        }

        if (slicelength <= 0)
            return PyByteArray_FromStringAndSize("", 0);
        else if (step == 1) {
            return PyByteArray_FromStringAndSize(self->ob_bytes + start,
                                             slicelength);
        }
        else {
            char *source_buf = PyByteArray_AS_STRING(self);
            char *result_buf;
            PyObject *result;

            result = PyByteArray_FromStringAndSize(NULL, slicelength);
            if (result == NULL)
                return NULL;

            result_buf = PyByteArray_AS_STRING(result);
            for (cur = start, i = 0; i < slicelength;
                 cur += step, i++) {
                     result_buf[i] = source_buf[cur];
            }
            return result;
        }
    }
    else {
        PyErr_SetString(PyExc_TypeError, "bytearray indices must be integers");
        return NULL;
    }
}

Here is the call graph for this function:

static PyObject* bytearray_translate ( PyByteArrayObject self,
PyObject args 
) [static]

Definition at line 1373 of file bytearrayobject.c.

{
    register char *input, *output;
    register const char *table;
    register Py_ssize_t i, c;
    PyObject *input_obj = (PyObject*)self;
    const char *output_start;
    Py_ssize_t inlen;
    PyObject *result = NULL;
    int trans_table[256];
    PyObject *tableobj = NULL, *delobj = NULL;
    Py_buffer vtable, vdel;

    if (!PyArg_UnpackTuple(args, "translate", 1, 2,
                           &tableobj, &delobj))
          return NULL;

    if (tableobj == Py_None) {
        table = NULL;
        tableobj = NULL;
    } else if (_getbuffer(tableobj, &vtable) < 0) {
        return NULL;
    } else {
        if (vtable.len != 256) {
            PyErr_SetString(PyExc_ValueError,
                            "translation table must be 256 characters long");
            PyBuffer_Release(&vtable);
            return NULL;
        }
        table = (const char*)vtable.buf;
    }

    if (delobj != NULL) {
        if (_getbuffer(delobj, &vdel) < 0) {
            if (tableobj != NULL)
                PyBuffer_Release(&vtable);
            return NULL;
        }
    }
    else {
        vdel.buf = NULL;
        vdel.len = 0;
    }

    inlen = PyByteArray_GET_SIZE(input_obj);
    result = PyByteArray_FromStringAndSize((char *)NULL, inlen);
    if (result == NULL)
        goto done;
    output_start = output = PyByteArray_AsString(result);
    input = PyByteArray_AS_STRING(input_obj);

    if (vdel.len == 0 && table != NULL) {
        /* If no deletions are required, use faster code */
        for (i = inlen; --i >= 0; ) {
            c = Py_CHARMASK(*input++);
            *output++ = table[c];
        }
        goto done;
    }

    if (table == NULL) {
        for (i = 0; i < 256; i++)
            trans_table[i] = Py_CHARMASK(i);
    } else {
        for (i = 0; i < 256; i++)
            trans_table[i] = Py_CHARMASK(table[i]);
    }

    for (i = 0; i < vdel.len; i++)
        trans_table[(int) Py_CHARMASK( ((unsigned char*)vdel.buf)[i] )] = -1;

    for (i = inlen; --i >= 0; ) {
        c = Py_CHARMASK(*input++);
        if (trans_table[c] != -1)
            if (Py_CHARMASK(*output++ = (char)trans_table[c]) == c)
                    continue;
    }
    /* Fix the size of the resulting string */
    if (inlen > 0)
        PyByteArray_Resize(result, output - output_start);

done:
    if (tableobj != NULL)
        PyBuffer_Release(&vtable);
    if (delobj != NULL)
        PyBuffer_Release(&vdel);
    return result;
}

Here is the call graph for this function:

static void bytearrayiter_dealloc ( bytesiterobject it) [static]

Definition at line 2867 of file bytearrayobject.c.

Here is the call graph for this function:

static PyObject* bytearrayiter_next ( bytesiterobject it) [static]

Definition at line 2882 of file bytearrayobject.c.

{
    PyByteArrayObject *seq;
    PyObject *item;

    assert(it != NULL);
    seq = it->it_seq;
    if (seq == NULL)
        return NULL;
    assert(PyByteArray_Check(seq));

    if (it->it_index < PyByteArray_GET_SIZE(seq)) {
        item = PyLong_FromLong(
            (unsigned char)seq->ob_bytes[it->it_index]);
        if (item != NULL)
            ++it->it_index;
        return item;
    }

    Py_DECREF(seq);
    it->it_seq = NULL;
    return NULL;
}

Here is the call graph for this function:

static int bytearrayiter_traverse ( bytesiterobject it,
visitproc  visit,
void arg 
) [static]

Definition at line 2875 of file bytearrayobject.c.

{
    Py_VISIT(it->it_seq);
    return 0;
}

Definition at line 2907 of file bytearrayobject.c.

{
    Py_ssize_t len = 0;
    if (it->it_seq)
        len = PyByteArray_GET_SIZE(it->it_seq) - it->it_index;
    return PyLong_FromSsize_t(len);
}
static int hex_digit_to_int ( Py_UNICODE  c) [static]

Definition at line 2612 of file bytearrayobject.c.

{
    if (c >= 128)
        return -1;
    if (Py_ISDIGIT(c))
        return c - '0';
    else {
        if (Py_ISUPPER(c))
            c = Py_TOLOWER(c);
        if (c >= 'a' && c <= 'f')
            return c - 'a' + 10;
    }
    return -1;
}

Here is the caller graph for this function:

static Py_ssize_t lstrip_helper ( unsigned char *  myptr,
Py_ssize_t  mysize,
void argptr,
Py_ssize_t  argsize 
) [static]

Definition at line 2348 of file bytearrayobject.c.

{
    Py_ssize_t i = 0;
    while (i < mysize && memchr(argptr, myptr[i], argsize))
        i++;
    return i;
}

Here is the caller graph for this function:

Py_LOCAL ( int  )

Definition at line 1238 of file bytearrayobject.c.

{
    Py_ssize_t len = PyByteArray_GET_SIZE(self);
    const char* str;
    Py_buffer vsubstr;
    int rv = 0;

    str = PyByteArray_AS_STRING(self);

    if (_getbuffer(substr, &vsubstr) < 0)
        return -1;

    ADJUST_INDICES(start, end, len);

    if (direction < 0) {
        /* startswith */
        if (start+vsubstr.len > len) {
            goto done;
        }
    } else {
        /* endswith */
        if (end-start < vsubstr.len || start > len) {
            goto done;
        }

        if (end-vsubstr.len > start)
            start = end - vsubstr.len;
    }
    if (end-start >= vsubstr.len)
        rv = ! memcmp(str+start, vsubstr.buf, vsubstr.len);

done:
    PyBuffer_Release(&vsubstr);
    return rv;
}

Here is the call graph for this function:

Definition at line 1477 of file bytearrayobject.c.

{
    /* always return a new bytearray */
    return (PyByteArrayObject *)PyByteArray_FromStringAndSize(
            PyByteArray_AS_STRING(self),
            PyByteArray_GET_SIZE(self));
}

Here is the call graph for this function:

Definition at line 1076 of file bytearrayobject.c.

{
    PyObject *subobj;
    Py_buffer subbuf;
    Py_ssize_t start=0, end=PY_SSIZE_T_MAX;
    Py_ssize_t res;

    if (!stringlib_parse_args_finds("find/rfind/index/rindex",
                                    args, &subobj, &start, &end))
        return -2;
    if (_getbuffer(subobj, &subbuf) < 0)
        return -2;
    if (dir > 0)
        res = stringlib_find_slice(
            PyByteArray_AS_STRING(self), PyByteArray_GET_SIZE(self),
            subbuf.buf, subbuf.len, start, end);
    else
        res = stringlib_rfind_slice(
            PyByteArray_AS_STRING(self), PyByteArray_GET_SIZE(self),
            subbuf.buf, subbuf.len, start, end);
    PyBuffer_Release(&subbuf);
    return res;
}

Here is the call graph for this function:

char* PyByteArray_AsString ( PyObject self)

Definition at line 168 of file bytearrayobject.c.

{
    assert(self != NULL);
    assert(PyByteArray_Check(self));

    return PyByteArray_AS_STRING(self);
}

Here is the caller graph for this function:

Definition at line 227 of file bytearrayobject.c.

{
    Py_ssize_t size;
    Py_buffer va, vb;
    PyByteArrayObject *result = NULL;

    va.len = -1;
    vb.len = -1;
    if (_getbuffer(a, &va) < 0  ||
        _getbuffer(b, &vb) < 0) {
            PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",
                         Py_TYPE(a)->tp_name, Py_TYPE(b)->tp_name);
            goto done;
    }

    size = va.len + vb.len;
    if (size < 0) {
            PyErr_NoMemory();
            goto done;
    }

    result = (PyByteArrayObject *) PyByteArray_FromStringAndSize(NULL, size);
    if (result != NULL) {
        memcpy(result->ob_bytes, va.buf, va.len);
        memcpy(result->ob_bytes + va.len, vb.buf, vb.len);
    }

  done:
    if (va.len != -1)
        PyBuffer_Release(&va);
    if (vb.len != -1)
        PyBuffer_Release(&vb);
    return (PyObject *)result;
}

Here is the call graph for this function:

Definition at line 11 of file bytearrayobject.c.

{
}

Here is the caller graph for this function:

Definition at line 109 of file bytearrayobject.c.

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* PyByteArray_FromStringAndSize ( const char *  bytes,
Py_ssize_t  size 
)

Definition at line 116 of file bytearrayobject.c.

{
    PyByteArrayObject *new;
    Py_ssize_t alloc;

    if (size < 0) {
        PyErr_SetString(PyExc_SystemError,
            "Negative size passed to PyByteArray_FromStringAndSize");
        return NULL;
    }

    /* Prevent buffer overflow when setting alloc to size+1. */
    if (size == PY_SSIZE_T_MAX) {
        return PyErr_NoMemory();
    }

    new = PyObject_New(PyByteArrayObject, &PyByteArray_Type);
    if (new == NULL)
        return NULL;

    if (size == 0) {
        new->ob_bytes = NULL;
        alloc = 0;
    }
    else {
        alloc = size + 1;
        new->ob_bytes = PyMem_Malloc(alloc);
        if (new->ob_bytes == NULL) {
            Py_DECREF(new);
            return PyErr_NoMemory();
        }
        if (bytes != NULL && size > 0)
            memcpy(new->ob_bytes, bytes, size);
        new->ob_bytes[size] = '\0';  /* Trailing null byte */
    }
    Py_SIZE(new) = size;
    new->ob_alloc = alloc;
    new->ob_exports = 0;

    return (PyObject *)new;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 16 of file bytearrayobject.c.

{
    return 1;
}

Here is the caller graph for this function:

int PyByteArray_Resize ( PyObject self,
Py_ssize_t  size 
)

Definition at line 177 of file bytearrayobject.c.

{
    void *sval;
    Py_ssize_t alloc = ((PyByteArrayObject *)self)->ob_alloc;

    assert(self != NULL);
    assert(PyByteArray_Check(self));
    assert(size >= 0);

    if (size == Py_SIZE(self)) {
        return 0;
    }
    if (!_canresize((PyByteArrayObject *)self)) {
        return -1;
    }

    if (size < alloc / 2) {
        /* Major downsize; resize down to exact size */
        alloc = size + 1;
    }
    else if (size < alloc) {
        /* Within allocated size; quick exit */
        Py_SIZE(self) = size;
        ((PyByteArrayObject *)self)->ob_bytes[size] = '\0'; /* Trailing null */
        return 0;
    }
    else if (size <= alloc * 1.125) {
        /* Moderate upsize; overallocate similar to list_resize() */
        alloc = size + (size >> 3) + (size < 9 ? 3 : 6);
    }
    else {
        /* Major upsize; resize up to exact size */
        alloc = size + 1;
    }

    sval = PyMem_Realloc(((PyByteArrayObject *)self)->ob_bytes, alloc);
    if (sval == NULL) {
        PyErr_NoMemory();
        return -1;
    }

    ((PyByteArrayObject *)self)->ob_bytes = sval;
    Py_SIZE(self) = size;
    ((PyByteArrayObject *)self)->ob_alloc = alloc;
    ((PyByteArrayObject *)self)->ob_bytes[size] = '\0'; /* Trailing null byte */

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 159 of file bytearrayobject.c.

{
    assert(self != NULL);
    assert(PyByteArray_Check(self));

    return PyByteArray_GET_SIZE(self);
}
PyDoc_STRVAR ( find__doc__  ,
"B.find(sub[, start[, end]]) -> int\n\\n\Return the lowest index in B where subsection sub is  found,
\n\such that sub is contained within B.Optional\n\arguments start and end are interpreted as in slice notation.\n\\n\Return-1 on failure."  [start, end] 
)
PyDoc_STRVAR ( count__doc__  ,
"B.count(sub[, start[, end]]) -> int\n\\n\Return the number of non-overlapping occurrences of subsection sub in\n\bytes B. Optional arguments start and end are interpreted\n\as in slice notation."  [start:end] 
)
PyDoc_STRVAR ( index__doc__  ,
"B.index(sub[, start[, end]]) -> int\n\\n\Like B.find() but raise ValueError when the subsection is not found."   
)
PyDoc_STRVAR ( rfind__doc__  ,
"B.rfind(sub[, start[, end]]) -> int\n\\n\Return the highest index in B where subsection sub is  found,
\n\such that sub is contained within B.Optional\n\arguments start and end are interpreted as in slice notation.\n\\n\Return-1 on failure."  [start, end] 
)
PyDoc_STRVAR ( rindex__doc__  ,
"B.rindex(sub[, start[, end]]) -> int\n\\n\Like B.rfind() but raise ValueError when the subsection is not found."   
)
PyDoc_STRVAR ( startswith__doc__  ,
"B.startswith(prefix[, start[, end]]) -> bool\n\\n\Return True if B starts with the specified  prefix,
False otherwise.\n\With optional  start,
test B beginning at that position.\n\With optional  end,
stop comparing B at that position.\n\prefix can also be a tuple of bytes to try."   
)
PyDoc_STRVAR ( endswith__doc__  ,
"B.endswith(suffix[, start[, end]]) -> bool\n\\n\Return True if B ends with the specified  suffix,
False otherwise.\n\With optional  start,
test B beginning at that position.\n\With optional  end,
stop comparing B at that position.\n\suffix can also be a tuple of bytes to try."   
)
PyDoc_STRVAR ( translate__doc__  ,
"B.translate(table[, deletechars]) -> bytearray\n\\n\Return a copy of  B,
where all characters occurring in the\n\optional argument deletechars are  removed,
and the remaining\n\characters have been mapped through the given translation\n\  table,
which must be a bytes object of length 256."   
)
PyDoc_STRVAR ( replace__doc__  ,
"B.replace(old, new[, count]) -> bytearray\n\\n\Return a copy of B with all occurrences of subsection\n\old replaced by new. If the optional argument count is\n\  given,
only the first count occurrences are replaced."   
)
PyDoc_STRVAR ( split__doc__  ,
"B.split([sep[, maxsplit]]) -> list of bytearrays\n\\n\Return a list of the sections in  B,
using sep as the delimiter.\n\If sep is not  given,
B is split on ASCII whitespace characters\n\(space, tab, return, newline, formfeed, vertical tab).\n\If maxsplit is  given,
at most maxsplit splits are done."   
)
PyDoc_STRVAR ( partition__doc__  ,
"B.partition(sep) -> (head, sep, tail)\n\\n\Search for the separator sep in  B,
and return the part before  it,
\n\the separator  itself,
and the part after it.If the separator is not\n\  found,
returns B and two empty bytearray objects."   
)
PyDoc_STRVAR ( rpartition__doc__  ,
"B.rpartition(sep) -> (head, sep, tail)\n\\n\Search for the separator sep in  B,
starting at the end of  B,
\n\and return the part before  it,
the separator  itself,
and the\n\part after it.If the separator is not  found,
returns two empty\n\bytearray objects and B."   
)
PyDoc_STRVAR ( rsplit__doc__  ,
"B.rsplit(sep[, maxsplit]) -> list of bytearrays\n\\n\Return a list of the sections in  B,
using sep as the  delimiter,
\n\starting at the end of B and working to the front.\n\If sep is not  given,
B is split on ASCII whitespace characters\n\(space, tab, return, newline, formfeed, vertical tab).\n\If maxsplit is  given,
at most maxsplit splits are done."   
)
PyDoc_STRVAR ( reverse__doc__  ,
"B.reverse() -> None\n\\n\Reverse the order of the values in B in place."   
)
PyDoc_STRVAR ( insert__doc__  ,
"B.insert(index, int) -> None\n\\n\Insert a single item into the bytearray before the given index."   
)
PyDoc_STRVAR ( append__doc__  ,
"B.append(int) -> None\n\\n\Append a single item to the end of B."   
)
PyDoc_STRVAR ( extend__doc__  ,
"B.extend(iterable_of_ints) -> None\n\\n\Append all the elements from the iterator or sequence to the\n\end of B."   
)
PyDoc_STRVAR ( pop__doc__  ,
"B.pop([index]) -> int\n\\n\Remove and return a single item from B. If no index\n\argument is  given,
will pop the last value."   
)
PyDoc_STRVAR ( remove__doc__  ,
"B.remove(int) -> None\n\\n\Remove the first occurrence of a value in B."   
)
PyDoc_STRVAR ( strip__doc__  ,
"B.strip([bytes]) -> bytearray\n\\n\Strip leading and trailing bytes contained in the argument\n\and return the result as a new bytearray.\n\If the argument is  omitted,
strip ASCII whitespace."   
)
PyDoc_STRVAR ( lstrip__doc__  ,
"B.lstrip([bytes]) -> bytearray\n\\n\Strip leading bytes contained in the argument\n\and return the result as a new bytearray.\n\If the argument is  omitted,
strip leading ASCII whitespace."   
)
PyDoc_STRVAR ( rstrip__doc__  ,
"B.rstrip([bytes]) -> bytearray\n\\n\Strip trailing bytes contained in the argument\n\and return the result as a new bytearray.\n\If the argument is  omitted,
strip trailing ASCII whitespace."   
)
PyDoc_STRVAR ( decode_doc  ,
"B.decode(encoding='utf-8', errors='strict') -> str\n\\n\Decode B using the codec registered for encoding. Default encoding\n\is 'utf-8'. errors may be given to set a different error\n\handling scheme. Default is 'strict' meaning that encoding errors raise\n\a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'\n\as well as any other name registered with codecs.register_error that is\n\able to handle UnicodeDecodeErrors."   
)
PyDoc_STRVAR ( alloc_doc  ,
"B.__alloc__() -> int\n\\n\Return the number of bytes actually allocated."   
)
PyDoc_STRVAR ( join_doc  ,
"B.join(iterable_of_bytes) -> bytearray\n\\n\Concatenate any number of bytes/bytearray  objects,
with B\n\in between each  pair,
and return the result as a new bytearray."   
)
PyDoc_STRVAR ( splitlines__doc__  ,
"B.splitlines([keepends]) -> list of lines\n\\n\Return a list of the lines in  B,
breaking at line boundaries.\n\Line breaks are not included in the resulting list unless keepends\n\is given and true."   
)
PyDoc_STRVAR ( fromhex_doc  ,
"bytearray.fromhex(string) -> bytearray (static method)\n\\n\Create a bytearray object from a string of hexadecimal numbers.\n\Spaces between two numbers are accepted.\n\Example: bytearray.fromhex('B9 01EF') -> bytearray(b'\\xb9\\x01\\xef')."   
)
PyDoc_STRVAR ( reduce_doc  ,
"Return state information for pickling."   
)
PyDoc_STRVAR ( sizeof_doc  ,
"B.__sizeof__() -> int\n\ \n\Returns the size of B in  memory,
in bytes  
)
PyDoc_STRVAR ( bytearray_doc  ,
"bytearray(iterable_of_ints) -> bytearray\n\bytearray(string, encoding[, errors]) -> bytearray\n\bytearray(bytes_or_bytearray) -> mutable copy of bytes_or_bytearray\n\bytearray(memory_view) -> bytearray\n\\n\Construct an mutable bytearray object from:\n\ - an iterable yielding integers in range(256)\n\ - a text string encoded using the specified encoding\n\ - a bytes or a bytearray object\n\ - any object implementing the buffer API.\n\\n\bytearray(int) -> bytearray\n\\n\Construct a zero-initialized bytearray of the given length."   
)
PyDoc_STRVAR ( length_hint_doc  ,
"Private method returning an estimate of len(list(it))."   
)
static Py_ssize_t rstrip_helper ( unsigned char *  myptr,
Py_ssize_t  mysize,
void argptr,
Py_ssize_t  argsize 
) [static]

Definition at line 2358 of file bytearrayobject.c.

{
    Py_ssize_t i = mysize - 1;
    while (i >= 0 && memchr(argptr, myptr[i], argsize))
        i--;
    return i + 1;
}

Here is the caller graph for this function:


Variable Documentation

Definition at line 8 of file bytearrayobject.c.

Definition at line 2731 of file bytearrayobject.c.

Initial value:
 {
    {"__length_hint__", (PyCFunction)bytesarrayiter_length_hint, METH_NOARGS,
     length_hint_doc},
    {NULL, NULL} 
}

Definition at line 2918 of file bytearrayobject.c.

Definition at line 2816 of file bytearrayobject.c.

Definition at line 2924 of file bytearrayobject.c.