interpret/src/journal.re.c

#include "../src/text.h"
#define OMIT_DAY
#define OMIT_PROTO
#include "../src/journal.h" /* base */
#include <inttypes.h> /* C99 */
#include <limits.h>
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <unistd.h> /* chdir (POSIX) */
#include <sys/types.h> /* mode_t (POSIX) */
#include <sys/stat.h> /* umask (POSIX) */
#include <dirent.h> /* opendir readdir closedir */


static void date32_to_string(const union date32 d, char (*const a)[12]) {
	assert(a
		&& d.year < 10000 && d.month && d.month <= 31 && d.day && d.day <= 31);
	sprintf(*a, "%" PRIu32 "-%2.2" PRIu32 "-%2.2" PRIu32,
		(unsigned)d.year % 10000, (unsigned)d.month, (unsigned)d.day);
}
static int day_compare(const union date32 a, const union date32 b)
	{ return a.u32 > b.u32; }
static void day_to_string(const union date32 d, char *const*const entry,
	char (*const a)[12]) { (void)entry; date32_to_string(d, a); }
#define TREE_NAME day
#define TREE_KEY union date32
#define TREE_VALUE char *
#define TREE_COMPARE
#define TREE_TO_STRING
#include "../src/tree.h"


/*!re2c
re2c:yyfill:enable = 0;
re2c:define:YYCTYPE = char;
*/

/** "-"? [1-9][0-9]*$, within the range of `INT_MAX`. */
static int looks_like_year(const char *const a, int *const year) {
	const char *YYCURSOR = a, *YYMARKER = a, *s0;
	/*!stags:re2c format = 'const char *@@;\n'; */
	assert(a && year);
	/*!re2c /**/
	@s0 ("-"? [1-9][0-9]* | "0") "\x00" {
		int sign = 1, mag;
		if(*s0 == '-') { sign = -1; s0++; }
		for(mag = 0; *s0 != '\0'; s0++) {
			int d = *s0 - '0';
			if((INT_MAX - d) / 10 < mag) return 0;
			mag = mag * 10 + d;
		}
		*year = sign * mag;
		return 1;
	}
	* { return 0; }
	*/
}

/** 1 <= [0-1][0-9]$ <= 12 */
static unsigned looks_like_month(const char *const a) {
	const char *YYCURSOR = a, *YYMARKER = a, *s0;
	/*!stags:re2c format = 'const char *@@;\n'; */
	(void)yyt1;
	assert(a);
	/*!re2c /**/
	@s0 [0-1][0-9] "\x00" {
		unsigned val = 10u * (unsigned)(s0[0] - '0') + (unsigned)(s0[1] - '0');
		return val < 1 || val > 12 ? 0 : val;
	}
	* { return 0; }
	*/
}

/** 1 <= [0-3][0-9].txt$ <= 31 */
static unsigned looks_like_day(const char *const a) {
	const char *YYCURSOR = a, *YYMARKER = a, *s0;
	/*!stags:re2c format = 'const char *@@;\n'; */
	(void)yyt1;
	assert(a);
	/*!re2c /**/
	@s0 [0-3][0-9] ".txt\x00" {
		unsigned val = 10u * (unsigned)(s0[0] - '0') + (unsigned)(s0[1] - '0');
		return val < 1 || val > 31 ? 0 : val;
	}
	* { return 0; }
	*/
}

#if 0
/** 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;
}
/** @return Pack into `date32` 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;
}
#endif


#define OMIT_BASE
#define OMIT_DAY
#include "../src/journal.h" /* Just prototypes. */

void journal_(struct journal *const j) {
}

struct journal journal(void) {
	struct journal j = {0};
	return j;
}

int journal_is_valid(const struct journal *const j) {
	return 0;
}

const char *journal_to_string(const struct journal *const j)
	{ return day_tree_to_string(&j->days); }



#if 0

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;
}

#endif