interpret/src/journal.re.c

/** @license 2022 Neil Edelman, distributed under the terms of the
 [GNU General Public License 3](https://opensource.org/licenses/GPL-3.0).

 Reading all journal entries yyyy-mm-dd in yyyy/mm/dd.txt to a tree.
 [re2c](https://re2c.org/) is a convince (and fast) for "looks like" functions,
 telling the recursion to go into a directory.
 @std GNU, C11, assumes reverse order unions. */

#include "../src/journal.h"
#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 */

/* Day tree-map from date to pointer; is backed by a huge array of text. */
void date32_to_string(const union date32 d, char (*const a)[12]) {
	sprintf(*a, "%" PRIu32 "-%2.2" PRIu32 "-%2.2" PRIu32,
		d.year % 10000, d.month % 100, d.day % 100);
}
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 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 const char *
#define TREE_COMPARE
#define TREE_TO_STRING
#define TREE_BODY
#include "../src/tree.h"

/* Temporary filename arrangement in directory; private. */
#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"
/** Comparator of `a`, `b`. */
static int int_cmp(const int *const a, const int *const b)
	{ return (*b < *a) - (*a < *b); }
/** For `qsort`. */
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; }
	*/
}

/** Erases memory allocation for `j`. */
void journal_(struct journal *const j) {
	if(!j) return;
	day_tree_(&j->days);
	text_(&j->backing);
}

/** @return A completed journal out of `dir_journal`. Any reading errors and
 `errno` will be set, it will be idle. */
struct journal journal(const char *const dir_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;
	struct day_tree_iterator it;
	union { const char **text; uintptr_t *offset; } v;
	char cwd[256];
	int is_dir_journal = 0;

	/* Get the years list as directories matching a year. */
	if(!getcwd(cwd, sizeof cwd) || chdir(dir_journal) == -1) goto catch;
	is_dir_journal = 1;
	if(!(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. */
	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)); <- Too much spam. */

			for(d = days.data, d_end = d + days.size; d < d_end; d++) {
				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 catch;
				switch(day_tree_bulk_assign(&j.days, d32, &v.text)) {
				case TREE_PRESENT: intent = "not unique", errno = EDOM; /*sic*/
				case TREE_ERROR: goto catch;
				case TREE_ABSENT: break; /* Expected. */
				}
				/* Because it's in a flat array, the pointers are not stable
				 while we are loading it, and we need to store the offsets. */
				*v.offset = (uintptr_t)(contents - j.backing.data);
			}
			d = 0, int_array_clear(&days);
			if(chdir("..") == -1) goto catch;
		}
		m = 0, int_array_clear(&months);
		if(chdir("..") == -1) goto catch;
	}
	if(chdir("../..") == -1 || !day_tree_bulk_finish(&j.days)) goto catch;

	/* Structure is now stable because we aren't going to move it;
	 convert all of offsets back to pointers. */
	it = day_tree_iterator(&j.days);
	while(day_tree_next(&it))
		v.text = day_tree_value(&it), *v.text = j.backing.data + *v.offset;

	goto finally;
catch:
	fprintf(stderr, "On date: %s/%d-%.2d-%.2d.\n",
		dir_journal, y ? *y : 0, m ? *m : 0, d ? *d : 0);
	if(intent) fprintf(stderr, "(%s)\n", intent);
recatch:
	journal_(&j);
finally:
	if(dir) { if(closedir(dir)) { dir = 0; goto recatch; } dir = 0; }
	if(is_dir_journal) {
		if(chdir(cwd) == -1) { is_dir_journal = 0; goto recatch; }
		is_dir_journal = 0;
	}
	int_array_(&years), int_array_(&months), int_array_(&days); /* Temporary. */
	return j;
}

/** @return `j` read in some data? */
int journal_is_empty(const struct journal *const j) {
	return !j || !j->days.root.node || !j->backing.data;
}

/** @return `j` as a string. */
const char *journal_to_string(const struct journal *const j)
	{ return day_tree_to_string(&j->days); }

struct journal_iterator journal_iterator(struct journal *const j) {
	struct journal_iterator it;
	it._ = day_tree_iterator(&j->days);
	return it;
}

int journal_next(struct journal_iterator *const it,
	union date32 *const k, const char **v) {
	assert(it && k && v);
	if(!day_tree_next(&it->_)) return 0;
	*k = day_tree_key(&it->_);
	*v = *day_tree_value(&it->_);
	return 1;
}