interpret/src/journal.re.c

#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 */


union load { const char *text; size_t offset; };
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, const union load *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 union load
#define TREE_COMPARE
#define TREE_TO_STRING
#include "../src/tree.h"


/* Temporary filename arrangement. */
#if INT_MAX >= 100000000000
#error int_to_string requires truncation on this compiler.
#endif
static void int_to_string(const int *const n, char (*const a)[12])
	{ sprintf(*a, "%d", *n); }
#define ARRAY_NAME int
#define ARRAY_TYPE int
#define ARRAY_TO_STRING
#include "../src/array.h"
static int int_cmp(const int *const a, const int *const b)
	{ return (*b < *a) - (*a < *b); }
static int void_int_cmp(const void *const a, const void *const b)
	{ return int_cmp(a, b); }


/*!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) {
	if(!j) return;
	day_tree_(&j->days);
	text_(&j->backing);
}

struct journal journal(void) {
	const char *const dir_journal = "journal";
	struct journal j = {0};
	char *intent = 0;
	DIR *dir = 0;
	struct dirent *de = 0;
	struct int_array years = int_array(), months = int_array(),
		days = int_array();
	int *y = 0, *y_end, *m = 0, *m_end, *d = 0, *d_end;

	/* Get the years list as directories matching a year. */
	if(chdir(dir_journal) == -1 || !(dir = opendir("."))) goto catch;
	while((de = readdir(dir))) {
		struct stat st;
		int year, *p;
		if(!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;
	}
	if(closedir(dir)) { dir = 0; goto catch; } 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",
		dir_journal, 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];
		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 = (int)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;
		}
		if(closedir(dir)) { dir = 0; goto catch; } 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++) {
			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;
				if(!(day = (int)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;
			}
			if(closedir(dir)) { dir = 0; goto catch; } 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++) {
				union load *load;
				const union date32 d32 = { .year = (uint32_t)*y,
					.month = (uint32_t)*m, .day = (uint32_t)*d };
				char *contents = 0;
				sprintf(fn, "%.2d.txt", *d); /* Reconstruct. */
				if(!(contents = text_append_file(&j.backing, fn))) goto syntax;
				switch(day_tree_bulk_add(&j.days, d32, &load)) {
				case TREE_PRESENT: intent = "not unique", errno = EDOM; /*Sic*/
				case TREE_ERROR: goto syntax;
				case TREE_ABSENT: break; /* Expected. */
				}
				/* The pointers are not stable while we are loading it. */
				load->offset = (size_t)(contents - j.backing.a.data);
				continue;
syntax:
				goto catch;
			}
			d = 0, int_array_clear(&days);
			if(chdir("..") == -1) goto catch;
		}
		m = 0, 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;
	}
	day_tree_bulk_finish(&j.days);
	fprintf(stderr, "Journal has entries: %s\n", day_tree_to_string(&j.days));
	goto finally;
catch:
	fprintf(stderr, "On date: %d-%.2d-%.2d.\n",
		y ? *y : -1, m ? *m : -1, d ? *d : -1);
	if(intent) fprintf(stderr, "Explanation: %s.\n", intent);
	day_tree_(&j.days);
finally:
	if(dir) closedir(dir); dir = 0;
	int_array_(&years), int_array_(&months), int_array_(&days);
	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); }