• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* NOTE: this API is -ONLY- for use with single byte character strings. */
2 /* Do not use it with Unicode. */
3 
4 /* the more complicated methods.  parts of these should be pulled out into the
5    shared code in bytes_methods.c to cut down on duplicate code bloat.  */
6 
7 PyDoc_STRVAR(expandtabs__doc__,
8 "B.expandtabs([tabsize]) -> copy of B\n\
9 \n\
10 Return a copy of B where all tab characters are expanded using spaces.\n\
11 If tabsize is not given, a tab size of 8 characters is assumed.");
12 
13 static PyObject*
stringlib_expandtabs(PyObject * self,PyObject * args)14 stringlib_expandtabs(PyObject *self, PyObject *args)
15 {
16     const char *e, *p;
17     char *q;
18     Py_ssize_t i, j;
19     PyObject *u;
20     int tabsize = 8;
21 
22     if (!PyArg_ParseTuple(args, "|i:expandtabs", &tabsize))
23         return NULL;
24 
25     /* First pass: determine size of output string */
26     i = j = 0;
27     e = STRINGLIB_STR(self) + STRINGLIB_LEN(self);
28     for (p = STRINGLIB_STR(self); p < e; p++) {
29         if (*p == '\t') {
30             if (tabsize > 0) {
31                 Py_ssize_t incr = tabsize - (j % tabsize);
32                 if (j > PY_SSIZE_T_MAX - incr)
33                     goto overflow;
34                 j += incr;
35             }
36         }
37         else {
38             if (j > PY_SSIZE_T_MAX - 1)
39                 goto overflow;
40             j++;
41             if (*p == '\n' || *p == '\r') {
42                 if (i > PY_SSIZE_T_MAX - j)
43                     goto overflow;
44                 i += j;
45                 j = 0;
46             }
47         }
48     }
49 
50     if (i > PY_SSIZE_T_MAX - j)
51         goto overflow;
52 
53     /* Second pass: create output string and fill it */
54     u = STRINGLIB_NEW(NULL, i + j);
55     if (!u)
56         return NULL;
57 
58     j = 0;
59     q = STRINGLIB_STR(u);
60 
61     for (p = STRINGLIB_STR(self); p < e; p++) {
62         if (*p == '\t') {
63             if (tabsize > 0) {
64                 i = tabsize - (j % tabsize);
65                 j += i;
66                 while (i--)
67                     *q++ = ' ';
68             }
69         }
70         else {
71             j++;
72             *q++ = *p;
73             if (*p == '\n' || *p == '\r')
74                 j = 0;
75         }
76     }
77 
78     return u;
79   overflow:
80     PyErr_SetString(PyExc_OverflowError, "result too long");
81     return NULL;
82 }
83 
84 Py_LOCAL_INLINE(PyObject *)
pad(PyObject * self,Py_ssize_t left,Py_ssize_t right,char fill)85 pad(PyObject *self, Py_ssize_t left, Py_ssize_t right, char fill)
86 {
87     PyObject *u;
88 
89     if (left < 0)
90         left = 0;
91     if (right < 0)
92         right = 0;
93 
94     if (left == 0 && right == 0 && STRINGLIB_CHECK_EXACT(self)) {
95 #if STRINGLIB_MUTABLE
96         /* We're defined as returning a copy;  If the object is mutable
97          * that means we must make an identical copy. */
98         return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));
99 #else
100         Py_INCREF(self);
101         return (PyObject *)self;
102 #endif /* STRINGLIB_MUTABLE */
103     }
104 
105     u = STRINGLIB_NEW(NULL,
106 				   left + STRINGLIB_LEN(self) + right);
107     if (u) {
108         if (left)
109             memset(STRINGLIB_STR(u), fill, left);
110         Py_MEMCPY(STRINGLIB_STR(u) + left,
111 	       STRINGLIB_STR(self),
112 	       STRINGLIB_LEN(self));
113         if (right)
114             memset(STRINGLIB_STR(u) + left + STRINGLIB_LEN(self),
115 		   fill, right);
116     }
117 
118     return u;
119 }
120 
121 PyDoc_STRVAR(ljust__doc__,
122 "B.ljust(width[, fillchar]) -> copy of B\n"
123 "\n"
124 "Return B left justified in a string of length width. Padding is\n"
125 "done using the specified fill character (default is a space).");
126 
127 static PyObject *
stringlib_ljust(PyObject * self,PyObject * args)128 stringlib_ljust(PyObject *self, PyObject *args)
129 {
130     Py_ssize_t width;
131     char fillchar = ' ';
132 
133     if (!PyArg_ParseTuple(args, "n|c:ljust", &width, &fillchar))
134         return NULL;
135 
136     if (STRINGLIB_LEN(self) >= width && STRINGLIB_CHECK_EXACT(self)) {
137 #if STRINGLIB_MUTABLE
138         /* We're defined as returning a copy;  If the object is mutable
139          * that means we must make an identical copy. */
140         return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));
141 #else
142         Py_INCREF(self);
143         return (PyObject*) self;
144 #endif
145     }
146 
147     return pad(self, 0, width - STRINGLIB_LEN(self), fillchar);
148 }
149 
150 
151 PyDoc_STRVAR(rjust__doc__,
152 "B.rjust(width[, fillchar]) -> copy of B\n"
153 "\n"
154 "Return B right justified in a string of length width. Padding is\n"
155 "done using the specified fill character (default is a space)");
156 
157 static PyObject *
stringlib_rjust(PyObject * self,PyObject * args)158 stringlib_rjust(PyObject *self, PyObject *args)
159 {
160     Py_ssize_t width;
161     char fillchar = ' ';
162 
163     if (!PyArg_ParseTuple(args, "n|c:rjust", &width, &fillchar))
164         return NULL;
165 
166     if (STRINGLIB_LEN(self) >= width && STRINGLIB_CHECK_EXACT(self)) {
167 #if STRINGLIB_MUTABLE
168         /* We're defined as returning a copy;  If the object is mutable
169          * that means we must make an identical copy. */
170         return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));
171 #else
172         Py_INCREF(self);
173         return (PyObject*) self;
174 #endif
175     }
176 
177     return pad(self, width - STRINGLIB_LEN(self), 0, fillchar);
178 }
179 
180 
181 PyDoc_STRVAR(center__doc__,
182 "B.center(width[, fillchar]) -> copy of B\n"
183 "\n"
184 "Return B centered in a string of length width.  Padding is\n"
185 "done using the specified fill character (default is a space).");
186 
187 static PyObject *
stringlib_center(PyObject * self,PyObject * args)188 stringlib_center(PyObject *self, PyObject *args)
189 {
190     Py_ssize_t marg, left;
191     Py_ssize_t width;
192     char fillchar = ' ';
193 
194     if (!PyArg_ParseTuple(args, "n|c:center", &width, &fillchar))
195         return NULL;
196 
197     if (STRINGLIB_LEN(self) >= width && STRINGLIB_CHECK_EXACT(self)) {
198 #if STRINGLIB_MUTABLE
199         /* We're defined as returning a copy;  If the object is mutable
200          * that means we must make an identical copy. */
201         return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));
202 #else
203         Py_INCREF(self);
204         return (PyObject*) self;
205 #endif
206     }
207 
208     marg = width - STRINGLIB_LEN(self);
209     left = marg / 2 + (marg & width & 1);
210 
211     return pad(self, left, marg - left, fillchar);
212 }
213 
214 PyDoc_STRVAR(zfill__doc__,
215 "B.zfill(width) -> copy of B\n"
216 "\n"
217 "Pad a numeric string B with zeros on the left, to fill a field\n"
218 "of the specified width.  B is never truncated.");
219 
220 static PyObject *
stringlib_zfill(PyObject * self,PyObject * args)221 stringlib_zfill(PyObject *self, PyObject *args)
222 {
223     Py_ssize_t fill;
224     PyObject *s;
225     char *p;
226     Py_ssize_t width;
227 
228     if (!PyArg_ParseTuple(args, "n:zfill", &width))
229         return NULL;
230 
231     if (STRINGLIB_LEN(self) >= width) {
232         if (STRINGLIB_CHECK_EXACT(self)) {
233 #if STRINGLIB_MUTABLE
234             /* We're defined as returning a copy;  If the object is mutable
235              * that means we must make an identical copy. */
236             return STRINGLIB_NEW(STRINGLIB_STR(self), STRINGLIB_LEN(self));
237 #else
238             Py_INCREF(self);
239             return (PyObject*) self;
240 #endif
241         }
242         else
243             return STRINGLIB_NEW(
244                 STRINGLIB_STR(self),
245                 STRINGLIB_LEN(self)
246             );
247     }
248 
249     fill = width - STRINGLIB_LEN(self);
250 
251     s = pad(self, fill, 0, '0');
252 
253     if (s == NULL)
254         return NULL;
255 
256     p = STRINGLIB_STR(s);
257     if (p[fill] == '+' || p[fill] == '-') {
258         /* move sign to beginning of string */
259         p[0] = p[fill];
260         p[fill] = '0';
261     }
262 
263     return (PyObject*) s;
264 }
265