Debian Codegraph @

time/date/parse.ha

raw
1 // SPDX-License-Identifier: MPL-2.0
2 // (c) Hare authors <https://harelang.org>
3
4 use ascii;
5 use strconv;
6 use strings;
7 use time;
8
9 // A parsing error occurred. This contains a byte index of and rune from the
10 // layout at the position where the parsing failure occured.
11 export type parsefail = !(size, rune);
12
13 // TODO: improve parsefail
14
15 type parsed = !(parsed_err | parsed_done);
16
17 type parsed_err = !void;
18
19 type parsed_done = !void;
20
21 // Parses date information from a string into a [[virtual]] date, according to a
22 // layout with specifiers as documented under [[format]]. Partial, sequential,
23 // aggregative parsing is possible.
24 //
25 // date::parse(&v, "%Y-%m-%d", "2019-12-27")!;
26 // date::parse(&v, "%H:%M:%S.%N", "22:07:08.000000000")!;
27 // date::parse(&v, "%z %Z %L", "+0100 CET Europe/Amsterdam")!;
28 //
29 // Parse will return [[parsefail]] if an invalid layout format specifier is
30 // encountered or if given info string does not match the layout.
31 export fn parse(v: *virtual, layout: str, info: str) (void | parsefail) = {
32 // TODO: specify if extraneous text is ignored. also for from_str().
33
34 const layout_iter = strings::iter(layout);
35 const info_iter = strings::iter(info);
36 let escaped = false;
37
38 for (let lr => strings::next(&layout_iter)) {
39 if (!escaped && lr == '%') {
40 escaped = true;
41 continue;
42 };
43
44 if (!escaped) {
45 const ir = match (strings::next(&info_iter)) {
46 case done =>
47 return (strings::position(&layout_iter),
48 lr): parsefail;
49 case let ir: rune =>
50 yield ir;
51 };
52 if (ir != lr) {
53 return (strings::position(&layout_iter),
54 lr): parsefail;
55 };
56 continue;
57 };
58
59 escaped = false;
60
61 match (parse_specifier(v, &info_iter, lr)) {
62 case parsed_done => void;
63 case parsed_err =>
64 return (strings::position(&layout_iter), lr): parsefail;
65 };
66 };
67
68 return void;
69 };
70
71 fn parse_specifier(
72 v: *virtual,
73 t: *strings::iterator,
74 lr: rune,
75 ) parsed = {
76 switch (lr) {
77 case 'a' =>
78 v.weekday = scan_for(t, WEEKDAYS_SHORT...)?;
79 case 'A' =>
80 v.weekday = scan_for(t, WEEKDAYS...)?;
81 case 'b' =>
82 v.month = scan_for(t, MONTHS_SHORT...)? + 1;
83 case 'B' =>
84 v.month = scan_for(t, MONTHS...)? + 1;
85 case 'C' =>
86 v.century = scan_int(t, 2)?;
87 case 'd', 'e' =>
88 v.day = scan_int(t, 2)?;
89 case 'F' =>
90 v.year = scan_int(t, 4)?;
91 scan_rune(t, '-', parsed_err)?;
92 v.month = scan_int(t, 2)?;
93 scan_rune(t, '-', parsed_err)?;
94 v.day = scan_int(t, 2)?;
95 case 'G' =>
96 v.isoweekyear = scan_int(t, 4)?;
97 case 'H' =>
98 v.hour = scan_int(t, 2)?;
99 case 'I' =>
100 v.hour12 = scan_int(t, 2)?;
101 case 'j' =>
102 v.yearday = scan_int(t, 3)?;
103 case 'L' =>
104 v.locname = scan_name(t)?;
105 case 'm' =>
106 v.month = scan_int(t, 2)?;
107 case 'M' =>
108 v.minute = scan_int(t, 2)?;
109 case 'N' =>
110 let nsec = scan_decimal(t, 9)?;
111 v.nanosecond = nsec: int;
112 v.vnsec = nsec;
113 case 'p' => // AM=false PM=true
114 v.ampm = scan_for(t, "AM", "PM", "am", "pm")? % 2 == 1;
115 case 's' =>
116 v.vsec = scan_num(t, 1, 20, parsed_err)?;
117 case 'S' =>
118 v.second = scan_int(t, 2)?;
119 case 'T' =>
120 v.hour = scan_int(t, 2)?;
121 scan_rune(t, ':', parsed_err)?;
122 v.minute = scan_int(t, 2)?;
123 scan_rune(t, ':', parsed_err)?;
124 v.second = scan_int(t, 2)?;
125 case 'u' =>
126 v.weekday = scan_int(t, 1)? - 1;
127 case 'U' =>
128 v.week = scan_int(t, 2)?;
129 case 'V' =>
130 v.isoweek = scan_int(t, 2)?;
131 case 'w' =>
132 v.weekday = scan_int(t, 1)? - 1;
133 case 'W' =>
134 v.week = scan_int(t, 2)?;
135 case 'y' =>
136 v.year100 = scan_int(t, 2)?;
137 case 'Y' =>
138 v.year = scan_int(t, 4)?;
139 case 'z' =>
140 v.zoff = scan_zoff(t)?;
141 case 'Z' =>
142 v.zabbr = scan_name(t)?;
143 case '%' =>
144 scan_rune(t, '%', parsed_err)?;
145 case =>
146 return parsed_err;
147 };
148
149 return parsed_done;
150 };
151
152 // Scans one rune.
153 // If [want] is void, any rune is accepted.
154 // If [want] is rune, rune must match [want], or [[parsed_err]] is returned.
155 // If iterator returns done, [default] is returned.
156 fn scan_rune(
157 iter: *strings::iterator,
158 want: (void | rune),
159 default: (rune | parsed),
160 ) (rune | parsed) = {
161 match (strings::next(iter)) {
162 case done =>
163 return default;
164 case let r: rune =>
165 match (want) {
166 case void =>
167 return r;
168 case let w: rune =>
169 if (r == w) {
170 return r;
171 } else {
172 return parsed_err;
173 };
174 };
175 };
176 };
177
178 // Scans a number, upto [maxwidth] digits.
179 // Number must be at least [minwidth] digits, or returns [[parsed_err]].
180 // If a non-digit is encountered, returns [[parsed_err]].
181 // If first rune scanned is a non-digit, returns [default].
182 // If iterator immediately returns done, returns [default].
183 fn scan_num(
184 t: *strings::iterator,
185 minwidth: size,
186 maxwidth: size,
187 default: (i64 | parsed),
188 ) (i64 | parsed) = {
189 let start = *t;
190
191 for (let i = 0z; i < maxwidth; i += 1) {
192 match (strings::next(t)) {
193 case done =>
194 if (i == 0z) {
195 strings::prev(t);
196 return default;
197 };
198 if (i < minwidth) return parsed_err;
199 break;
200 case let r: rune =>
201 if (!ascii::isdigit(r)) {
202 if (i < minwidth) {
203 *t = start;
204 return parsed_err;
205 };
206 strings::prev(t);
207 break;
208 };
209 continue;
210 };
211 };
212
213 return strconv::stoi64(strings::slice(&start, t))!;
214 };
215
216 // Scans a number, left-padded with ' ' or '0'. [width] runes are scanned.
217 // Digits must be consecutive, or returns [[parsed_err]].
218 // The last rune must be a digit, or returns [[parsed_err]].
219 // If an invalid rune is encountered, returns [[parsed_err]].
220 // If first rune is invalid, returns [default].
221 // If iterator immediately returns done, returns [default].
222 fn scan_numpad(
223 t: *strings::iterator,
224 width: size,
225 default: (i64 | parsed),
226 ) (i64 | parsed) = {
227 for (let i = 0z; i < width; i += 1) {
228 match (strings::next(t)) {
229 case done =>
230 if (i == 0) {
231 strings::prev(t);
232 return default;
233 };
234 return parsed_err;
235 case let r: rune =>
236 switch (r) {
237 case =>
238 if (i == 0) {
239 strings::prev(t);
240 return default;
241 };
242 return parsed_err;
243 case ' ' =>
244 continue;
245 case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' =>
246 strings::prev(t);
247 width = width - i;
248 return scan_num(t, width, width, parsed_err);
249 };
250 };
251 };
252
253 return parsed_err;
254 };
255
256 // Scans a left-padded number. Returns an int. See [[scan_numpad]].
257 // If first rune is invalid, returns [[parsed_err]].
258 fn scan_int(t: *strings::iterator, width: size) (int | parsed_err) = {
259 match (scan_numpad(t, width, parsed_err)) {
260 case let n: i64 =>
261 return n: int;
262 case parsed_err =>
263 return parsed_err;
264 case parsed_done =>
265 return abort();
266 };
267 };
268
269 // Scans a number as a subunit decimal.
270 // Scans upto [maxwidth] digits.
271 // The scanned decimal is right-padded with zeros to reach [maxwidth].
272 //
273 // For example, the string
274 // "Foo 42.125 Bar"
275 // can have its substring
276 // "125"
277 // interpreted with [maxwidth]=6 as
278 // "125000"
279 // and scanned as value
280 // 125000
281 //
282 fn scan_decimal(t: *strings::iterator, maxwidth: size) (i64 | parsed_err) = {
283 let start = *t;
284 for (let i = 0z; i < maxwidth; i += 1) {
285 let rn: rune = match (strings::next(t)) {
286 case done =>
287 break;
288 case let rn: rune =>
289 yield rn;
290 };
291 if (!ascii::isdigit(rn)) {
292 strings::prev(t);
293 break;
294 };
295 };
296 const s = strings::slice(&start, t);
297 match (strconv::stoi64(s)) {
298 case let num: i64 =>
299 for (let i = 0z; i < maxwidth - len(s); i += 1) {
300 num *= 10;
301 };
302 return num;
303 case =>
304 return parsed_err;
305 };
306 };
307
308 // Scans and parses zone offsets of the form:
309 //
310 // Z
311 // z
312 // +nn:nn
313 // +nnnn
314 // -nn:nn
315 // -nnnn
316 //
317 fn scan_zoff(t: *strings::iterator) (time::duration | parsed_err) = {
318 const first = match (strings::next(t)) {
319 case done =>
320 return parsed_err;
321 case let first: rune =>
322 yield first;
323 };
324 if (first == 'Z' || first == 'z') {
325 return 0;
326 };
327
328 let zo = scan_int(t, 2)? * time::HOUR;
329
330 match (strings::next(t)) {
331 case done =>
332 return parsed_err;
333 case let sep: rune =>
334 if (sep != ':') {
335 strings::prev(t);
336 };
337 };
338
339 zo += scan_int(t, 2)? * time::MINUTE;
340
341 if (first == '-') {
342 zo *= -1;
343 };
344
345 return zo;
346 };
347
348 // Scans and parses locality names, made of printable characters.
349 fn scan_name(t: *strings::iterator) (str | parsed_err) = {
350 let start = *t;
351 for (let rn => strings::next(t)) {
352 if (!ascii::isgraph(rn)) {
353 strings::prev(t);
354 break;
355 };
356 };
357 return strings::slice(&start, t);
358 };
359
360 // Scans the iterator for a given list of strings.
361 // Returns the list index of the matched string.
362 fn scan_for(iter: *strings::iterator, list: str...) (int | parsed_err) = {
363 const name = strings::iterstr(iter);
364 if (len(name) == 0) {
365 return parsed_err;
366 };
367 for(let i = 0z; i < len(list); i += 1) {
368 if (strings::hasprefix(name, list[i])) {
369 // Consume name
370 for (let j = 0z; j < len(list[i]); j += 1) {
371 strings::next(iter);
372 };
373 return i: int;
374 };
375 };
376 return parsed_err;
377 };
378
379 @test fn parse() void = {
380 let v = newvirtual();
381 assert(parse(&v, "foo", "foo") is void, "none: parsefail");
382 assert(v.zonephase == null, "none: non-null zonephase");
383 assert(v.daydate is void, "none: non-void daydate");
384 assert(v.daytime is void, "none: non-void daytime");
385 assert(v.era is void, "none: non-void era");
386 assert(v.year is void, "none: non-void year");
387 assert(v.month is void, "none: non-void month");
388 assert(v.day is void, "none: non-void day");
389 assert(v.yearday is void, "none: non-void yearday");
390 assert(v.isoweekyear is void, "none: non-void isoweekyear");
391 assert(v.isoweek is void, "none: non-void isoweek");
392 assert(v.week is void, "none: non-void week");
393 assert(v.sundayweek is void, "none: non-void sundayweek");
394 assert(v.weekday is void, "none: non-void weekday");
395 assert(v.hour is void, "none: non-void hour");
396 assert(v.minute is void, "none: non-void minute");
397 assert(v.second is void, "none: non-void second");
398 assert(v.nanosecond is void, "none: non-void nanosecond");
399 assert(v.vloc is void, "none: non-void vloc");
400 assert(v.locname is void, "none: non-void locname");
401 assert(v.zoff is void, "none: non-void zoff");
402 assert(v.zabbr is void, "none: non-void zabbr");
403 assert(v.hour12 is void, "none: non-void hour12");
404 assert(v.ampm is void, "none: non-void ampm");
405
406 let v = newvirtual();
407 assert(parse(&v, "%a", "Fri") is void , "%a: parsefail");
408 assert(v.weekday is int , "%a: void");
409 assert(v.weekday as int == 4 , "%a: incorrect");
410
411 let v = newvirtual();
412 assert(parse(&v, "%A", "Friday") is void , "%A: parsefail");
413 assert(v.weekday is int , "%A: void");
414 assert(v.weekday as int == 4 , "%A: incorrect");
415
416 let v = newvirtual();
417 assert(parse(&v, "%b", "Jan") is void , "%b: parsefail");
418 assert(v.month is int , "%b: void");
419 assert(v.month as int == 1 , "%b: incorrect");
420
421 let v = newvirtual();
422 assert(parse(&v, "%B", "January") is void , "%B: parsefail");
423 assert(v.month is int , "%B: void");
424 assert(v.month as int == 1 , "%B: incorrect");
425
426 let v = newvirtual();
427 assert(parse(&v, "%d", "27") is void , "%d: parsefail");
428 assert(v.day is int , "%d: void");
429 assert(v.day as int == 27 , "%d: incorrect");
430
431 let v = newvirtual();
432 assert(parse(&v, "%d", " 1") is void , "%d: parsefail");
433 assert(v.day is int , "%d: void");
434 assert(v.day as int == 1 , "%d: incorrect");
435
436 let v = newvirtual();
437 assert(parse(&v, "%d", "x1") is parsefail , "%d: not parsefail");
438
439 let v = newvirtual();
440 assert(parse(&v, "%e", " 7") is void , "%d: parsefail");
441 assert(v.day is int , "%d: void");
442 assert(v.day as int == 7 , "%d: incorrect");
443
444 let v = newvirtual();
445 assert(parse(&v, "%F", "2012-10-01") is void , "%d: parsefail");
446 assert(v.year is int , "%d: void");
447 assert(v.year as int == 2012 , "%d: incorrect");
448 assert(v.month is int , "%d: void");
449 assert(v.month as int == 10 , "%d: incorrect");
450 assert(v.day is int , "%d: void");
451 assert(v.day as int == 1 , "%d: incorrect");
452
453 let v = newvirtual();
454 assert(parse(&v, "%H", "22") is void , "%H: parsefail");
455 assert(v.hour is int , "%H: void");
456 assert(v.hour as int == 22 , "%H: incorrect");
457
458 let v = newvirtual();
459 assert(parse(&v, "%I", "10") is void , "%I: parsefail");
460 assert(v.hour12 is int , "%I: void");
461 assert(v.hour12 as int == 10 , "%I: incorrect");
462
463 let v = newvirtual();
464 assert(parse(&v, "%j", "361") is void , "%j: parsefail");
465 assert(v.yearday is int , "%j: void");
466 assert(v.yearday as int == 361 , "%j: incorrect");
467
468 let v = newvirtual();
469 assert(parse(&v, "%j", " 9") is void , "%j: parsefail");
470 assert(v.yearday is int , "%j: void");
471 assert(v.yearday as int == 9 , "%j: incorrect");
472
473 let v = newvirtual();
474 assert(parse(&v, "%L", "Europe/Amsterdam") is void , "%L: parsefail");
475 assert(v.locname is str , "%L: void");
476 assert(v.locname as str == "Europe/Amsterdam" , "%L: incorrect");
477
478 let v = newvirtual();
479 assert(parse(&v, "%m", "12") is void , "%m: parsefail");
480 assert(v.month is int , "%m: void");
481 assert(v.month as int == 12 , "%m: incorrect");
482
483 let v = newvirtual();
484 assert(parse(&v, "%M", "07") is void , "%M: parsefail");
485 assert(v.minute is int , "%M: void");
486 assert(v.minute as int == 7 , "%M: incorrect");
487
488 let v = newvirtual();
489 assert(parse(&v, "%N", "123456789") is void , "%N: parsefail");
490 assert(v.nanosecond is int , "%N: void");
491 assert(v.nanosecond as int == 123456789 , "%N: incorrect");
492
493 let v = newvirtual();
494 assert(parse(&v, "%N", "123") is void , "%N: parsefail");
495 assert(v.nanosecond is int , "%N: void");
496 assert(v.nanosecond as int == 123000000 , "%N: incorrect");
497
498 let v = newvirtual();
499 assert(parse(&v, "%p", "PM") is void , "%p: parsefail");
500 assert(v.ampm is bool , "%p: void");
501 assert(v.ampm as bool == true , "%p: incorrect");
502
503 let v = newvirtual();
504 assert(parse(&v, "%S", "08") is void , "%S: parsefail");
505 assert(v.second is int , "%S: void");
506 assert(v.second as int == 8 , "%S: incorrect");
507
508 let v = newvirtual();
509 assert(parse(&v, "%T", "18:42:05") is void , "%d: parsefail");
510 assert(v.hour is int , "%d: void");
511 assert(v.hour as int == 18 , "%d: incorrect");
512 assert(v.minute is int , "%d: void");
513 assert(v.minute as int == 42 , "%d: incorrect");
514 assert(v.second is int , "%d: void");
515 assert(v.second as int == 5 , "%d: incorrect");
516
517 let v = newvirtual();
518 assert(parse(&v, "%u", "5") is void , "%u: parsefail");
519 assert(v.weekday is int , "%u: void");
520 assert(v.weekday as int == 4 , "%u: incorrect");
521
522 let v = newvirtual();
523 assert(parse(&v, "%U", "51") is void , "%U: parsefail");
524 assert(v.week is int , "%U: void");
525 assert(v.week as int == 51 , "%U: incorrect");
526
527 let v = newvirtual();
528 assert(parse(&v, "%w", "5") is void , "%w: parsefail");
529 assert(v.weekday is int , "%w: void");
530 assert(v.weekday as int == 4 , "%w: incorrect");
531
532 let v = newvirtual();
533 assert(parse(&v, "%W", "51") is void , "%W: parsefail");
534 assert(v.week is int , "%W: void");
535 assert(v.week as int == 51 , "%W: incorrect");
536
537 let v = newvirtual();
538 assert(parse(&v, "%Y", "2019") is void , "%Y: parsefail");
539 assert(v.year is int , "%Y: void");
540 assert(v.year as int == 2019 , "%Y: incorrect");
541
542 let v = newvirtual();
543 assert(parse(&v, "%z", "+0100") is void , "%z: parsefail");
544 assert(v.zoff is i64 , "%z: void");
545 assert(v.zoff as i64 == 1 * time::HOUR , "%z: incorrect");
546 let v = newvirtual();
547 assert(parse(&v, "%z", "+01:00") is void , "%z: parsefail");
548 assert(v.zoff is i64 , "%z: void");
549 assert(v.zoff as i64 == 1 * time::HOUR , "%z: incorrect");
550
551 let v = newvirtual();
552 assert(parse(&v, "%Z", "CET") is void , "%Z: parsefail");
553 assert(v.zabbr is str , "%Z: void");
554 assert(v.zabbr as str == "CET" , "%Z: incorrect");
555
556 let v = newvirtual();
557 assert((
558 parse(&v,
559 "%Y-%m-%d %H:%M:%S.%N %z %Z %L",
560 "2038-01-19 03:14:07.000000000 +0000 UTC UTC",
561 )
562 is void
563 ),
564 "test 1: parsefail"
565 );
566 assert(v.year is int , "test 1: year void");
567 assert(v.year as int == 2038, "test 1: year incorrect");
568 assert(v.month is int , "test 1: month void");
569 assert(v.month as int == 1, "test 1: month incorrect");
570 assert(v.day is int , "test 1: day void");
571 assert(v.day as int == 19, "test 1: day incorrect");
572 assert(v.hour is int , "test 1: hour void");
573 assert(v.hour as int == 3, "test 1: hour incorrect");
574 assert(v.minute is int , "test 1: minute void");
575 assert(v.minute as int == 14, "test 1: minute incorrect");
576 assert(v.second is int , "test 1: second void");
577 assert(v.second as int == 7, "test 1: second incorrect");
578 assert(v.nanosecond is int , "test 1: nanosecond void");
579 assert(v.nanosecond as int == 0, "test 1: nanosecond incorrect");
580 assert(v.zoff is i64 , "test 1: zoff void");
581 assert(v.zoff as i64 == 0, "test 1: zoff incorrect");
582 assert(v.zabbr is str , "test 1: zabbr void");
583 assert(v.zabbr as str == "UTC", "test 1: zabbr incorrect");
584 assert(v.locname is str , "test 1: locname void");
585 assert(v.locname as str == "UTC", "test 1: locname incorrect");
586
587 };