OILS / mycpp / gc_mylib.cc View on Github | oilshell.org

312 lines, 165 significant
1#include "mycpp/gc_mylib.h"
2
3#include <errno.h>
4#include <stdio.h>
5#include <unistd.h> // isatty
6
7namespace mylib {
8
9void InitCppOnly() {
10 // We don't seem need this now that we have ctx_FlushStdout().
11 // setvbuf(stdout, 0, _IONBF, 0);
12
13 // Arbitrary threshold of 50K objects based on eyeballing
14 // benchmarks/osh-runtime 10K or 100K aren't too bad either.
15 gHeap.Init(50000);
16}
17
18void print_stderr(BigStr* s) {
19 fputs(s->data_, stderr); // prints until first NUL
20 fputc('\n', stderr);
21}
22
23#if 0
24void writeln(BigStr* s, int fd) {
25 // TODO: handle errors and write in a loop, like posix::write(). If possible,
26 // use posix::write directly, but that introduces some dependency problems.
27
28 if (write(fd, s->data_, len(s)) < 0) {
29 assert(0);
30 }
31 if (write(fd, "\n", 1) < 0) {
32 assert(0);
33 }
34}
35#endif
36
37BigStr* JoinBytes(List<int>* byte_list) {
38 int n = len(byte_list);
39 BigStr* result = NewStr(n);
40 for (int i = 0; i < n; ++i) {
41 result->data_[i] = byte_list->at(i);
42 }
43 return result;
44}
45
46// For BashArray
47void BigIntSort(List<mops::BigInt>* keys) {
48 keys->sort();
49}
50
51class MutableStr : public BigStr {};
52
53MutableStr* NewMutableStr(int n) {
54 // In order for everything to work, MutableStr must be identical in layout to
55 // BigStr. One easy way to achieve this is for MutableStr to have no members
56 // and to inherit from BigStr.
57 static_assert(sizeof(MutableStr) == sizeof(BigStr),
58 "BigStr and MutableStr must have same size");
59 return reinterpret_cast<MutableStr*>(NewStr(n));
60}
61
62Tuple2<BigStr*, BigStr*> split_once(BigStr* s, BigStr* delim) {
63 DCHECK(len(delim) == 1);
64
65 const char* start = s->data_; // note: this pointer may move
66 char c = delim->data_[0];
67 int length = len(s);
68
69 const char* p = static_cast<const char*>(memchr(start, c, length));
70
71 if (p) {
72 int len1 = p - start;
73 int len2 = length - len1 - 1; // -1 for delim
74
75 BigStr* s1 = nullptr;
76 BigStr* s2 = nullptr;
77 // Allocate together to avoid 's' moving in between
78 s1 = NewStr(len1);
79 s2 = NewStr(len2);
80
81 memcpy(s1->data_, s->data_, len1);
82 memcpy(s2->data_, s->data_ + len1 + 1, len2);
83
84 return Tuple2<BigStr*, BigStr*>(s1, s2);
85 } else {
86 return Tuple2<BigStr*, BigStr*>(s, nullptr);
87 }
88}
89
90LineReader* gStdin;
91
92LineReader* open(BigStr* path) {
93 // TODO: Don't use C I/O; use POSIX I/O!
94 FILE* f = fopen(path->data_, "r");
95 if (f == nullptr) {
96 throw Alloc<IOError>(errno);
97 }
98
99 return reinterpret_cast<LineReader*>(Alloc<CFile>(f));
100}
101
102BigStr* CFile::readline() {
103 char* line = nullptr;
104 size_t allocated_size = 0; // unused
105
106 // Reset errno because we turn the EOF error into empty string (like Python).
107 errno = 0;
108 ssize_t len = getline(&line, &allocated_size, f_);
109 // log("getline = %d", len);
110 if (len < 0) {
111 // Reset EOF flag so the next readline() will get a line.
112 clearerr(f_);
113
114 // man page says the buffer should be freed even if getline fails
115 free(line);
116
117#if 0
118 // Need to raise KeyboardInterrupt like mylib.Stdin().readline() does in
119 // Python! This affects _PlainPromptInput() in frontend/reader.py
120 // gSignalSafe. But the dependency on gSignalSafe is "inverted".
121 if (errno == EINTR && gSignalSafe->PollUntrappedSigInt()) {
122 throw Alloc<KeyboardInterrupt>();
123 }
124#endif
125
126 if (errno != 0) { // Unexpected error
127 // log("getline() error: %s", strerror(errno));
128 throw Alloc<IOError>(errno);
129 }
130 return kEmptyString; // Indicate EOF with empty string, like Python
131 }
132
133 // Note: getline() NUL-terminates the buffer
134 BigStr* result = ::StrFromC(line, len);
135 free(line);
136 return result;
137}
138
139bool CFile::isatty() {
140 return ::isatty(fileno(f_));
141}
142
143// Problem: most BigStr methods like index() and slice() COPY so they have a
144// NUL terminator.
145// log("%s") falls back on sprintf, so it expects a NUL terminator.
146// It would be easier for us to just share.
147BigStr* BufLineReader::readline() {
148 BigStr* line = nullptr;
149
150 int str_len = len(s_);
151 if (pos_ == str_len) {
152 return kEmptyString;
153 }
154
155 int orig_pos = pos_;
156 const char* p = strchr(s_->data_ + pos_, '\n');
157 // log("pos_ = %s", pos_);
158 int line_len;
159 if (p) {
160 int new_pos = p - s_->data_;
161 line_len = new_pos - pos_ + 1; // past newline char
162 pos_ = new_pos + 1;
163 } else { // leftover line
164 if (pos_ == 0) { // The string has no newlines at all -- just return it
165 pos_ = str_len; // advance to the end
166 return s_;
167 } else {
168 line_len = str_len - pos_;
169 pos_ = str_len; // advance to the end
170 }
171 }
172
173 line = NewStr(line_len);
174 memcpy(line->data_, s_->data_ + orig_pos, line_len);
175 DCHECK(line->data_[line_len] == '\0');
176 return line;
177}
178
179Writer* gStdout;
180Writer* gStderr;
181
182//
183// CFileWriter
184//
185
186void CFile::write(BigStr* s) {
187 // Writes can be short!
188 int n = len(s);
189 int num_written = ::fwrite(s->data_, sizeof(char), n, f_);
190 // Similar to CPython fileobject.c
191 if (num_written != n) {
192 throw Alloc<IOError>(errno);
193 }
194}
195
196void CFile::flush() {
197 if (::fflush(f_) != 0) {
198 throw Alloc<IOError>(errno);
199 }
200}
201
202void CFile::close() {
203 if (::fclose(f_) != 0) {
204 throw Alloc<IOError>(errno);
205 }
206}
207
208//
209// BufWriter
210//
211
212void BufWriter::EnsureMoreSpace(int n) {
213 if (str_ == nullptr) {
214 // TODO: we could make the default capacity big enough for a line, e.g. 128
215 // capacity: 128 -> 256 -> 512
216 str_ = NewMutableStr(n);
217 return;
218 }
219
220 int current_cap = len(str_);
221 DCHECK(current_cap >= len_);
222
223 int new_cap = len_ + n;
224
225 if (current_cap < new_cap) {
226 auto* s = NewMutableStr(std::max(current_cap * 2, new_cap));
227 memcpy(s->data_, str_->data_, len_);
228 s->data_[len_] = '\0';
229 str_ = s;
230 }
231}
232
233uint8_t* BufWriter::LengthPointer() {
234 // start + len
235 return reinterpret_cast<uint8_t*>(str_->data_) + len_;
236}
237
238uint8_t* BufWriter::CapacityPointer() {
239 // start + capacity
240 return reinterpret_cast<uint8_t*>(str_->data_) + str_->len_;
241}
242
243void BufWriter::SetLengthFrom(uint8_t* length_ptr) {
244 uint8_t* begin = reinterpret_cast<uint8_t*>(str_->data_);
245 DCHECK(length_ptr >= begin); // we should have written some data
246
247 // Set the length, e.g. so we know where to resume writing from
248 len_ = length_ptr - begin;
249 // printf("SET LEN to %d\n", len_);
250}
251
252void BufWriter::Truncate(int length) {
253 len_ = length;
254}
255
256void BufWriter::WriteRaw(char* s, int n) {
257 DCHECK(is_valid_); // Can't write() after getvalue()
258
259 // write('') is a no-op, so don't create Buf if we don't need to
260 if (n == 0) {
261 return;
262 }
263
264 EnsureMoreSpace(n);
265
266 // Append the contents to the buffer
267 memcpy(str_->data_ + len_, s, n);
268 len_ += n;
269 str_->data_[len_] = '\0';
270}
271
272void BufWriter::WriteConst(const char* c_string) {
273 // meant for short strings like '"'
274 WriteRaw(const_cast<char*>(c_string), strlen(c_string));
275}
276
277void BufWriter::write(BigStr* s) {
278 WriteRaw(s->data_, len(s));
279}
280
281void BufWriter::write_spaces(int n) {
282 DCHECK(n >= 0);
283 if (n == 0) {
284 return;
285 }
286
287 EnsureMoreSpace(n);
288
289 char* dest = str_->data_ + len_;
290 for (int i = 0; i < n; ++i) {
291 dest[i] = ' ';
292 }
293 len_ += n;
294 str_->data_[len_] = '\0';
295}
296
297BigStr* BufWriter::getvalue() {
298 DCHECK(is_valid_); // Check for two INVALID getvalue() in a row
299 is_valid_ = false;
300
301 if (str_ == nullptr) { // if no write() methods are called, the result is ""
302 return kEmptyString;
303 } else {
304 BigStr* s = str_;
305 s->MaybeShrink(len_);
306 str_ = nullptr;
307 len_ = -1;
308 return s;
309 }
310}
311
312} // namespace mylib