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

283 lines, 153 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
46class MutableStr : public BigStr {};
47
48MutableStr* NewMutableStr(int n) {
49 // In order for everything to work, MutableStr must be identical in layout to
50 // BigStr. One easy way to achieve this is for MutableStr to have no members
51 // and to inherit from BigStr.
52 static_assert(sizeof(MutableStr) == sizeof(BigStr),
53 "BigStr and MutableStr must have same size");
54 return reinterpret_cast<MutableStr*>(NewStr(n));
55}
56
57Tuple2<BigStr*, BigStr*> split_once(BigStr* s, BigStr* delim) {
58 DCHECK(len(delim) == 1);
59
60 const char* start = s->data_; // note: this pointer may move
61 char c = delim->data_[0];
62 int length = len(s);
63
64 const char* p = static_cast<const char*>(memchr(start, c, length));
65
66 if (p) {
67 int len1 = p - start;
68 int len2 = length - len1 - 1; // -1 for delim
69
70 BigStr* s1 = nullptr;
71 BigStr* s2 = nullptr;
72 // Allocate together to avoid 's' moving in between
73 s1 = NewStr(len1);
74 s2 = NewStr(len2);
75
76 memcpy(s1->data_, s->data_, len1);
77 memcpy(s2->data_, s->data_ + len1 + 1, len2);
78
79 return Tuple2<BigStr*, BigStr*>(s1, s2);
80 } else {
81 return Tuple2<BigStr*, BigStr*>(s, nullptr);
82 }
83}
84
85LineReader* gStdin;
86
87LineReader* open(BigStr* path) {
88 // TODO: Don't use C I/O; use POSIX I/O!
89 FILE* f = fopen(path->data_, "r");
90 if (f == nullptr) {
91 throw Alloc<IOError>(errno);
92 }
93
94 return reinterpret_cast<LineReader*>(Alloc<CFile>(f));
95}
96
97BigStr* CFile::readline() {
98 char* line = nullptr;
99 size_t allocated_size = 0; // unused
100
101 // Reset errno because we turn the EOF error into empty string (like Python).
102 errno = 0;
103 ssize_t len = getline(&line, &allocated_size, f_);
104 if (len < 0) {
105 // man page says the buffer should be freed even if getline fails
106 free(line);
107 if (errno != 0) { // Unexpected error
108 log("getline() error: %s", strerror(errno));
109 throw Alloc<IOError>(errno);
110 }
111 return kEmptyString; // EOF indicated by by empty string, like Python
112 }
113
114 // Note: getline() NUL-terminates the buffer
115 BigStr* result = ::StrFromC(line, len);
116 free(line);
117 return result;
118}
119
120bool CFile::isatty() {
121 return ::isatty(fileno(f_));
122}
123
124// Problem: most BigStr methods like index() and slice() COPY so they have a
125// NUL terminator.
126// log("%s") falls back on sprintf, so it expects a NUL terminator.
127// It would be easier for us to just share.
128BigStr* BufLineReader::readline() {
129 BigStr* line = nullptr;
130
131 int str_len = len(s_);
132 if (pos_ == str_len) {
133 return kEmptyString;
134 }
135
136 int orig_pos = pos_;
137 const char* p = strchr(s_->data_ + pos_, '\n');
138 // log("pos_ = %s", pos_);
139 int line_len;
140 if (p) {
141 int new_pos = p - s_->data_;
142 line_len = new_pos - pos_ + 1; // past newline char
143 pos_ = new_pos + 1;
144 } else { // leftover line
145 if (pos_ == 0) { // The string has no newlines at all -- just return it
146 pos_ = str_len; // advance to the end
147 return s_;
148 } else {
149 line_len = str_len - pos_;
150 pos_ = str_len; // advance to the end
151 }
152 }
153
154 line = NewStr(line_len);
155 memcpy(line->data_, s_->data_ + orig_pos, line_len);
156 DCHECK(line->data_[line_len] == '\0');
157 return line;
158}
159
160Writer* gStdout;
161Writer* gStderr;
162
163//
164// CFileWriter
165//
166
167void CFile::write(BigStr* s) {
168 // note: throwing away the return value
169 fwrite(s->data_, sizeof(char), len(s), f_);
170}
171
172void CFile::flush() {
173 ::fflush(f_);
174}
175
176void CFile::close() {
177 ::fclose(f_);
178}
179
180//
181// BufWriter
182//
183
184void BufWriter::EnsureMoreSpace(int n) {
185 if (str_ == nullptr) {
186 // TODO: we could make the default capacity big enough for a line, e.g. 128
187 // capacity: 128 -> 256 -> 512
188 str_ = NewMutableStr(n);
189 return;
190 }
191
192 int current_cap = len(str_);
193 DCHECK(current_cap >= len_);
194
195 int new_cap = len_ + n;
196
197 if (current_cap < new_cap) {
198 auto* s = NewMutableStr(std::max(current_cap * 2, new_cap));
199 memcpy(s->data_, str_->data_, len_);
200 s->data_[len_] = '\0';
201 str_ = s;
202 }
203}
204
205uint8_t* BufWriter::LengthPointer() {
206 // start + len
207 return reinterpret_cast<uint8_t*>(str_->data_) + len_;
208}
209
210uint8_t* BufWriter::CapacityPointer() {
211 // start + capacity
212 return reinterpret_cast<uint8_t*>(str_->data_) + str_->len_;
213}
214
215void BufWriter::SetLengthFrom(uint8_t* length_ptr) {
216 uint8_t* begin = reinterpret_cast<uint8_t*>(str_->data_);
217 DCHECK(length_ptr >= begin); // we should have written some data
218
219 // Set the length, e.g. so we know where to resume writing from
220 len_ = length_ptr - begin;
221 // printf("SET LEN to %d\n", len_);
222}
223
224void BufWriter::Truncate(int length) {
225 len_ = length;
226}
227
228void BufWriter::WriteRaw(char* s, int n) {
229 DCHECK(is_valid_); // Can't write() after getvalue()
230
231 // write('') is a no-op, so don't create Buf if we don't need to
232 if (n == 0) {
233 return;
234 }
235
236 EnsureMoreSpace(n);
237
238 // Append the contents to the buffer
239 memcpy(str_->data_ + len_, s, n);
240 len_ += n;
241 str_->data_[len_] = '\0';
242}
243
244void BufWriter::WriteConst(const char* c_string) {
245 // meant for short strings like '"'
246 WriteRaw(const_cast<char*>(c_string), strlen(c_string));
247}
248
249void BufWriter::write(BigStr* s) {
250 WriteRaw(s->data_, len(s));
251}
252
253void BufWriter::write_spaces(int n) {
254 if (n == 0) {
255 return;
256 }
257
258 EnsureMoreSpace(n);
259
260 char* dest = str_->data_ + len_;
261 for (int i = 0; i < n; ++i) {
262 dest[i] = ' ';
263 }
264 len_ += n;
265 str_->data_[len_] = '\0';
266}
267
268BigStr* BufWriter::getvalue() {
269 DCHECK(is_valid_); // Check for two INVALID getvalue() in a row
270 is_valid_ = false;
271
272 if (str_ == nullptr) { // if no write() methods are called, the result is ""
273 return kEmptyString;
274 } else {
275 BigStr* s = str_;
276 s->MaybeShrink(len_);
277 str_ = nullptr;
278 len_ = -1;
279 return s;
280 }
281}
282
283} // namespace mylib