MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
fix path module
+103
-40
+1
-1
meson.build
+1
-1
meson.build
···
74
74
build_date = run_command('date', '+%Y-%m-%d', check: true).stdout().strip()
75
75
76
76
version_conf = configuration_data()
77
-
version_conf.set('ANT_VERSION', '0.1.0.38')
77
+
version_conf.set('ANT_VERSION', '0.1.0.39')
78
78
version_conf.set('ANT_GIT_HASH', git_hash)
79
79
version_conf.set('ANT_BUILD_DATE', build_date)
80
80
+102
-39
src/modules/path.c
+102
-39
src/modules/path.c
···
105
105
return js_mkstr(js, "", 0);
106
106
}
107
107
108
+
static int is_dotdot(char *seg, size_t len) {
109
+
return len == 2 && seg[0] == '.' && seg[1] == '.';
110
+
}
111
+
112
+
static char* normalize_path_full(const char *path, size_t path_len) {
113
+
char *normalized = NULL;
114
+
char **segments = NULL;
115
+
size_t *seg_lens = NULL;
116
+
char *result = NULL;
117
+
118
+
if (path_len == 0) return strdup(".");
119
+
120
+
normalized = normalize_separators(path, path_len);
121
+
if (!normalized) goto fail;
122
+
123
+
segments = malloc(path_len * sizeof(char*));
124
+
seg_lens = malloc(path_len * sizeof(size_t));
125
+
if (!segments || !seg_lens) goto fail;
126
+
127
+
int is_absolute = (normalized[0] == PATH_SEP);
128
+
int seg_count = 0;
129
+
130
+
char *start = is_absolute ? normalized + 1 : normalized;
131
+
char *seg_start = start;
132
+
133
+
for (char *p = start; ; p++) {
134
+
if (*p != PATH_SEP && *p != '\0') continue;
135
+
136
+
size_t len = p - seg_start;
137
+
if (len == 0 || (len == 1 && seg_start[0] == '.')) goto next;
138
+
139
+
if (is_dotdot(seg_start, len)) {
140
+
if (seg_count > 0 && !is_dotdot(segments[seg_count-1], seg_lens[seg_count-1]))
141
+
seg_count--;
142
+
else if (!is_absolute)
143
+
goto add_segment;
144
+
goto next;
145
+
}
146
+
147
+
add_segment:
148
+
segments[seg_count] = seg_start;
149
+
seg_lens[seg_count] = len;
150
+
seg_count++;
151
+
152
+
next:
153
+
if (*p == '\0') break;
154
+
seg_start = p + 1;
155
+
}
156
+
157
+
size_t result_len = is_absolute ? 1 : 0;
158
+
for (int i = 0; i < seg_count; i++) {
159
+
result_len += seg_lens[i];
160
+
if (i < seg_count - 1) result_len++;
161
+
}
162
+
if (result_len == 0) result_len = 1;
163
+
164
+
result = malloc(result_len + 1);
165
+
if (!result) goto fail;
166
+
167
+
size_t pos = 0;
168
+
if (is_absolute) result[pos++] = PATH_SEP;
169
+
170
+
for (int i = 0; i < seg_count; i++) {
171
+
memcpy(result + pos, segments[i], seg_lens[i]);
172
+
pos += seg_lens[i];
173
+
if (i < seg_count - 1) result[pos++] = PATH_SEP;
174
+
}
175
+
176
+
if (pos == 0) result[pos++] = '.';
177
+
result[pos] = '\0';
178
+
179
+
free(segments);
180
+
free(seg_lens);
181
+
free(normalized);
182
+
return result;
183
+
184
+
fail:
185
+
free(segments);
186
+
free(seg_lens);
187
+
free(normalized);
188
+
return NULL;
189
+
}
190
+
191
+
// path.normalize(path)
192
+
static jsval_t builtin_path_normalize(struct js *js, jsval_t *args, int nargs) {
193
+
if (nargs < 1) return js_mkerr(js, "normalize() requires a path argument");
194
+
if (js_type(args[0]) != JS_STR) return js_mkerr(js, "normalize() path must be a string");
195
+
196
+
size_t path_len;
197
+
char *path = js_getstr(js, args[0], &path_len);
198
+
if (!path || path_len == 0) return js_mkstr(js, ".", 1);
199
+
200
+
char *result = normalize_path_full(path, path_len);
201
+
if (!result) return js_mkerr(js, "Out of memory");
202
+
203
+
jsval_t ret = js_mkstr(js, result, strlen(result));
204
+
free(result);
205
+
return ret;
206
+
}
207
+
108
208
// path.join(...paths)
109
209
static jsval_t builtin_path_join(struct js *js, jsval_t *args, int nargs) {
110
210
if (nargs < 1) return js_mkstr(js, ".", 1);
···
164
264
165
265
result[pos] = '\0';
166
266
167
-
jsval_t ret = js_mkstr(js, result, pos);
267
+
char *normalized = normalize_path_full(result, pos);
168
268
free(result);
169
269
free(segments);
170
270
free(lengths);
171
-
return ret;
172
-
}
173
-
174
-
// path.normalize(path)
175
-
static jsval_t builtin_path_normalize(struct js *js, jsval_t *args, int nargs) {
176
-
if (nargs < 1) return js_mkerr(js, "normalize() requires a path argument");
177
-
if (js_type(args[0]) != JS_STR) return js_mkerr(js, "normalize() path must be a string");
178
271
179
-
size_t path_len;
180
-
char *path = js_getstr(js, args[0], &path_len);
181
-
if (!path || path_len == 0) return js_mkstr(js, ".", 1);
182
-
183
-
char *normalized = normalize_separators(path, path_len);
184
272
if (!normalized) return js_mkerr(js, "Out of memory");
185
273
186
-
char *result = malloc(path_len + 1);
187
-
if (!result) {
188
-
free(normalized);
189
-
return js_mkerr(js, "Out of memory");
190
-
}
191
-
192
-
size_t j = 0;
193
-
int last_was_sep = 0;
194
-
195
-
for (size_t i = 0; i < path_len; i++) {
196
-
if (normalized[i] == PATH_SEP) {
197
-
if (!last_was_sep) {
198
-
result[j++] = PATH_SEP;
199
-
last_was_sep = 1;
200
-
}
201
-
} else {
202
-
result[j++] = normalized[i];
203
-
last_was_sep = 0;
204
-
}
205
-
}
206
-
207
-
if (j > 1 && result[j - 1] == PATH_SEP) j--;
208
-
result[j] = '\0';
209
-
210
-
jsval_t ret = js_mkstr(js, result, j);
274
+
jsval_t ret = js_mkstr(js, normalized, strlen(normalized));
211
275
free(normalized);
212
-
free(result);
213
276
return ret;
214
277
}
215
278