2022-12-28 23:54:59 -08:00

#### 551 lines 16 KiB C Raw Blame History

 ```/** Is `y` a leap-year? */ ``` ```static int leap(int y) { ``` ``` assert(y >= 1582); ``` ``` if(!(y % 400)) return 1; ``` ``` if(!(y % 100)) return 0; ``` ``` if(!(y % 4)) return 1; ``` ``` return 0; ``` ```} ``` ```/** Convert or narrower type or return zero. */ ``` ```static union date32 date_to_32(const int y, const int m, const int d) { ``` ``` union date32 d32 = { 0 }; ``` ``` /* Leap year calculations only work at y>=1 and Gregorian Calendar and max ``` ``` 23 bits. */ ``` ``` if(y < 1582 || y > 8388607 || m < 1 || m > 12 || d < 1 || d > 31) goto no; ``` ``` switch(m) { ``` ``` case 1: case 3: case 5: case 7: case 8: case 10: case 12: break; ``` ``` case 4: case 6: case 9: case 11: if(d > 30) goto no; break; ``` ``` case 2: if(d > 28 + leap(y)) goto no; break; ``` ``` default: assert(0); break; ``` ``` } ``` ``` d32.year = (unsigned)y, d32.month = (unsigned)m, d32.day = (unsigned)d; ``` ```no: ``` ``` return d32; ``` ```} ``` ```/** Tomohiko Sakamoto comp.lang.c 1993-04-10. */ ``` ```static unsigned weekday(union date32 d) { ``` ``` d.year -= d.month < 3; ``` ``` return (d.year + d.year / 4 - d.year / 100 + d.year / 400 ``` ``` + "-bed=pen+mad."[d.month] + d.day) % 7; ``` ```} ``` ```/* ``` ```### plot with steps ``` ```reset session ``` ``` ``` ```\$Data <meaning); ``` ``` (lex = lex_array_next(&l_it)); ) { ``` ``` switch(lex->symbol) { ``` ``` case KJV_BOOK: ``` ``` if(state != CHILL && state != WORD) goto catch; ``` ``` if(state == WORD) printf("\n"); ``` ``` fprintf(stderr, "%d-%.2d-%.2d: \"%.*s\", ", ``` ``` entry.key->year, entry.key->month, entry.key->day, ``` ``` (int)(lex->s1 - lex->s0), lex->s0); ``` ``` state = BOOK; ``` ``` break; ``` ``` case KJV_CHAPTER_VERSE: ``` ``` if(state != BOOK) goto catch; ``` ``` printf("\"%.*s\", \"", (int)(lex->s1 - lex->s0), lex->s0); ``` ``` state = CHAPTER; ``` ``` break; ``` ``` case KJV_NEXT: ``` ``` if(state != WORD) goto catch; ``` ``` printf("\"\n"); ``` ``` break; ``` ``` case KJV_TEXT: ``` ``` if(state != WORD && state != CHAPTER && state != NEXT) ``` ``` goto catch; ``` ``` printf("%s%.*s<%d>", state == WORD ? "*" : "", ``` ``` (int)(lex->s1 - lex->s0 < 0 ? 10 : lex->s1 - lex->s0), ``` ``` lex->s0, (int)(lex->s1 - lex->s0)); ``` ``` count++; ``` ``` state = WORD; ``` ``` break; ``` ``` default: ``` ``` if(state != CHILL && state != WORD) goto catch; ``` ``` if(state == WORD) printf("\"\n"), state = CHILL; ``` ``` break; ``` ``` } ``` ``` } ``` ``` if(state != CHILL && state != WORD) goto catch; ``` ``` if(state == WORD) printf("\n"), state = CHILL; ``` ``` } ``` ``` printf("Count: %lu.\n", (unsigned long)count); ``` ``` return 1; ``` ```catch: ``` ``` fprintf(stderr, "Bible error.\n"); ``` ``` if(entry.key) { ``` ``` fprintf(stderr, "On date: %d-%.2d-%.2d.\n", ``` ``` entry.key->year, entry.key->month, entry.key->day); ``` ``` if(lex) fprintf(stderr, "At line %lu.\n", (unsigned long)lex->line); ``` ``` } ``` ``` errno = EILSEQ; ``` ``` return 0; ``` ```} ``` ``` ``` ```#define C_BLACK "\033[0;30m" ``` ```#define C_RED "\033[0;31m" ``` ```#define C_GREEN "\033[0;32m" ``` ```#define C_YELLOW "\033[0;33m" ``` ```#define C_BLUE "\033[0;34m" ``` ```#define C_PURPLE "\033[0;35m" ``` ```#define C_CYAN "\033[0;36m" ``` ```#define C_WHITE "\033[0;37m" ``` ``` ``` ```#define CB_BLACK "\033[1;30m" ``` ```#define CB_RED "\033[1;31m" ``` ```#define CB_GREEN "\033[1;32m" ``` ```#define CB_YELLOW "\033[1;33m" ``` ```#define CB_BLUE "\033[1;34m" ``` ```#define CB_PURPLE "\033[1;35m" ``` ```#define CB_CYAN "\033[1;36m" ``` ```#define CB_WHITE "\033[1;37m" ``` ``` ``` ```#define C_RESET "\033[0m" ``` ``` ``` ```int main(int argc, char **argv) { ``` ``` int success = EXIT_SUCCESS; ``` ``` char *intent = 0; ``` ``` ``` ``` /* For reading in files, overwritten. */ ``` ``` DIR *dir = 0; ``` ``` struct dirent *de; ``` ``` struct int_array years = int_array(), months = int_array(), ``` ``` days = int_array(); ``` ``` int *y, *y_end; ``` ``` ``` ``` struct page_tree journal = page_tree(); ``` ``` ``` ``` errno = 0; ``` ``` if(argc != 2) { intent = "needs journal location, which should" ``` ``` " contain //.txt"; goto catch; } ``` ``` ``` ``` /* Get the years list as directories matching a year. */ ``` ``` if(chdir(argv[1]) == -1 || !(dir = opendir("."))) goto catch; ``` ``` while((de = readdir(dir))) { ``` ``` struct stat st; ``` ``` int year, *p; ``` ``` if(!lex_looks_like_year(de->d_name, &year)) continue; ``` ``` if(stat(de->d_name, &st)) goto catch; ``` ``` if(!S_ISDIR(st.st_mode)) continue; ``` ``` if(!(p = int_array_new(&years))) goto catch; ``` ``` *p = year; ``` ``` } ``` ``` closedir(dir), dir = 0; ``` ``` /* Sort the years for sensible ordering of parsing. */ ``` ``` qsort(years.data, years.size, sizeof *years.data, &void_int_cmp); ``` ``` fprintf(stderr, "Years in <<%s>>: %s.\n", ``` ``` argv[1], int_array_to_string(&years)); ``` ``` ``` ``` /* Go though each year. */ ``` ``` for(y = years.data, y_end = y + years.size; y < y_end; y++) { ``` ``` char fn[64]; ``` ``` int *m, *m_end; ``` ``` sprintf(fn, "%d", *y); ``` ``` ``` ``` /* Get the months as directories. */ ``` ``` if(chdir(fn) == -1 || !(dir = opendir("."))) goto catch; ``` ``` while((de = readdir(dir))) { ``` ``` struct stat st; ``` ``` int month, *p; ``` ``` if(!(month = lex_looks_like_month(de->d_name))) continue; ``` ``` if(stat(de->d_name, &st)) goto catch; ``` ``` if(!S_ISDIR(st.st_mode)) continue; ``` ``` if(!(p = int_array_new(&months))) goto catch; ``` ``` *p = month; ``` ``` } ``` ``` closedir(dir), dir = 0; ``` ``` qsort(months.data, months.size, sizeof *months.data, &void_int_cmp); ``` ``` fprintf(stderr, "Months in <<%s>>: %s.)\n", ``` ``` fn, int_array_to_string(&months)); ``` ``` ``` ``` /* Go though each month. */ ``` ``` for(m = months.data, m_end = m + months.size; m < m_end; m++) { ``` ``` int *d, *d_end; ``` ``` sprintf(fn, "%.2d", *m); ``` ``` ``` ``` /* Get the days as files. */ ``` ``` if(chdir(fn) == -1 || !(dir = opendir("."))) goto catch; ``` ``` while((de = readdir(dir))) { ``` ``` struct stat st; ``` ``` int day, *p; ``` ``` /* fixme: Have yyyy-mm-dd to figure out how many days. */ ``` ``` if(!(day = lex_looks_like_day(de->d_name))) continue; ``` ``` if(stat(de->d_name, &st)) goto catch; ``` ``` if(S_ISDIR(st.st_mode)) continue; ``` ``` if(!(p = int_array_new(&days))) goto catch; ``` ``` *p = day; ``` ``` } ``` ``` closedir(dir), dir = 0; ``` ``` qsort(days.data, days.size, sizeof *days.data, &void_int_cmp); ``` ``` fprintf(stderr, "Days in <<%s>>: %s.\n", ``` ``` fn, int_array_to_string(&days)); ``` ``` ``` ``` for(d = days.data, d_end = d + days.size; d < d_end; d++) { ``` ``` struct lex *lex = 0; ``` ``` struct page *page = 0; ``` ``` union date32 d32; ``` ``` if(!(d32 = date_to_32(*y, *m, *d)).year) { errno = EILSEQ; ``` ``` intent = "date parse error"; goto syntax; } ``` ``` sprintf(fn, "%.2d.txt", *d); ``` ``` if(page_tree_bulk_add(&journal, d32, &page) != TREE_UNIQUE) { ``` ``` if(!errno) intent = "not unique", errno = EDOM; ``` ``` goto syntax; ``` ``` } ``` ``` page->entry = char_array(); ``` ``` page->meaning = lex_array(); ``` ``` if(!append_file(&page->entry, fn)) goto syntax; ``` ``` int first = 1; ``` ``` for(lex_reset(page->entry.data); ; ) { ``` ``` if(!(lex = lex_array_new(&page->meaning))) goto syntax; ``` ``` if(!lex_next(lex)) { ``` ``` if(lex->symbol != END) { errno = EILSEQ; goto syntax; } ``` ``` break; /* Terminated successfully. */ ``` ``` } ``` ``` switch(lex->symbol) { ``` ``` case TEXT: printf("%s%.*s", ``` ``` first ? "" : " ", (int)(lex->s1 - lex->s0), lex->s0); ``` ``` first = 0; break; ``` ``` case PARAGRAPH: printf("\n" C_RESET); break; ``` ``` case KJV_BOOK: printf(C_YELLOW "%.*s", ``` ``` (int)(lex->s1 - lex->s0), lex->s0); break; ``` ``` case KJV_CHAPTER_VERSE: printf(" ch. %.*s", ``` ``` (int)(lex->s1 - lex->s0), lex->s0); break; ``` ``` case KJV_TEXT: printf("%.*s", ``` ``` (int)(lex->s1 - lex->s0), lex->s0); break; ``` ``` case KJV_NEXT: printf("(next)\n"); break; ``` ``` default: ``` ``` fprintf(stderr, "%lu: %s", ``` ``` (unsigned long)lex->line, lex_symbols[lex->symbol]); ``` ``` if(lex->s0 && lex->s1) { ``` ``` if(lex->s0 + INT_MAX < lex->s1) ``` ``` intent = "line too long", errno = EILSEQ; ``` ``` else ``` ``` fprintf(stderr, " <<%.*s>>", ``` ``` (int)(lex->s1 - lex->s0), lex->s0); ``` ``` } ``` ``` fprintf(stderr, ".\n"); ``` ``` break; ``` ``` } ``` ``` } ``` ``` continue; ``` ```syntax: ``` ``` fprintf(stderr, "On date: %d-%.2d-%.2d.\n", *y, *m, *d); ``` ``` if(!page) goto catch; ``` ``` if(!lex) { fprintf(stderr, "While parsing <<<\n%s>>>.\n", ``` ``` page->entry.data); goto catch; } ``` ``` for(struct lex_array_iterator it ``` ``` = lex_array_iterator(&page->meaning); ``` ``` lex = lex_array_next(&it); ) { ``` ``` fprintf(stderr, "%lu: %s", ``` ``` (unsigned long)lex->line, lex_symbols[lex->symbol]); ``` ``` if(lex->s0 && lex->s1) { ``` ``` if(lex->s0 + INT_MAX < lex->s1) ``` ``` intent = "line too long", errno = EILSEQ; ``` ``` else ``` ``` fprintf(stderr, " <<%.*s>>", ``` ``` (int)(lex->s1 - lex->s0), lex->s0); ``` ``` } ``` ``` fprintf(stderr, ".\n"); ``` ``` } ``` ``` goto catch; ``` ``` } ``` ``` ``` ``` int_array_clear(&days); ``` ``` if(chdir("..") == -1) goto catch; ``` ``` } ``` ``` ``` ``` int_array_clear(&months); ``` ``` if(chdir("..") == -1) goto catch; ``` ``` /* fixme: Expand, contact is the next thing that it doesn't get. */ ``` ``` if(*y == 1993/*1996*/) break; ``` ``` } ``` ``` page_tree_bulk_finish(&journal); ``` ``` int_array_(&years), int_array_(&months), int_array_(&days); ``` ``` fprintf(stderr, "Journal has entries: %s\n", page_tree_to_string(&journal)); ``` ``` ``` ``` /* Do something interesting? */ ``` ``` if(!bible_graph(&journal)) goto catch; ``` ``` ``` ``` goto finally; ``` ```catch: ``` ``` success = EXIT_FAILURE; ``` ``` perror("interpret"); ``` ``` if(intent) fprintf(stderr, "Further explanation: %s.\n", intent); ``` ```finally: ``` ``` if(dir && closedir(dir)) success = EXIT_FAILURE, perror("dir"); ``` ``` int_array_(&years), int_array_(&months), int_array_(&days); ``` ``` struct page_tree_entry entry; ``` ``` for(struct page_tree_iterator it = page_tree_begin(&journal); ``` ``` (entry = page_tree_next(&it)).key; ) { ``` ``` struct page *const page = entry.value; ``` ``` char z[12]; ``` ``` date32_to_string(*entry.key, &z); ``` ``` lex_array_(&page->meaning); ``` ``` char_array_(&page->entry); ``` ``` } ``` ``` return success; ``` ```} ``` ``` ``` ```/* Popular KJV 738137 words. */ ``` ``` ``` ```struct scan scan(const char *const buffer) { ``` ``` struct scan scan; ``` ``` scan.marker = scan.from = scan.cursor = scan.label = scan.buffer = buffer; ``` ``` scan.condition = yycline; ``` ``` scan.line = 1; ``` ``` return scan; ``` ```} ``` ``` ``` ```int scan_next(struct scan *const s, struct lex *const x) { ``` ``` /*!re2c /**/ ``` ``` re2c:flags:tags = 1; ``` ``` re2c:define:YYCTYPE = char; ``` ``` re2c:yyfill:enable = 0; ``` ``` re2c:define:YYCURSOR = s->cursor; ``` ``` re2c:define:YYMARKER = s->marker; ``` ``` re2c:define:YYCONDTYPE = 'condition'; ``` ``` re2c:define:YYGETCONDITION = 's->condition'; ``` ``` re2c:define:YYGETCONDITION:naked = 1; ``` ``` re2c:define:YYSETCONDITION = 's->condition = @@;'; ``` ``` re2c:define:YYSETCONDITION:naked = 1; ``` ``` sentinel = "\x00"; ``` ``` newline = "\n"; ``` ``` unix_control = [\x01-\x08\x0a-\x1f\x7f]; ``` ``` ws = [ \t]; ``` ``` glyph = [^] \ (sentinel | unix_control | newline | ws); ``` ``` keyword = ([a-zA-Z] | [0-9][0-9_\-]*[a-zA-Z]) [a-zA-Z0-9_\-]*; ``` ``` decimal = "-"? ([1-9][0-9]* | [0])? "." [0-9]+ | [1-9][0-9]* | [0]; ``` ``` natural = [1-9][0-9]*; ``` ``` date = "-"? natural "-" [0-1][0-9] "-" [0-1][0-9]; ``` ``` */ ``` ``` const char *s0, *s1; ``` ``` /*!stags:re2c format = 'const char *@@;\n'; */ ``` ``` assert(s && x); ``` ``` if(!s->buffer) return 0; ``` ``` x->line = s->line; ``` ``` x->s0 = x->s1 = 0; ``` ```scan: ``` ``` /*!re2c /**/ ``` ``` <*> unix_control { return x->symbol = ILLEGAL, 0; } ``` ``` <*> * { return x->symbol = SYNTAX, 0; } ``` ``` <*> sentinel /* New line always delimits. */ ``` ``` { return x->symbol = s->condition == yycline ? END : ILLEGAL, 0; } ``` ``` newline => line { x->line = ++s->line; goto scan; } ``` ``` /* Symbols that go at the beginning of a line. */ ``` ``` newline { x->line = ++s->line; goto scan; } ``` ``` "[" :=> edict ``` ``` "--" :=> source ``` ``` "->" :=> location ``` ``` "!" => text { return x->symbol = COMPLETE, 1; } ``` ``` "^" => text { return x->symbol = CANCELLED, 1; } ``` ``` "#" => text { return x->symbol = HEADING, 1; } ``` ``` * :=> text ``` ``` ``` ``` newline => line { x->line = ++s->line; goto scan; } ``` ``` ws+ { goto scan; } ``` ``` @s0 glyph+ @s1 ``` ``` { x->s0 = s0, x->s1 = s1; return x->symbol = TEXT, 1; } ``` ``` ``` ``` ``` ``` @s0 keyword @s1 => expect_line ``` ``` { x->s0 = s0, x->s1 = s1; return x->symbol = SOURCE_RECALL, 1; } ``` ``` ``` ``` "" / "(" :=> map ``` ``` "[" ws* @s0 keyword @s1 ws* "]" ``` ``` { x->s0 = s0, x->s1 = s1; return x->symbol = LOCATION_SAVE, 1; } ``` ``` @s0 keyword @s1 => expect_line ``` ``` { x->s0 = s0, x->s1 = s1; return x->symbol = LOCATION_RECALL, 1; } ``` ``` ``` ``` "(" @s0 decimal "," @s1 decimal ")" => expect_caption ``` ``` { x->s0 = s0, x->s1 = s1; return x->symbol = LOCATION, 1; } ``` ``` ``` ``` "source" :=> source ``` ``` "ed" :=> ed ``` ``` "contact" :=> contact ``` ``` "glider" :=> glider ``` ``` "flight" :=> flight ``` ``` "bible" :=> bible ``` ``` "book" :=> book ``` ``` "movie" :=> movie ``` ``` "tv" :=> tv ``` ``` "medication" :=> medication ``` ``` "idea" :=> idea ``` ``` "vaccine" :=> vaccine ``` ``` "in" :=> in ``` ``` "" / natural :=> significant ``` ``` [0-1][0-9] "-" [0-3][0-9] ``` ``` ", " [0-2][0-9] ":" [0-5][0-9] "] " ``` ``` :=> text /* This is likely WhatsApp conversations. Ignore. */ ``` ``` /* missed, show, 'First, Second', 'Sounds', 'CSS', ..., 'Swanky', 'Shields' */ ``` ``` ``` ``` /* How did it get into my journal? */ ``` ``` "source" ``` ``` { if(s->is_ws_expected || s->edict.size) ``` ``` return x->symbol = SYNTAX, 0; ``` ``` s->is_ws_expected = 1, s->is_source = 1; ``` ``` s->edict.size = 2; ``` ``` s->edict.expect[1] = EXPECT_KEYWORD; ``` ``` s->edict.expect[0] = EXPECT_END_TEXT; ``` ``` return x->symbol = SOURCE, 1; } ``` ``` "default" ``` ``` { if(s->is_ws_expected || !s->is_source) ``` ``` return x->symbol = SYNTAX, 0; ``` ``` s->is_ws_expected = 1, s->is_source = 0; ``` ``` return x->symbol = DEFAULT, 1; } ``` ``` ``` ``` /* Editorializing; looking back. */ ``` ``` "ed" ``` ``` { if(s->is_ws_expected || s->edict.size) ``` ``` return x->symbol = SYNTAX, 0; ``` ``` s->is_ws_expected = 1; /* no idea, just copy; probably should do sth */ ``` ``` s->edict.size = 1; ``` ``` s->edict.expect[0] = EXPECT_END_TEXT; /* Pithy comment. */ ``` ``` return x->symbol = EDITORIALIZING, 1; } ``` ``` ``` ``` /* Score. */ ``` ``` "significant" ``` ``` { if(s->is_ws_expected || s->edict.size) ``` ``` return x->symbol = SYNTAX, 0; ``` ``` s->is_ws_expected = 1; ``` ``` s->edict.size = 3; ``` ``` s->edict.expect[2] = EXPECT_NATURAL; /* Ordinal. */ ``` ``` s->edict.expect[1] = EXPECT_RESTRICT_TEXT; /* Name. */ ``` ``` s->edict.expect[0] = EXPECT_DATE; /* Birthday. */ ``` ``` return x->symbol = SIGNIFICANT, 1; } ``` ``` @s0 natural @s1 ``` ``` { if(s->is_ws_expected || s->edict.size) ``` ``` return x->symbol = SYNTAX, 0; ``` ``` s->is_ws_expected = 1; ``` ``` x->s0 = s0, x->s1 = s1; ``` ``` return x->symbol = SIGNIFICANT_RECALL, 1; } ``` ``` ``` ``` /* General [edict: whatever]. */ ``` ``` ws+ { s->is_ws_expected = 0; goto scan; } ``` ``` ":" ``` ``` { if(!s->edict.size) return x->symbol = SYNTAX, 0; ``` ``` s->is_ws_expected = 0, s->is_source = 0; ``` ``` expect_pop(); goto scan; } ``` ``` ws* @s0 keyword @s1 ws* ";"? ``` ``` { x->s0 = s0, x->s1 = s1; expect_pop(); ``` ``` return x->symbol = ARG_KEYWORD, 1; } ``` ``` ws* @s0 date @s1 ws* ";"? ``` ``` { x->s0 = s0, x->s1 = s1; expect_pop(); ``` ``` return x->symbol = ARG_DATE, 1; } ``` ``` ws* @s0 natural @s1 ws* ";"? ``` ``` { x->s0 = s0, x->s1 = s1; expect_pop(); ``` ``` return x->symbol = ARG_NATURAL, 1; } ``` ``` ``` ``` ws* @s0 (glyph \ [;[\]]) ((glyph \ [;[\]]) | ws)* @s1 ws* ";"? ``` ``` { x->s0 = s0, x->s1 = s1; expect_pop(); ``` ``` return x->symbol = ARG_RESTRICT_TEXT, 1; } ``` ``` ``` ``` ws* @s0 (glyph \ [[\]]) ((glyph \ [[\]]) | ws)* @s1 ws* ``` ``` { x->s0 = s0, x->s1 = s1; expect_pop(); ``` ``` return x->symbol = ARG_END_TEXT, 1; } ``` ``` "]" => expect_line ``` ``` { if(s->edict.size) return 0; goto scan; } ``` ``` */ ``` ```} ``` ``` ``` ```#define FOR_SYMBOL(X) \ ``` ``` \ ``` ``` /* Results. */ \ ``` ``` X(END, 0), \ ``` ``` X(SYNTAX, 0), \ ``` ``` X(ILLEGAL, 0), \ ``` ``` X(NOT_FOUND, 0), \ ``` ``` \ ``` ``` X(ORDERED_LIST_ITEM, &no_vt), \ ``` ``` X(LIST_ITEM, 0), \ ``` ``` X(COMPLETE, 0), \ ``` ``` X(CANCELLED, 0), \ ``` ``` X(HEADING, 0), \ ``` ``` /* Text. */ \ ``` ``` X(PARAGRAPH, 0), \ ``` ``` X(TEXT, &word_vt), \ ``` ``` /*This is lazy.*/X(CAPTION, &word_vt), \ ``` ``` \ ``` ``` /* Edicts. */ \ ``` ``` X(SOURCE, &word_vt), \ ``` ``` X(DEFAULT, 0), \ ``` ``` X(SOURCE_RECALL, &word_vt), \ ``` ``` X(LOCATION, 0), \ ``` ``` X(LOCATION_SAVE, 0), \ ``` ``` X(LOCATION_RECALL, 0), \ ``` ``` X(SIGNIFICANT, 0), \ ``` ``` X(SIGNIFICANT_RECALL, 0), \ ``` ``` X(EDITORIALIZING, 0), \ ``` ``` \ ``` ``` /* Arguments. */ \ ``` ``` X(ARG_KEYWORD, 0), \ ``` ``` X(ARG_DATE, &date_vt), \ ``` ``` X(ARG_NATURAL, &no_vt), \ ``` ``` X(ARG_RESTRICT_TEXT, &word_vt), \ ``` ``` X(ARG_END_TEXT, &word_vt), \ ``` ``` \ ``` ``` /* Bible */ \ ``` ``` X(KJV_BOOK, &kjv_book_vt), \ ``` ``` X(KJV_CHAPTER_VERSE, &word_vt), \ ``` ``` X(KJV_TEXT, &word_vt), \ ``` ``` X(KJV_NEXT, 0) ``` ``` ``` ```int scan(union date32 date, const char *const buffer); ``` ``` ``` ```struct scan { ``` ``` const char *marker, *from, *cursor, *limit, *label, *buffer; ``` ``` int condition; ``` ``` size_t line; ``` ``` int is_ws_expected; ``` ```}; ``` ``` ``` ```struct lex { ``` ``` size_t line; ``` ```#define ARG1(n, m) n ``` ``` enum lex_symbol { FOR_SYMBOL(ARG1) } symbol; ``` ```#undef ARG1 ``` ``` const char *s0, *s1; ``` ```}; ``` ```#define STR1(n, m) #n ``` ```static const char *const lex_symbols[] = { FOR_SYMBOL(STR1) }; ``` ```#undef X ``` ``` ``` ```struct scan scan(const char *); ``` ```int scan_next(struct scan *const s, struct lex *const x); ```