# SPDX-License-Identifier: AGPL-3.0-only
# SPDX-FileCopyrightText: Copyright (c) 2025 Runxi Yu <https://runxiyu.org>

.PHONY: clean version.go man source.tar.gz

CFLAGS = -Wall -Wextra -pedantic -std=c99 -D_GNU_SOURCE
MAN_PAGES = lindenii-forge.5 lindenii-forge-hookc.1 lindenii-forge.1 lindenii-forge-mail.5

forge: source.tar.gz version.go hookc/*.c hookc/hookc man # TODO
	go build .

man: $(MAN_PAGES:%=man/%.html) $(MAN_PAGES:%=man/%.txt)

man/%.html: man/%
	mandoc -Thtml -O style=./mandoc.css $< > $@

man/%.txt: man/% utils/colb
	mandoc $< | ./utils/colb > $@

utils/colb:

hookc/hookc:

git2d/git2d: git2d/main.o git2d/bare.o
	$(CC) $(CFLAGS) `pkg-config --cflags --libs libgit2` -lpthread -o git2d/git2d $<

git2d/git2d: git2d/main.o git2d/bare.o git2d/utf8.c
	$(CC) $(CFLAGS) `pkg-config --cflags --libs libgit2` -lpthread -o git2d/git2d $^

version.go:
	printf 'package main\n\nconst VERSION = "%s"\n' `git describe --tags --always --dirty` > $@

clean:
	$(RM) forge version.go vendor

source.tar.gz:
	rm -f source.tar.gz
	go mod vendor
	git ls-files -z | xargs -0 tar -czf source.tar.gz vendor

#include "utf8.h"

extern inline void *utf8_decode(void *buf, uint32_t *c, int *e);

/*-
 * SPDX-License-Identifier: Unlicense
 * SPDX-FileContributor: Chris Wellons <wellons@nullprogram.com>
 *
 * From: https://nullprogram.com/blog/2017/10/06/
 */

#ifndef UTF8_H
#define UTF8_H

#include <stdint.h>

/*
 * Decode the next character, C, from BUF, reporting errors in E.
 *
 * Since this is a branchless decoder, four bytes will be read from the
 * buffer regardless of the actual length of the next character. This
 * means the buffer _must_ have at least three bytes of zero padding
 * following the end of the data stream.
 *
 * Errors are reported in E, which will be non-zero if the parsed
 * character was somehow invalid: invalid byte sequence, non-canonical
 * encoding, or a surrogate half.
 *
 * The function returns a pointer to the next character. When an error
 * occurs, this pointer will be a guess that depends on the particular
 * error, but it will always advance at least one byte.
 */

static void *

inline void *

utf8_decode(void *buf, uint32_t *c, int *e)
{
	static const char lengths[] = {
		1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 3, 3, 4, 0
	};
	static const int masks[]  = {0x00, 0x7f, 0x1f, 0x0f, 0x07};
	static const uint32_t mins[] = {4194304, 0, 128, 2048, 65536};
	static const int shiftc[] = {0, 18, 12, 6, 0};
	static const int shifte[] = {0, 6, 4, 2, 0};

	uint8_t *s = buf;
	int len = lengths[s[0] >> 3];

	/*
	 * Compute the pointer to the next character early so that the next
	 * iteration can start working on the next character. Neither Clang
	 * nor GCC figure out this reordering on their own.
	 */
	uint8_t *next = s + len + !len;

	/*
	 * Assume a four-byte character and load four bytes. Unused bits are
	 * shifted out.
	 */
	*c  = (uint32_t)(s[0] & masks[len]) << 18;
	*c |= (uint32_t)(s[1] & 0x3f) << 12;
	*c |= (uint32_t)(s[2] & 0x3f) <<  6;
	*c |= (uint32_t)(s[3] & 0x3f) <<  0;
	*c >>= shiftc[len];

	/* Accumulate the various error conditions. */
	*e  = (*c < mins[len]) << 6; /* non-canonical encoding */
	*e |= ((*c >> 11) == 0x1b) << 7; /* surrogate half? */
	*e |= (*c > 0x10FFFF) << 8; /* out of range? */
	*e |= (s[1] & 0xc0) >> 2;
	*e |= (s[2] & 0xc0) >> 4;
	*e |= (s[3]	   ) >> 6;
	*e ^= 0x2a; /* top two bits of each tail byte correct? */
	*e >>= shifte[len];

	return next;
}

#endif