blob: 82e97c0aff7da48f1c9342bf3c4f0ab7d35a807e [file] [log] [blame]
Damiend99b0522013-12-21 18:17:45 +00001#include <stdlib.h>
2#include <stdint.h>
3#include <stdarg.h>
4#include <string.h>
5#include <assert.h>
6
7#include "nlr.h"
8#include "misc.h"
9#include "mpconfig.h"
Damien George55baff42014-01-21 21:40:13 +000010#include "qstr.h"
Damiend99b0522013-12-21 18:17:45 +000011#include "obj.h"
12#include "runtime0.h"
13#include "runtime.h"
14
15typedef struct _mp_obj_str_t {
16 mp_obj_base_t base;
Damien George5fa93b62014-01-22 14:35:10 +000017 machine_uint_t hash : 16; // XXX here we assume the hash size is 16 bits (it is at the moment; see qstr.c)
18 machine_uint_t len : 16; // len == number of bytes used in data, alloc = len + 1 because (at the moment) we also append a null byte
19 byte data[];
Damiend99b0522013-12-21 18:17:45 +000020} mp_obj_str_t;
21
Damien George5fa93b62014-01-22 14:35:10 +000022// use this macro to extract the string hash
23#define GET_STR_HASH(str_obj_in, str_hash) uint str_hash; if (MP_OBJ_IS_QSTR(str_obj_in)) { str_hash = qstr_hash(MP_OBJ_QSTR_VALUE(str_obj_in)); } else { str_hash = ((mp_obj_str_t*)str_obj_in)->hash; }
24
25// use this macro to extract the string length
26#define GET_STR_LEN(str_obj_in, str_len) uint str_len; if (MP_OBJ_IS_QSTR(str_obj_in)) { str_len = qstr_len(MP_OBJ_QSTR_VALUE(str_obj_in)); } else { str_len = ((mp_obj_str_t*)str_obj_in)->len; }
27
28// use this macro to extract the string data and length
29#define GET_STR_DATA_LEN(str_obj_in, str_data, str_len) const byte *str_data; uint str_len; if (MP_OBJ_IS_QSTR(str_obj_in)) { str_data = qstr_data(MP_OBJ_QSTR_VALUE(str_obj_in), &str_len); } else { str_len = ((mp_obj_str_t*)str_obj_in)->len; str_data = ((mp_obj_str_t*)str_obj_in)->data; }
30
31static mp_obj_t mp_obj_new_str_iterator(mp_obj_t str, int cur);
xyb8cfc9f02014-01-05 18:47:51 +080032
33/******************************************************************************/
34/* str */
35
Damien George5fa93b62014-01-22 14:35:10 +000036void str_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
37 GET_STR_DATA_LEN(self_in, str_data, str_len);
Paul Sokolovsky76d982e2014-01-13 19:19:16 +020038 if (kind == PRINT_STR) {
Damien George5fa93b62014-01-22 14:35:10 +000039 print(env, "%.*s", str_len, str_data);
Paul Sokolovsky76d982e2014-01-13 19:19:16 +020040 } else {
41 // TODO need to escape chars etc
Damien George5fa93b62014-01-22 14:35:10 +000042 print(env, "'%.*s'", str_len, str_data);
Paul Sokolovsky76d982e2014-01-13 19:19:16 +020043 }
Damiend99b0522013-12-21 18:17:45 +000044}
45
Damien George55baff42014-01-21 21:40:13 +000046// like strstr but with specified length and allows \0 bytes
47// TODO replace with something more efficient/standard
48static const byte *find_subbytes(const byte *haystack, uint hlen, const byte *needle, uint nlen) {
49 if (hlen >= nlen) {
50 for (uint i = 0; i <= hlen - nlen; i++) {
51 bool found = true;
52 for (uint j = 0; j < nlen; j++) {
53 if (haystack[i + j] != needle[j]) {
54 found = false;
55 break;
56 }
57 }
58 if (found) {
59 return haystack + i;
60 }
61 }
62 }
63 return NULL;
64}
65
Damiend99b0522013-12-21 18:17:45 +000066mp_obj_t str_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
Damien George5fa93b62014-01-22 14:35:10 +000067 GET_STR_DATA_LEN(lhs_in, lhs_data, lhs_len);
Damiend99b0522013-12-21 18:17:45 +000068 switch (op) {
69 case RT_BINARY_OP_SUBSCR:
Paul Sokolovsky31ba60f2014-01-03 02:51:16 +020070 // TODO: need predicate to check for int-like type (bools are such for example)
71 // ["no", "yes"][1 == 2] is common idiom
72 if (MP_OBJ_IS_SMALL_INT(rhs_in)) {
Damien George5fa93b62014-01-22 14:35:10 +000073 uint index = mp_get_index(mp_obj_get_type(lhs_in), lhs_len, rhs_in);
74 return mp_obj_new_str(lhs_data + index, 1, true);
Paul Sokolovskye606cb62014-01-04 01:34:23 +020075#if MICROPY_ENABLE_SLICE
Paul Sokolovsky31ba60f2014-01-03 02:51:16 +020076 } else if (MP_OBJ_IS_TYPE(rhs_in, &slice_type)) {
Damien Georgec8d13842014-01-04 01:06:10 +000077 machine_int_t start, stop, step;
Paul Sokolovsky31ba60f2014-01-03 02:51:16 +020078 mp_obj_slice_get(rhs_in, &start, &stop, &step);
79 assert(step == 1);
Paul Sokolovskydecad082014-01-03 23:36:56 +020080 if (start < 0) {
Damien George55baff42014-01-21 21:40:13 +000081 start = lhs_len + start;
Paul Sokolovsky6ee1e382014-01-04 03:47:34 +020082 if (start < 0) {
83 start = 0;
84 }
Damien George55baff42014-01-21 21:40:13 +000085 } else if (start > lhs_len) {
86 start = lhs_len;
Paul Sokolovskydecad082014-01-03 23:36:56 +020087 }
88 if (stop <= 0) {
Damien George55baff42014-01-21 21:40:13 +000089 stop = lhs_len + stop;
Paul Sokolovsky6ee1e382014-01-04 03:47:34 +020090 // CPython returns empty string in such case
91 if (stop < 0) {
92 stop = start;
93 }
Damien George55baff42014-01-21 21:40:13 +000094 } else if (stop > lhs_len) {
95 stop = lhs_len;
Paul Sokolovskydecad082014-01-03 23:36:56 +020096 }
Damien George5fa93b62014-01-22 14:35:10 +000097 return mp_obj_new_str(lhs_data + start, stop - start, false);
Paul Sokolovskye606cb62014-01-04 01:34:23 +020098#endif
Paul Sokolovsky31ba60f2014-01-03 02:51:16 +020099 } else {
Paul Sokolovskyf8b9d3c2014-01-04 01:38:26 +0200100 // Message doesn't match CPython, but we don't have so much bytes as they
101 // to spend them on verbose wording
Damien Georgeeb7bfcb2014-01-04 15:57:35 +0000102 nlr_jump(mp_obj_new_exception_msg(MP_QSTR_TypeError, "index must be int"));
Paul Sokolovsky31ba60f2014-01-03 02:51:16 +0200103 }
Damiend99b0522013-12-21 18:17:45 +0000104
105 case RT_BINARY_OP_ADD:
106 case RT_BINARY_OP_INPLACE_ADD:
Damien George5fa93b62014-01-22 14:35:10 +0000107 if (MP_OBJ_IS_STR(rhs_in)) {
Damiend99b0522013-12-21 18:17:45 +0000108 // add 2 strings
Damien George5fa93b62014-01-22 14:35:10 +0000109
110 GET_STR_DATA_LEN(rhs_in, rhs_data, rhs_len);
Damien George55baff42014-01-21 21:40:13 +0000111 int alloc_len = lhs_len + rhs_len;
Damien George5fa93b62014-01-22 14:35:10 +0000112
113 /* code for making qstr
Damien George55baff42014-01-21 21:40:13 +0000114 byte *q_ptr;
115 byte *val = qstr_build_start(alloc_len, &q_ptr);
116 memcpy(val, lhs_data, lhs_len);
117 memcpy(val + lhs_len, rhs_data, rhs_len);
Damien George5fa93b62014-01-22 14:35:10 +0000118 return MP_OBJ_NEW_QSTR(qstr_build_end(q_ptr));
119 */
120
121 // code for non-qstr
122 byte *data;
123 mp_obj_t s = mp_obj_str_builder_start(alloc_len, &data);
124 memcpy(data, lhs_data, lhs_len);
125 memcpy(data + lhs_len, rhs_data, rhs_len);
126 return mp_obj_str_builder_end(s);
Damiend99b0522013-12-21 18:17:45 +0000127 }
128 break;
Damien George5fa93b62014-01-22 14:35:10 +0000129
John R. Lentonc1bef212014-01-11 12:39:33 +0000130 case RT_COMPARE_OP_IN:
131 case RT_COMPARE_OP_NOT_IN:
132 /* NOTE `a in b` is `b.__contains__(a)` */
Damien George5fa93b62014-01-22 14:35:10 +0000133 if (MP_OBJ_IS_STR(rhs_in)) {
134 GET_STR_DATA_LEN(rhs_in, rhs_data, rhs_len);
Damien George55baff42014-01-21 21:40:13 +0000135 return MP_BOOL((op == RT_COMPARE_OP_IN) ^ (find_subbytes(lhs_data, lhs_len, rhs_data, rhs_len) == NULL));
John R. Lentonc1bef212014-01-11 12:39:33 +0000136 }
137 break;
Damien George5fa93b62014-01-22 14:35:10 +0000138
Paul Sokolovsky545591a2014-01-21 00:27:33 +0200139 case RT_BINARY_OP_MULTIPLY:
140 {
141 if (!MP_OBJ_IS_SMALL_INT(rhs_in)) {
142 return NULL;
143 }
144 int n = MP_OBJ_SMALL_INT_VALUE(rhs_in);
Damien George5fa93b62014-01-22 14:35:10 +0000145 byte *data;
146 mp_obj_t s = mp_obj_str_builder_start(lhs_len * n, &data);
147 mp_seq_multiply(lhs_data, sizeof(*lhs_data), lhs_len, n, data);
148 return mp_obj_str_builder_end(s);
Paul Sokolovsky545591a2014-01-21 00:27:33 +0200149 }
Damiend99b0522013-12-21 18:17:45 +0000150 }
151
152 return MP_OBJ_NULL; // op not supported
153}
154
xyb8cfc9f02014-01-05 18:47:51 +0800155static mp_obj_t str_getiter(mp_obj_t o_in) {
156 return mp_obj_new_str_iterator(o_in, 0);
157}
158
Damiend99b0522013-12-21 18:17:45 +0000159mp_obj_t str_join(mp_obj_t self_in, mp_obj_t arg) {
Damien George5fa93b62014-01-22 14:35:10 +0000160 assert(MP_OBJ_IS_STR(self_in));
Damiend99b0522013-12-21 18:17:45 +0000161
Damien Georgefe8fb912014-01-02 16:36:09 +0000162 // get separation string
Damien George5fa93b62014-01-22 14:35:10 +0000163 GET_STR_DATA_LEN(self_in, sep_str, sep_len);
Damien Georgefe8fb912014-01-02 16:36:09 +0000164
165 // process args
Damiend99b0522013-12-21 18:17:45 +0000166 uint seq_len;
167 mp_obj_t *seq_items;
168 if (MP_OBJ_IS_TYPE(arg, &tuple_type)) {
169 mp_obj_tuple_get(arg, &seq_len, &seq_items);
170 } else if (MP_OBJ_IS_TYPE(arg, &list_type)) {
171 mp_obj_list_get(arg, &seq_len, &seq_items);
172 } else {
173 goto bad_arg;
174 }
Damien Georgefe8fb912014-01-02 16:36:09 +0000175
176 // count required length
177 int required_len = 0;
Damiend99b0522013-12-21 18:17:45 +0000178 for (int i = 0; i < seq_len; i++) {
Damien George5fa93b62014-01-22 14:35:10 +0000179 if (!MP_OBJ_IS_STR(seq_items[i])) {
Damiend99b0522013-12-21 18:17:45 +0000180 goto bad_arg;
181 }
Damien Georgefe8fb912014-01-02 16:36:09 +0000182 if (i > 0) {
183 required_len += sep_len;
184 }
Damien George5fa93b62014-01-22 14:35:10 +0000185 GET_STR_LEN(seq_items[i], l);
186 required_len += l;
Damiend99b0522013-12-21 18:17:45 +0000187 }
188
189 // make joined string
Damien George5fa93b62014-01-22 14:35:10 +0000190 byte *data;
191 mp_obj_t joined_str = mp_obj_str_builder_start(required_len, &data);
Damiend99b0522013-12-21 18:17:45 +0000192 for (int i = 0; i < seq_len; i++) {
Damiend99b0522013-12-21 18:17:45 +0000193 if (i > 0) {
Damien George5fa93b62014-01-22 14:35:10 +0000194 memcpy(data, sep_str, sep_len);
195 data += sep_len;
Damiend99b0522013-12-21 18:17:45 +0000196 }
Damien George5fa93b62014-01-22 14:35:10 +0000197 GET_STR_DATA_LEN(seq_items[i], s, l);
198 memcpy(data, s, l);
199 data += l;
Damiend99b0522013-12-21 18:17:45 +0000200 }
Damien Georgefe8fb912014-01-02 16:36:09 +0000201
202 // return joined string
Damien George5fa93b62014-01-22 14:35:10 +0000203 return mp_obj_str_builder_end(joined_str);
Damiend99b0522013-12-21 18:17:45 +0000204
205bad_arg:
Damien Georgeeb7bfcb2014-01-04 15:57:35 +0000206 nlr_jump(mp_obj_new_exception_msg(MP_QSTR_TypeError, "?str.join expecting a list of str's"));
Damiend99b0522013-12-21 18:17:45 +0000207}
208
Paul Sokolovsky4c316552014-01-21 05:00:21 +0200209#define is_ws(c) ((c) == ' ' || (c) == '\t')
210
211static mp_obj_t str_split(uint n_args, const mp_obj_t *args) {
212 int splits = -1;
213 mp_obj_t sep = mp_const_none;
214 if (n_args > 1) {
215 sep = args[1];
216 if (n_args > 2) {
217 splits = MP_OBJ_SMALL_INT_VALUE(args[2]);
218 }
219 }
220 assert(sep == mp_const_none);
Damien George12eacca2014-01-21 21:54:15 +0000221 (void)sep; // unused; to hush compiler warning
Paul Sokolovsky4c316552014-01-21 05:00:21 +0200222 mp_obj_t res = mp_obj_new_list(0, NULL);
Damien George5fa93b62014-01-22 14:35:10 +0000223 GET_STR_DATA_LEN(args[0], s, len);
224 const byte *top = s + len;
225 const byte *start;
Paul Sokolovsky4c316552014-01-21 05:00:21 +0200226
227 // Initial whitespace is not counted as split, so we pre-do it
Damien George5fa93b62014-01-22 14:35:10 +0000228 while (s < top && is_ws(*s)) s++;
229 while (s < top && splits != 0) {
Paul Sokolovsky4c316552014-01-21 05:00:21 +0200230 start = s;
Damien George5fa93b62014-01-22 14:35:10 +0000231 while (s < top && !is_ws(*s)) s++;
232 rt_list_append(res, mp_obj_new_str(start, s - start, false));
233 if (s >= top) {
Paul Sokolovsky4c316552014-01-21 05:00:21 +0200234 break;
235 }
Damien George5fa93b62014-01-22 14:35:10 +0000236 while (s < top && is_ws(*s)) s++;
Paul Sokolovsky4c316552014-01-21 05:00:21 +0200237 if (splits > 0) {
238 splits--;
239 }
240 }
241
Damien George5fa93b62014-01-22 14:35:10 +0000242 if (s < top) {
243 rt_list_append(res, mp_obj_new_str(s, top - s, false));
Paul Sokolovsky4c316552014-01-21 05:00:21 +0200244 }
245
246 return res;
247}
248
Damien Georgea11ceca2014-01-19 16:02:09 +0000249static mp_obj_t str_find(uint n_args, const mp_obj_t *args) {
John R. Lentone8204912014-01-12 21:53:52 +0000250 assert(2 <= n_args && n_args <= 4);
Damien George5fa93b62014-01-22 14:35:10 +0000251 assert(MP_OBJ_IS_STR(args[0]));
252 assert(MP_OBJ_IS_STR(args[1]));
John R. Lentone8204912014-01-12 21:53:52 +0000253
Damien George5fa93b62014-01-22 14:35:10 +0000254 GET_STR_DATA_LEN(args[0], haystack, haystack_len);
255 GET_STR_DATA_LEN(args[1], needle, needle_len);
John R. Lentone8204912014-01-12 21:53:52 +0000256
257 size_t start = 0;
258 size_t end = haystack_len;
259 /* TODO use a non-exception-throwing mp_get_index */
260 if (n_args >= 3 && args[2] != mp_const_none) {
261 start = mp_get_index(&str_type, haystack_len, args[2]);
262 }
263 if (n_args >= 4 && args[3] != mp_const_none) {
264 end = mp_get_index(&str_type, haystack_len, args[3]);
265 }
266
Damien George5fa93b62014-01-22 14:35:10 +0000267 const byte *p = find_subbytes(haystack + start, haystack_len - start, needle, needle_len);
Damien George23005372014-01-13 19:39:01 +0000268 if (p == NULL) {
269 // not found
270 return MP_OBJ_NEW_SMALL_INT(-1);
271 } else {
272 // found
273 machine_int_t pos = p - haystack;
John R. Lentone8204912014-01-12 21:53:52 +0000274 if (pos + needle_len > end) {
275 pos = -1;
276 }
Damien George23005372014-01-13 19:39:01 +0000277 return MP_OBJ_NEW_SMALL_INT(pos);
John R. Lentone8204912014-01-12 21:53:52 +0000278 }
John R. Lentone8204912014-01-12 21:53:52 +0000279}
280
Paul Sokolovsky1eacefe2014-01-23 01:20:40 +0200281// TODO: (Much) more variety in args
282static mp_obj_t str_startswith(mp_obj_t self_in, mp_obj_t arg) {
283 GET_STR_DATA_LEN(self_in, str, str_len);
284 GET_STR_DATA_LEN(arg, prefix, prefix_len);
285 if (prefix_len > str_len) {
286 return mp_const_false;
287 }
288 return MP_BOOL(memcmp(str, prefix, prefix_len) == 0);
289}
290
Damien George5fa93b62014-01-22 14:35:10 +0000291static bool chr_in_str(const byte* const str, const size_t str_len, int c) {
292 for (size_t i = 0; i < str_len; i++) {
293 if (str[i] == c) {
294 return true;
295 }
296 }
297 return false;
298}
299
Damien Georgea11ceca2014-01-19 16:02:09 +0000300mp_obj_t str_strip(uint n_args, const mp_obj_t *args) {
xbe7b0f39f2014-01-08 14:23:45 -0800301 assert(1 <= n_args && n_args <= 2);
Damien George5fa93b62014-01-22 14:35:10 +0000302 assert(MP_OBJ_IS_STR(args[0]));
303
304 const byte *chars_to_del;
305 uint chars_to_del_len;
306 static const byte whitespace[] = " \t\n\r\v\f";
xbe7b0f39f2014-01-08 14:23:45 -0800307
308 if (n_args == 1) {
309 chars_to_del = whitespace;
Damien George5fa93b62014-01-22 14:35:10 +0000310 chars_to_del_len = sizeof(whitespace);
xbe7b0f39f2014-01-08 14:23:45 -0800311 } else {
Damien George5fa93b62014-01-22 14:35:10 +0000312 assert(MP_OBJ_IS_STR(args[1]));
313 GET_STR_DATA_LEN(args[1], s, l);
314 chars_to_del = s;
315 chars_to_del_len = l;
xbe7b0f39f2014-01-08 14:23:45 -0800316 }
317
Damien George5fa93b62014-01-22 14:35:10 +0000318 GET_STR_DATA_LEN(args[0], orig_str, orig_str_len);
xbe7b0f39f2014-01-08 14:23:45 -0800319
320 size_t first_good_char_pos = 0;
321 bool first_good_char_pos_set = false;
322 size_t last_good_char_pos = 0;
323 for (size_t i = 0; i < orig_str_len; i++) {
324 if (!chr_in_str(chars_to_del, chars_to_del_len, orig_str[i])) {
325 last_good_char_pos = i;
326 if (!first_good_char_pos_set) {
327 first_good_char_pos = i;
328 first_good_char_pos_set = true;
329 }
330 }
331 }
332
333 if (first_good_char_pos == 0 && last_good_char_pos == 0) {
Damien George5fa93b62014-01-22 14:35:10 +0000334 // string is all whitespace, return ''
335 return MP_OBJ_NEW_QSTR(MP_QSTR_);
xbe7b0f39f2014-01-08 14:23:45 -0800336 }
337
338 assert(last_good_char_pos >= first_good_char_pos);
339 //+1 to accomodate the last character
340 size_t stripped_len = last_good_char_pos - first_good_char_pos + 1;
Damien George5fa93b62014-01-22 14:35:10 +0000341 return mp_obj_new_str(orig_str + first_good_char_pos, stripped_len, false);
xbe7b0f39f2014-01-08 14:23:45 -0800342}
343
Damien Georgea11ceca2014-01-19 16:02:09 +0000344mp_obj_t str_format(uint n_args, const mp_obj_t *args) {
Damien George5fa93b62014-01-22 14:35:10 +0000345 assert(MP_OBJ_IS_STR(args[0]));
Damiend99b0522013-12-21 18:17:45 +0000346
Damien George5fa93b62014-01-22 14:35:10 +0000347 GET_STR_DATA_LEN(args[0], str, len);
Damiend99b0522013-12-21 18:17:45 +0000348 int arg_i = 1;
349 vstr_t *vstr = vstr_new();
Damien George5fa93b62014-01-22 14:35:10 +0000350 for (const byte *top = str + len; str < top; str++) {
Damiend99b0522013-12-21 18:17:45 +0000351 if (*str == '{') {
352 str++;
Damien George5fa93b62014-01-22 14:35:10 +0000353 if (str < top && *str == '{') {
Damiend99b0522013-12-21 18:17:45 +0000354 vstr_add_char(vstr, '{');
Paul Sokolovskyf2b796e2014-01-15 22:45:20 +0200355 } else {
Damien George5fa93b62014-01-22 14:35:10 +0000356 while (str < top && *str != '}') str++;
Damiend99b0522013-12-21 18:17:45 +0000357 if (arg_i >= n_args) {
Damien Georgeeb7bfcb2014-01-04 15:57:35 +0000358 nlr_jump(mp_obj_new_exception_msg(MP_QSTR_IndexError, "tuple index out of range"));
Damiend99b0522013-12-21 18:17:45 +0000359 }
Paul Sokolovsky76d982e2014-01-13 19:19:16 +0200360 // TODO: may be PRINT_REPR depending on formatting code
Damien George4899ff92014-01-15 22:39:03 +0000361 mp_obj_print_helper((void (*)(void*, const char*, ...))vstr_printf, vstr, args[arg_i], PRINT_STR);
Damiend99b0522013-12-21 18:17:45 +0000362 arg_i++;
363 }
364 } else {
365 vstr_add_char(vstr, *str);
366 }
367 }
368
Damien George5fa93b62014-01-22 14:35:10 +0000369 mp_obj_t s = mp_obj_new_str((byte*)vstr->buf, vstr->len, false);
370 vstr_free(vstr);
371 return s;
Damiend99b0522013-12-21 18:17:45 +0000372}
373
John R. Lentone8204912014-01-12 21:53:52 +0000374static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_find_obj, 2, 4, str_find);
Damiend99b0522013-12-21 18:17:45 +0000375static MP_DEFINE_CONST_FUN_OBJ_2(str_join_obj, str_join);
Paul Sokolovsky4c316552014-01-21 05:00:21 +0200376static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_split_obj, 1, 3, str_split);
Paul Sokolovsky1eacefe2014-01-23 01:20:40 +0200377static MP_DEFINE_CONST_FUN_OBJ_2(str_startswith_obj, str_startswith);
xbe7b0f39f2014-01-08 14:23:45 -0800378static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(str_strip_obj, 1, 2, str_strip);
Damiend99b0522013-12-21 18:17:45 +0000379static MP_DEFINE_CONST_FUN_OBJ_VAR(str_format_obj, 1, str_format);
380
ian-va5a01df2014-01-06 14:14:11 -0800381static const mp_method_t str_type_methods[] = {
John R. Lentone8204912014-01-12 21:53:52 +0000382 { "find", &str_find_obj },
ian-v7a16fad2014-01-06 09:52:29 -0800383 { "join", &str_join_obj },
Paul Sokolovsky4c316552014-01-21 05:00:21 +0200384 { "split", &str_split_obj },
Paul Sokolovsky1eacefe2014-01-23 01:20:40 +0200385 { "startswith", &str_startswith_obj },
xbe7b0f39f2014-01-08 14:23:45 -0800386 { "strip", &str_strip_obj },
ian-v7a16fad2014-01-06 09:52:29 -0800387 { "format", &str_format_obj },
388 { NULL, NULL }, // end-of-list sentinel
389};
Damien George97209d32014-01-07 15:58:30 +0000390
Damiend99b0522013-12-21 18:17:45 +0000391const mp_obj_type_t str_type = {
392 { &mp_const_type },
393 "str",
Paul Sokolovsky860ffb02014-01-05 22:34:09 +0200394 .print = str_print,
395 .binary_op = str_binary_op,
396 .getiter = str_getiter,
ian-v7a16fad2014-01-06 09:52:29 -0800397 .methods = str_type_methods,
Damiend99b0522013-12-21 18:17:45 +0000398};
399
Damien George5fa93b62014-01-22 14:35:10 +0000400mp_obj_t mp_obj_str_builder_start(uint len, byte **data) {
401 mp_obj_str_t *o = m_new_obj_var(mp_obj_str_t, byte, len + 1);
Damiend99b0522013-12-21 18:17:45 +0000402 o->base.type = &str_type;
Damien George5fa93b62014-01-22 14:35:10 +0000403 o->len = len;
404 *data = o->data;
Damiend99b0522013-12-21 18:17:45 +0000405 return o;
406}
407
Damien George5fa93b62014-01-22 14:35:10 +0000408mp_obj_t mp_obj_str_builder_end(mp_obj_t o_in) {
409 assert(MP_OBJ_IS_STR(o_in));
410 mp_obj_str_t *o = o_in;
411 o->hash = qstr_compute_hash(o->data, o->len);
412 o->data[o->len] = '\0'; // for now we add null for compatibility with C ASCIIZ strings
413 return o;
414}
415
416mp_obj_t mp_obj_new_str(const byte* data, uint len, bool make_qstr_if_not_already) {
417 qstr q = qstr_find_strn(data, len);
418 if (q != MP_QSTR_NULL) {
419 // qstr with this data already exists
420 return MP_OBJ_NEW_QSTR(q);
421 } else if (make_qstr_if_not_already) {
422 // no existing qstr, make a new one
423 return MP_OBJ_NEW_QSTR(qstr_from_strn((const char*)data, len));
424 } else {
425 // no existing qstr, don't make one
426 mp_obj_str_t *o = m_new_obj_var(mp_obj_str_t, byte, len + 1);
427 o->base.type = &str_type;
428 o->hash = qstr_compute_hash(data, len);
429 o->len = len;
430 memcpy(o->data, data, len * sizeof(byte));
431 o->data[len] = '\0'; // for now we add null for compatibility with C ASCIIZ strings
432 return o;
Paul Sokolovsky8965a5e2014-01-20 23:33:19 +0200433 }
Damien George5fa93b62014-01-22 14:35:10 +0000434}
435
436bool mp_obj_str_equal(mp_obj_t s1, mp_obj_t s2) {
437 if (MP_OBJ_IS_QSTR(s1) && MP_OBJ_IS_QSTR(s2)) {
438 return s1 == s2;
439 } else {
440 GET_STR_HASH(s1, h1);
441 GET_STR_HASH(s2, h2);
442 if (h1 != h2) {
443 return false;
444 }
445 GET_STR_DATA_LEN(s1, d1, l1);
446 GET_STR_DATA_LEN(s2, d2, l2);
447 if (l1 != l2) {
448 return false;
449 }
Damien George1e708fe2014-01-23 18:27:51 +0000450 return memcmp(d1, d2, l1) == 0;
Paul Sokolovsky8965a5e2014-01-20 23:33:19 +0200451 }
Damien George5fa93b62014-01-22 14:35:10 +0000452}
453
454uint mp_obj_str_get_hash(mp_obj_t self_in) {
455 if (MP_OBJ_IS_STR(self_in)) {
456 GET_STR_HASH(self_in, h);
457 return h;
458 } else {
459 nlr_jump(mp_obj_new_exception_msg_varg(MP_QSTR_TypeError, "Can't convert '%s' object to str implicitly",
460 mp_obj_get_type_str(self_in)));
461 }
462}
463
464uint mp_obj_str_get_len(mp_obj_t self_in) {
465 if (MP_OBJ_IS_STR(self_in)) {
466 GET_STR_LEN(self_in, l);
467 return l;
468 } else {
469 nlr_jump(mp_obj_new_exception_msg_varg(MP_QSTR_TypeError, "Can't convert '%s' object to str implicitly",
470 mp_obj_get_type_str(self_in)));
471 }
472}
473
474// only use this function if you need the str data to be zero terminated
475// at the moment all strings are zero terminated to help with C ASCIIZ compatibility
476const char *mp_obj_str_get_str(mp_obj_t self_in) {
477 if (MP_OBJ_IS_STR(self_in)) {
478 GET_STR_DATA_LEN(self_in, s, l);
479 (void)l; // len unused
480 return (const char*)s;
481 } else {
482 nlr_jump(mp_obj_new_exception_msg_varg(MP_QSTR_TypeError, "Can't convert '%s' object to str implicitly",
483 mp_obj_get_type_str(self_in)));
484 }
485}
486
487const byte *mp_obj_str_get_data(mp_obj_t self_in, uint *len) {
488 if (MP_OBJ_IS_STR(self_in)) {
489 GET_STR_DATA_LEN(self_in, s, l);
490 *len = l;
491 return s;
492 } else {
493 nlr_jump(mp_obj_new_exception_msg_varg(MP_QSTR_TypeError, "Can't convert '%s' object to str implicitly",
494 mp_obj_get_type_str(self_in)));
495 }
Damiend99b0522013-12-21 18:17:45 +0000496}
xyb8cfc9f02014-01-05 18:47:51 +0800497
498/******************************************************************************/
499/* str iterator */
500
501typedef struct _mp_obj_str_it_t {
502 mp_obj_base_t base;
Damien George5fa93b62014-01-22 14:35:10 +0000503 mp_obj_t str;
xyb8cfc9f02014-01-05 18:47:51 +0800504 machine_uint_t cur;
505} mp_obj_str_it_t;
506
507mp_obj_t str_it_iternext(mp_obj_t self_in) {
508 mp_obj_str_it_t *self = self_in;
Damien George5fa93b62014-01-22 14:35:10 +0000509 GET_STR_DATA_LEN(self->str, str, len);
510 if (self->cur < len) {
511 mp_obj_t o_out = mp_obj_new_str(str + self->cur, 1, true);
xyb8cfc9f02014-01-05 18:47:51 +0800512 self->cur += 1;
513 return o_out;
514 } else {
515 return mp_const_stop_iteration;
516 }
517}
518
519static const mp_obj_type_t str_it_type = {
520 { &mp_const_type },
521 "str_iterator",
Paul Sokolovsky860ffb02014-01-05 22:34:09 +0200522 .iternext = str_it_iternext,
xyb8cfc9f02014-01-05 18:47:51 +0800523};
524
Damien George5fa93b62014-01-22 14:35:10 +0000525mp_obj_t mp_obj_new_str_iterator(mp_obj_t str, int cur) {
xyb8cfc9f02014-01-05 18:47:51 +0800526 mp_obj_str_it_t *o = m_new_obj(mp_obj_str_it_t);
527 o->base.type = &str_it_type;
528 o->str = str;
529 o->cur = cur;
530 return o;
531}