OILS / mycpp / gc_builtins.cc View on Github | oils.pub

471 lines, 254 significant
1#include <errno.h> // errno
2#include <float.h> // DBL_MIN, DBL_MAX
3#include <math.h> // INFINITY
4#include <stdio.h> // required for readline/readline.h (man readline)
5
6#include "_build/detected-cpp-config.h"
7#include "mycpp/gc_list.h"
8#include "mycpp/gc_str.h"
9#ifdef HAVE_READLINE
10 #include "cpp/frontend_pyreadline.h"
11#endif
12
13// Translation of Python's print().
14void print(BigStr* s) {
15 fputs(s->data_, stdout); // print until first NUL
16 fputc('\n', stdout);
17}
18
19BigStr* str(int i) {
20 BigStr* s = OverAllocatedStr(kIntBufSize);
21 int length = snprintf(s->data(), kIntBufSize, "%d", i);
22 s->MaybeShrink(length);
23 return s;
24}
25
26BigStr* str(double d) {
27 char buf[64]; // overestimate, but we use snprintf() to be safe
28
29 int n = sizeof(buf) - 2; // in case we add '.0'
30
31 // The round tripping test in mycpp/float_test.cc tells us:
32 // %.9g - FLOAT round trip
33 // %.17g - DOUBLE round trip
34 // But this causes problems in practice, e.g. for 3.14, or 1/3
35 // int length = snprintf(buf, n, "%.17g", d);
36
37 // So use 1 less digit, which happens to match Python 3 and node.js (but not
38 // Python 2)
39 int length = snprintf(buf, n, "%.16g", d);
40
41 // TODO: This may depend on LC_NUMERIC locale!
42
43 // We may return the strings:
44 // inf -inf nan
45 // But this shouldn't come up much, because Python code changes it to:
46 // INFINITY -INFINITY NAN
47 if (strchr(buf, 'i') || strchr(buf, 'n')) {
48 return StrFromC(buf); // don't add .0
49 }
50
51 // Problem:
52 // %f prints 3.0000000 and 3.500000
53 // %g prints 3 and 3.5
54 //
55 // We want 3.0 and 3.5, so add '.0' in some cases
56 if (!strchr(buf, '.')) { // 12345 -> 12345.0
57 buf[length] = '.';
58 buf[length + 1] = '0';
59 buf[length + 2] = '\0';
60 }
61
62 return StrFromC(buf);
63}
64// %a is a hexfloat form, probably don't need that
65// int length = snprintf(buf, n, "%a", d);
66
67// Do we need this API? Or is mylib.InternedStr(BigStr* s, int start, int end)
68// better for getting values out of Token.line without allocating?
69//
70// e.g. mylib.InternedStr(tok.line, tok.start, tok.start+1)
71//
72// Also for SmallStr, we don't care about interning. Only for HeapStr.
73
74BigStr* intern(BigStr* s) {
75 // TODO: put in table gHeap.interned_
76 return s;
77}
78
79// Print quoted string. Called by StrFormat('%r').
80// TODO: consider using J8 notation instead, since error messages show that
81// string.
82BigStr* repr(BigStr* s) {
83 // Worst case: \0 becomes 4 bytes as '\\x00', and then two quote bytes.
84 int n = len(s);
85 int upper_bound = n * 4 + 2;
86
87 BigStr* result = OverAllocatedStr(upper_bound);
88
89 // Single quote by default.
90 char quote = '\'';
91 if (memchr(s->data_, '\'', n) && !memchr(s->data_, '"', n)) {
92 quote = '"';
93 }
94 char* p = result->data_;
95
96 // From PyString_Repr()
97 *p++ = quote;
98 for (int i = 0; i < n; ++i) {
99 unsigned char c = static_cast<unsigned char>(s->data_[i]);
100 if (c == quote || c == '\\') {
101 *p++ = '\\';
102 *p++ = c;
103 } else if (c == '\t') {
104 *p++ = '\\';
105 *p++ = 't';
106 } else if (c == '\n') {
107 *p++ = '\\';
108 *p++ = 'n';
109 } else if (c == '\r') {
110 *p++ = '\\';
111 *p++ = 'r';
112 } else if (0x20 <= c && c < 0x80) {
113 *p++ = c;
114 } else {
115 // Unprintable becomes \xff.
116 // TODO: Consider \yff. This is similar to J8 strings, but we don't
117 // decode UTF-8.
118 sprintf(p, "\\x%02x", c & 0xff);
119 p += 4;
120 }
121 }
122 *p++ = quote;
123 *p = '\0';
124
125 int length = p - result->data_;
126 result->MaybeShrink(length);
127 return result;
128}
129
130// Helper functions that don't use exceptions.
131
132bool StringToInt(const char* s, int length, int base, int* result) {
133 if (length == 0) {
134 return false; // empty string isn't a valid integer
135 }
136
137 // Note: sizeof(int) is often 4 bytes on both 32-bit and 64-bit
138 // sizeof(long) is often 4 bytes on both 32-bit but 8 bytes on 64-bit
139 // static_assert(sizeof(long) == 8);
140
141 char* pos; // mutated by strtol
142
143 errno = 0;
144 long v = strtol(s, &pos, base);
145
146 if (errno == ERANGE) {
147 switch (v) {
148 case LONG_MIN:
149 return false; // underflow of long, which may be 64 bits
150 case LONG_MAX:
151 return false; // overflow of long
152 }
153 }
154
155 // It should ALSO fit in an int, not just a long
156 if (v > INT_MAX) {
157 return false;
158 }
159 if (v < INT_MIN) {
160 return false;
161 }
162
163 const char* end = s + length;
164 if (pos == end) {
165 *result = v;
166 return true; // strtol() consumed ALL characters.
167 }
168
169 while (pos < end) {
170 if (!IsAsciiWhitespace(*pos)) {
171 return false; // Trailing non-space
172 }
173 pos++;
174 }
175
176 *result = v;
177 return true; // Trailing space is OK
178}
179
180bool StringToInt64(const char* s, int length, int base, int64_t* result) {
181 if (length == 0) {
182 return false; // empty string isn't a valid integer
183 }
184
185 // These should be the same type
186 static_assert(sizeof(long long) == sizeof(int64_t), "");
187
188 char* pos; // mutated by strtol
189
190 errno = 0;
191 long long v = strtoll(s, &pos, base);
192
193 if (errno == ERANGE) {
194 switch (v) {
195 case LLONG_MIN:
196 return false; // underflow
197 case LLONG_MAX:
198 return false; // overflow
199 }
200 }
201
202 const char* end = s + length;
203 if (pos == end) {
204 *result = v;
205 return true; // strtol() consumed ALL characters.
206 }
207
208 while (pos < end) {
209 if (!IsAsciiWhitespace(*pos)) {
210 return false; // Trailing non-space
211 }
212 pos++;
213 }
214
215 *result = v;
216 return true; // Trailing space is OK
217}
218
219int to_int(BigStr* s, int base) {
220 int i;
221 if (StringToInt(s->data_, len(s), base, &i)) {
222 return i; // truncated to int
223 } else {
224 throw Alloc<ValueError>();
225 }
226}
227
228BigStr* chr(int i) {
229 // NOTE: i should be less than 256, in which we could return an object from
230 // GLOBAL_STR() pool, like StrIter
231 auto result = NewStr(1);
232 result->data_[0] = i;
233 return result;
234}
235
236int ord(BigStr* s) {
237 assert(len(s) == 1);
238 // signed to unsigned conversion, so we don't get values like -127
239 uint8_t c = static_cast<uint8_t>(s->data_[0]);
240 return c;
241}
242
243bool to_bool(BigStr* s) {
244 return len(s) != 0;
245}
246
247double to_float(int i) {
248 return static_cast<double>(i);
249}
250
251double to_float(BigStr* s) {
252 char* begin = s->data_;
253 char* end_pos = begin + len(s);
254 char* orig_end = end_pos;
255
256 errno = 0;
257 double result = strtod(begin, &end_pos);
258
259 if (errno == ERANGE) { // error: overflow or underflow
260 if (result >= HUGE_VAL) {
261 return INFINITY;
262 } else if (result <= -HUGE_VAL) {
263 return -INFINITY;
264 } else if (-DBL_MIN <= result && result <= DBL_MIN) {
265 return 0.0;
266 } else {
267 FAIL("Invalid value after ERANGE");
268 }
269 }
270 if (end_pos == begin) { // error: not a floating point number
271 throw Alloc<ValueError>();
272 }
273 if (end_pos != orig_end) { // trailing data like '5s' not alowed
274 while (end_pos < orig_end) {
275 if (!IsAsciiWhitespace(*end_pos)) {
276 throw Alloc<ValueError>(); // Trailing non-space
277 }
278 end_pos++;
279 }
280 }
281
282 return result;
283}
284
285// e.g. ('a' in 'abc')
286bool str_contains(BigStr* haystack, BigStr* needle) {
287 // Common case
288 if (len(needle) == 1) {
289 return memchr(haystack->data_, needle->data_[0], len(haystack));
290 }
291
292 if (len(needle) > len(haystack)) {
293 return false;
294 }
295
296 // General case. TODO: We could use a smarter substring algorithm.
297
298 const char* end = haystack->data_ + len(haystack);
299 const char* last_possible = end - len(needle);
300 const char* p = haystack->data_;
301
302 while (p <= last_possible) {
303 if (memcmp(p, needle->data_, len(needle)) == 0) {
304 return true;
305 }
306 p++;
307 }
308 return false;
309}
310
311BigStr* str_repeat(BigStr* s, int times) {
312 // Python allows -1 too, and Oil used that
313 if (times <= 0) {
314 return kEmptyString;
315 }
316 int len_ = len(s);
317 int new_len = len_ * times;
318 BigStr* result = NewStr(new_len);
319
320 char* dest = result->data_;
321 for (int i = 0; i < times; i++) {
322 memcpy(dest, s->data_, len_);
323 dest += len_;
324 }
325 return result;
326}
327
328// for os_path.join()
329// NOTE(Jesse): Perfect candidate for BoundedBuffer
330BigStr* str_concat3(BigStr* a, BigStr* b, BigStr* c) {
331 int a_len = len(a);
332 int b_len = len(b);
333 int c_len = len(c);
334
335 int new_len = a_len + b_len + c_len;
336 BigStr* result = NewStr(new_len);
337 char* pos = result->data_;
338
339 memcpy(pos, a->data_, a_len);
340 pos += a_len;
341
342 memcpy(pos, b->data_, b_len);
343 pos += b_len;
344
345 memcpy(pos, c->data_, c_len);
346
347 assert(pos + c_len == result->data_ + new_len);
348
349 return result;
350}
351
352BigStr* str_concat(BigStr* a, BigStr* b) {
353 int a_len = len(a);
354 int b_len = len(b);
355 int new_len = a_len + b_len;
356 BigStr* result = NewStr(new_len);
357 char* buf = result->data_;
358
359 memcpy(buf, a->data_, a_len);
360 memcpy(buf + a_len, b->data_, b_len);
361
362 return result;
363}
364
365//
366// Comparators
367//
368
369bool str_equals(BigStr* left, BigStr* right) {
370 // Fast path for identical strings. String deduplication during GC could
371 // make this more likely. String interning could guarantee it, allowing us
372 // to remove memcmp().
373 if (left == right) {
374 return true;
375 }
376
377 // TODO: It would be nice to remove this condition, but I think we need MyPy
378 // strict None checking for it
379 if (left == nullptr || right == nullptr) {
380 return false;
381 }
382
383 if (left->len_ != right->len_) {
384 return false;
385 }
386
387 return memcmp(left->data_, right->data_, left->len_) == 0;
388}
389
390bool maybe_str_equals(BigStr* left, BigStr* right) {
391 if (left && right) {
392 return str_equals(left, right);
393 }
394
395 if (!left && !right) {
396 return true; // None == None
397 }
398
399 return false; // one is None and one is a BigStr*
400}
401
402bool items_equal(BigStr* left, BigStr* right) {
403 return str_equals(left, right);
404}
405
406bool keys_equal(BigStr* left, BigStr* right) {
407 return items_equal(left, right);
408}
409
410bool items_equal(Tuple2<int, int>* t1, Tuple2<int, int>* t2) {
411 return (t1->at0() == t2->at0()) && (t1->at1() == t2->at1());
412}
413
414bool keys_equal(Tuple2<int, int>* t1, Tuple2<int, int>* t2) {
415 return items_equal(t1, t2);
416}
417
418bool items_equal(Tuple2<BigStr*, int>* t1, Tuple2<BigStr*, int>* t2) {
419 return items_equal(t1->at0(), t2->at0()) && (t1->at1() == t2->at1());
420}
421
422bool keys_equal(Tuple2<BigStr*, int>* t1, Tuple2<BigStr*, int>* t2) {
423 return items_equal(t1, t2);
424}
425
426bool str_equals_c(BigStr* s, const char* c_string, int c_len) {
427 // Needs SmallStr change
428 if (len(s) == c_len) {
429 return memcmp(s->data_, c_string, c_len) == 0;
430 } else {
431 return false;
432 }
433}
434
435bool str_equals0(const char* c_string, BigStr* s) {
436 int n = strlen(c_string);
437 if (len(s) == n) {
438 return memcmp(s->data_, c_string, n) == 0;
439 } else {
440 return false;
441 }
442}
443
444int hash(BigStr* s) {
445 return s->hash(fnv1);
446}
447
448int max(int a, int b) {
449 return std::max(a, b);
450}
451
452int min(int a, int b) {
453 return std::min(a, b);
454}
455
456int max(List<int>* elems) {
457 int n = len(elems);
458 if (n < 1) {
459 throw Alloc<ValueError>();
460 }
461
462 int ret = elems->at(0);
463 for (int i = 0; i < n; ++i) {
464 int cand = elems->at(i);
465 if (cand > ret) {
466 ret = cand;
467 }
468 }
469
470 return ret;
471}