EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.10 / Objects / stringlib / transmogrify.h

/* NOTE: this API is -ONLY- for use with single byte character strings. */\r
/* Do not use it with Unicode. */\r
\r
/* the more complicated methods.  parts of these should be pulled out into the\r
   shared code in bytes_methods.c to cut down on duplicate code bloat.  */\r
\r
PyDoc_STRVAR(expandtabs__doc__,\r
"B.expandtabs([tabsize]) -> copy of B\n\\r
\n\\r
Return a copy of B where all tab characters are expanded using spaces.\n\\r
If tabsize is not given, a tab size of 8 characters is assumed.");\r
\r
static PyObject*\r
stringlib_expandtabs(PyObject *self, PyObject *args)\r
{\r
    const char *e, *p;\r
    char *q;\r
    Py_ssize_t i, j;\r
    PyObject *u;\r
    int tabsize = 8;\r
    \r
    if (!PyArg_ParseTuple(args, "|i:expandtabs", &tabsize))\r
        return NULL;\r
    \r
    /* First pass: determine size of output string */\r
    i = j = 0;\r
    e = STRINGLIB_STR(self) + STRINGLIB_LEN(self);\r
    for (p = STRINGLIB_STR(self); p < e; p++) {\r
        if (*p == '\t') {\r
            if (tabsize > 0) {\r
                Py_ssize_t incr = tabsize - (j % tabsize);\r
                if (j > PY_SSIZE_T_MAX - incr)\r
                    goto overflow;\r
                j += incr;\r
            }\r
        }\r
        else {\r
            if (j > PY_SSIZE_T_MAX - 1)\r
                goto overflow;\r
            j++;\r
            if (*p == '\n' || *p == '\r') {\r
                if (i > PY_SSIZE_T_MAX - j)\r
                    goto overflow;\r
                i += j;\r
                j = 0;\r
            }\r
        }\r
    }\r
    \r
    if (i > PY_SSIZE_T_MAX - j)\r
        goto overflow;\r
    \r
    /* Second pass: create output string and fill it */\r
    u = STRINGLIB_NEW(NULL, i + j);\r
    if (!u)\r
        return NULL;\r
    \r
    j = 0;\r
    q = STRINGLIB_STR(u);\r
    \r
    for (p = STRINGLIB_STR(self); p < e; p++) {\r
        if (*p == '\t') {\r
            if (tabsize > 0) {\r
                i = tabsize - (j % tabsize);\r
                j += i;\r
                while (i--)\r
                    *q++ = ' ';\r
            }\r
        }\r
        else {\r
            j++;\r
            *q++ = *p;\r
            if (*p == '\n' || *p == '\r')\r
                j = 0;\r
        }\r
    }\r
\r
    return u;\r
  overflow:\r
    PyErr_SetString(PyExc_OverflowError, "result too long");\r
    return NULL;\r
}\r
\r
Py_LOCAL_INLINE(PyObject *)\r
pad(PyObject *self, Py_ssize_t left, Py_ssize_t right, char fill)\r
{\r
    PyObject *u;\r
\r
    if (left < 0)\r
        left = 0;\r
    if (right < 0)\r
        right = 0;\r
\r
    if (left == 0 && right == 0 && STRINGLIB_CHECK_EXACT(self)) {\r
#if STRINGLIB_MUTABLE\r
        /* We're defined as returning a copy;  If the object is mutable\r
         * that means we must make an identical copy. */\r
        return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));\r
#else\r
        Py_INCREF(self);\r
        return (PyObject *)self;\r
#endif /* STRINGLIB_MUTABLE */\r
    }\r
\r
    u = STRINGLIB_NEW(NULL,\r
				   left + STRINGLIB_LEN(self) + right);\r
    if (u) {\r
        if (left)\r
            memset(STRINGLIB_STR(u), fill, left);\r
        Py_MEMCPY(STRINGLIB_STR(u) + left,\r
	       STRINGLIB_STR(self),\r
	       STRINGLIB_LEN(self));\r
        if (right)\r
            memset(STRINGLIB_STR(u) + left + STRINGLIB_LEN(self),\r
		   fill, right);\r
    }\r
\r
    return u;\r
}\r
\r
PyDoc_STRVAR(ljust__doc__,\r
"B.ljust(width[, fillchar]) -> copy of B\n"\r
"\n"\r
"Return B left justified in a string of length width. Padding is\n"\r
"done using the specified fill character (default is a space).");\r
\r
static PyObject *\r
stringlib_ljust(PyObject *self, PyObject *args)\r
{\r
    Py_ssize_t width;\r
    char fillchar = ' ';\r
\r
    if (!PyArg_ParseTuple(args, "n|c:ljust", &width, &fillchar))\r
        return NULL;\r
\r
    if (STRINGLIB_LEN(self) >= width && STRINGLIB_CHECK_EXACT(self)) {\r
#if STRINGLIB_MUTABLE\r
        /* We're defined as returning a copy;  If the object is mutable\r
         * that means we must make an identical copy. */\r
        return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));\r
#else\r
        Py_INCREF(self);\r
        return (PyObject*) self;\r
#endif\r
    }\r
\r
    return pad(self, 0, width - STRINGLIB_LEN(self), fillchar);\r
}\r
\r
\r
PyDoc_STRVAR(rjust__doc__,\r
"B.rjust(width[, fillchar]) -> copy of B\n"\r
"\n"\r
"Return B right justified in a string of length width. Padding is\n"\r
"done using the specified fill character (default is a space)");\r
\r
static PyObject *\r
stringlib_rjust(PyObject *self, PyObject *args)\r
{\r
    Py_ssize_t width;\r
    char fillchar = ' ';\r
\r
    if (!PyArg_ParseTuple(args, "n|c:rjust", &width, &fillchar))\r
        return NULL;\r
\r
    if (STRINGLIB_LEN(self) >= width && STRINGLIB_CHECK_EXACT(self)) {\r
#if STRINGLIB_MUTABLE\r
        /* We're defined as returning a copy;  If the object is mutable\r
         * that means we must make an identical copy. */\r
        return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));\r
#else\r
        Py_INCREF(self);\r
        return (PyObject*) self;\r
#endif\r
    }\r
\r
    return pad(self, width - STRINGLIB_LEN(self), 0, fillchar);\r
}\r
\r
\r
PyDoc_STRVAR(center__doc__,\r
"B.center(width[, fillchar]) -> copy of B\n"\r
"\n"\r
"Return B centered in a string of length width.  Padding is\n"\r
"done using the specified fill character (default is a space).");\r
\r
static PyObject *\r
stringlib_center(PyObject *self, PyObject *args)\r
{\r
    Py_ssize_t marg, left;\r
    Py_ssize_t width;\r
    char fillchar = ' ';\r
\r
    if (!PyArg_ParseTuple(args, "n|c:center", &width, &fillchar))\r
        return NULL;\r
\r
    if (STRINGLIB_LEN(self) >= width && STRINGLIB_CHECK_EXACT(self)) {\r
#if STRINGLIB_MUTABLE\r
        /* We're defined as returning a copy;  If the object is mutable\r
         * that means we must make an identical copy. */\r
        return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));\r
#else\r
        Py_INCREF(self);\r
        return (PyObject*) self;\r
#endif\r
    }\r
\r
    marg = width - STRINGLIB_LEN(self);\r
    left = marg / 2 + (marg & width & 1);\r
\r
    return pad(self, left, marg - left, fillchar);\r
}\r
\r
PyDoc_STRVAR(zfill__doc__,\r
"B.zfill(width) -> copy of B\n"\r
"\n"\r
"Pad a numeric string B with zeros on the left, to fill a field\n"\r
"of the specified width.  B is never truncated.");\r
\r
static PyObject *\r
stringlib_zfill(PyObject *self, PyObject *args)\r
{\r
    Py_ssize_t fill;\r
    PyObject *s;\r
    char *p;\r
    Py_ssize_t width;\r
\r
    if (!PyArg_ParseTuple(args, "n:zfill", &width))\r
        return NULL;\r
\r
    if (STRINGLIB_LEN(self) >= width) {\r
        if (STRINGLIB_CHECK_EXACT(self)) {\r
#if STRINGLIB_MUTABLE\r
            /* We're defined as returning a copy;  If the object is mutable\r
             * that means we must make an identical copy. */\r
            return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));\r
#else\r
            Py_INCREF(self);\r
            return (PyObject*) self;\r
#endif\r
        }\r
        else\r
            return STRINGLIB_NEW(\r
                STRINGLIB_STR(self),\r
                STRINGLIB_LEN(self)\r
            );\r
    }\r
\r
    fill = width - STRINGLIB_LEN(self);\r
\r
    s = pad(self, fill, 0, '0');\r
\r
    if (s == NULL)\r
        return NULL;\r
\r
    p = STRINGLIB_STR(s);\r
    if (p[fill] == '+' || p[fill] == '-') {\r
        /* move sign to beginning of string */\r
        p[0] = p[fill];\r
        p[fill] = '0';\r
    }\r
\r
    return (PyObject*) s;\r
}\r