551 lines
16 KiB
C
551 lines
16 KiB
C
|
/** 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 <<EOD
|
||
|
1,1,0
|
||
|
1,2,0
|
||
|
1,3,0
|
||
|
1,4,2
|
||
|
1,5,1
|
||
|
1,6,3
|
||
|
1,7,3
|
||
|
1,8,1
|
||
|
1,9,3
|
||
|
1,10,8
|
||
|
1,11,1
|
||
|
1,12,0
|
||
|
1,13,3
|
||
|
EOD
|
||
|
|
||
|
set title "Cumulative count" font ",16"
|
||
|
set xlabel "episode"
|
||
|
set ylabel "cumulative count"
|
||
|
set xtics 1
|
||
|
set key bottom right
|
||
|
set grid
|
||
|
unset border
|
||
|
|
||
|
set datafile separator comma
|
||
|
plot $Data u 2:($3) smooth cumulative with steps lw 2 lc "red" ti "cumulative count"
|
||
|
### end of code
|
||
|
*/
|
||
|
static int bible_graph(/*const*/ struct page_tree *const journal) {
|
||
|
enum { CHILL, BOOK, CHAPTER, WORD, NEXT } state = CHILL;
|
||
|
struct page_tree_entry entry = { 0, 0 };
|
||
|
struct lex *lex = 0;
|
||
|
size_t count = 0;
|
||
|
for(struct page_tree_iterator p_it = page_tree_begin(journal);
|
||
|
(entry = page_tree_next(&p_it)).key; ) {
|
||
|
struct page *const page = entry.value;
|
||
|
for(struct lex_array_iterator l_it = lex_array_iterator(&page->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 <year>/<month>/<day>.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; }
|
||
|
<expect_line> newline => line { x->line = ++s->line; goto scan; }
|
||
|
/* Symbols that go at the beginning of a line. */
|
||
|
<line> newline { x->line = ++s->line; goto scan; }
|
||
|
<line> "[" :=> edict
|
||
|
<line> "--" :=> source
|
||
|
<line> "->" :=> location
|
||
|
<line> "!" => text { return x->symbol = COMPLETE, 1; }
|
||
|
<line> "^" => text { return x->symbol = CANCELLED, 1; }
|
||
|
<line> "#" => text { return x->symbol = HEADING, 1; }
|
||
|
<line> * :=> text
|
||
|
|
||
|
<text> newline => line { x->line = ++s->line; goto scan; }
|
||
|
<text, bible> ws+ { goto scan; }
|
||
|
<text> @s0 glyph+ @s1
|
||
|
{ x->s0 = s0, x->s1 = s1; return x->symbol = TEXT, 1; }
|
||
|
|
||
|
|
||
|
<source> @s0 keyword @s1 => expect_line
|
||
|
{ x->s0 = s0, x->s1 = s1; return x->symbol = SOURCE_RECALL, 1; }
|
||
|
|
||
|
<location> "" / "(" :=> map
|
||
|
<location> "[" ws* @s0 keyword @s1 ws* "]"
|
||
|
{ x->s0 = s0, x->s1 = s1; return x->symbol = LOCATION_SAVE, 1; }
|
||
|
<location> @s0 keyword @s1 => expect_line
|
||
|
{ x->s0 = s0, x->s1 = s1; return x->symbol = LOCATION_RECALL, 1; }
|
||
|
|
||
|
<map> "(" @s0 decimal "," @s1 decimal ")" => expect_caption
|
||
|
{ x->s0 = s0, x->s1 = s1; return x->symbol = LOCATION, 1; }
|
||
|
|
||
|
<edict> "source" :=> source
|
||
|
<edict> "ed" :=> ed
|
||
|
<edict> "contact" :=> contact
|
||
|
<edict> "glider" :=> glider
|
||
|
<edict> "flight" :=> flight
|
||
|
<edict> "bible" :=> bible
|
||
|
<edict> "book" :=> book
|
||
|
<edict> "movie" :=> movie
|
||
|
<edict> "tv" :=> tv
|
||
|
<edict> "medication" :=> medication
|
||
|
<edict> "idea" :=> idea
|
||
|
<edict> "vaccine" :=> vaccine
|
||
|
<edict> "in" :=> in
|
||
|
<edict> "" / natural :=> significant
|
||
|
<edict> [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? */
|
||
|
<edict> "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; }
|
||
|
<edict> "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. */
|
||
|
<edict> "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. */
|
||
|
<edict> "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; }
|
||
|
<edict> @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]. */
|
||
|
<edict> ws+ { s->is_ws_expected = 0; goto scan; }
|
||
|
<edict> ":"
|
||
|
{ if(!s->edict.size) return x->symbol = SYNTAX, 0;
|
||
|
s->is_ws_expected = 0, s->is_source = 0;
|
||
|
expect_pop(); goto scan; }
|
||
|
<edict_keyword> ws* @s0 keyword @s1 ws* ";"?
|
||
|
{ x->s0 = s0, x->s1 = s1; expect_pop();
|
||
|
return x->symbol = ARG_KEYWORD, 1; }
|
||
|
<edict_date> ws* @s0 date @s1 ws* ";"?
|
||
|
{ x->s0 = s0, x->s1 = s1; expect_pop();
|
||
|
return x->symbol = ARG_DATE, 1; }
|
||
|
<edict_natural> ws* @s0 natural @s1 ws* ";"?
|
||
|
{ x->s0 = s0, x->s1 = s1; expect_pop();
|
||
|
return x->symbol = ARG_NATURAL, 1; }
|
||
|
<edict_restrict_text>
|
||
|
ws* @s0 (glyph \ [;[\]]) ((glyph \ [;[\]]) | ws)* @s1 ws* ";"?
|
||
|
{ x->s0 = s0, x->s1 = s1; expect_pop();
|
||
|
return x->symbol = ARG_RESTRICT_TEXT, 1; }
|
||
|
<edict_end_text>
|
||
|
ws* @s0 (glyph \ [[\]]) ((glyph \ [[\]]) | ws)* @s1 ws*
|
||
|
{ x->s0 = s0, x->s1 = s1; expect_pop();
|
||
|
return x->symbol = ARG_END_TEXT, 1; }
|
||
|
<edict, edict_end> "]" => 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);
|