pietr

pietr.c (7062B)

#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <stdarg.h>
#include <err.h>

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h"

#define ARRLEN(x) (sizeof(x)/sizeof((x)[0]))
#define ABS(x) ((x) >= 0 ? (x) : -(x))

#define ASSERT(x) do { \
	if (!(x)) errx(1, "Assertion failed: '%s'", #x); } while (0)
#define ASSERTI(i, x) do { \
	if (!(x)) errx(1, "Assertion failed: '%s' in %s", #x, #i); } while (0)

#define BLACK 18
#define WHITE 19

enum {
	PUSH,
	POP,
	ADD,
	SUB,
	MUL,
	DIV,
	MOD,
	NOT,
	GTR,
	DPI,
	CCI,
	DUP,
	ROLL,
	INN,
	INC,
	OUTN,
	OUTC,
	NONE
};

static const char *inst_names[] = {
	"PUSH",
	"POP",
	"ADD",
	"SUB",
	"MUL",
	"DIV",
	"MOD",
	"NOT",
	"GTR",
	"DPI",
	"CCI",
	"DUP",
	"ROLL",
	"INN",
	"INC",
	"OUTN",
	"OUTC",
	""
};

static const int inst_lut[18] = {
	[0 * 3 + 0] = NONE,
	[0 * 3 + 1] = PUSH,
	[0 * 3 + 2] = POP,
	[1 * 3 + 0] = ADD,
	[1 * 3 + 1] = SUB,
	[1 * 3 + 2] = MUL,
	[2 * 3 + 0] = DIV,
	[2 * 3 + 1] = MOD,
	[2 * 3 + 2] = NOT,
	[3 * 3 + 0] = GTR,
	[3 * 3 + 1] = DPI,
	[3 * 3 + 2] = CCI,
	[4 * 3 + 0] = DUP,
	[4 * 3 + 1] = ROLL,
	[4 * 3 + 2] = INN,
	[5 * 3 + 0] = INC,
	[5 * 3 + 1] = OUTN,
	[5 * 3 + 2] = OUTC,
};

static const uint32_t colors[20] = {
	0xffc0c0, 0xffffc0, 0xc0ffc0, 0xc0ffff, 0xc0c0ff, 0xffc0ff,
	0xff0000, 0xffff00, 0x00ff00, 0x00ffff, 0x0000ff, 0xff00ff,
	0xc00000, 0xc0c000, 0x00c000, 0x00c0c0, 0x0000c0, 0xc000c0,
	0x000000, 0xffffff,
};

static const size_t stacksize = 2048;
static int debug = 0;

int
getcolor(uint8_t *pix, int stride, int x, int y)
{
	uint32_t rgb;
	int i;

	rgb = pix[y * stride + x * 3 + 0] << 16
		| pix[y * stride + x * 3 + 1] << 8
		| pix[y * stride + x * 3 + 2] << 0;
	for (i = 0; i < ARRLEN(colors); i++)
		if (colors[i] == rgb)
			return i;

	errx(1, "Encountered invalid color: #%06X", rgb);
	return -1;
}

int
getinst(int prev, int next)
{
	int dx, dy;

	if (prev == WHITE || next == WHITE)
		return NONE;
	dx = ((next % 6) - (prev % 6) + 6) % 6;
	dy = ((next / 6) - (prev / 6) + 3) % 3;
	return inst_lut[dx * 3 + dy];
}

const char *
dirstr(int dx, int dy)
{
	if (dx > 0)
		return "+X";
	else if (dx < 0)
		return "-X";
	else if (dy > 0)
		return "+Y";
	else if (dy < 0)
		return "-Y";
	else
		return "O";
}

void
rotate(int *dx, int *dy)
{
	if (debug) printf("ROTATE %s ->", dirstr(*dx, *dy));
	if (*dx != 0) {
		*dy = *dx;
		*dx = 0;
	} else {
		*dx = -*dy;
		*dy = 0;
	}
	if (debug) printf(" %s\n", dirstr(*dx, *dy));
}

void
roll(int *top, int depth)
{
	int tmp, i;

	tmp = top[-1];
	for (i = -1; i > -depth; i++)
		top[i] = top[i-1];
	top[-depth] = tmp;
}

void
unroll(int *top, int depth)
{
	int tmp, i;

	tmp = top[-depth];
	for (i = -depth; i < -1; i++)
		top[i] = top[i+1];
	top[-1] = tmp;
}

void
debuginst(int *stack, int stacktop, int prevc, int nextc,
	int x, int y, const char *name)
{
	int i;

	printf("[%3i,%3i]: %06X -> %06X | %4s | ", x, y,
		colors[prevc], colors[nextc], name);
	for (i = 0; i < stacktop; i++)
		printf("%i ", stack[i]);
	printf("\n");
}

int
main(int argc, const char **argv)
{
	uint8_t *pix, *vismap;
	const char *inpath;
	int *stack;
	int width, height;
	int inst, x, y;
	int dx, dy;
	int prevc, nextc;
	int rotcount;
	int stacktop;
	int edgedir;
	int i, tmp;

	inpath = NULL;
	for (i = 1; i < argc; i++) {
		if (!strcmp(argv[i], "-d"))
			debug = 1;
		else if (!strcmp(argv[i], "-h"))
			errx(0, "pietr [-h] [-d] IMAGE");
		else if (inpath)
			errx(1, "Multiple image specified");
		else
			inpath = argv[i];
	}
	if (!inpath)
		errx(1, "No image specified");

	pix = stbi_load(inpath, &width, &height, NULL, STBI_rgb);
	if (!pix) errx(1, "Image load failed");

	stack = calloc(stacksize, sizeof(int));
	if (!stack) err(1, "calloc");
	stacktop = 0;

	vismap = calloc(width * height, 1);
	if (!vismap) err(1, "calloc");

	dx = 1;
	dy = 0;

	x = y = 0;
	while (1) {
		prevc = getcolor(pix, width * 3, x, y);

		/* rotate until free */
		rotcount = 0;
		while (x + dx < 0 || x + dx >= width
			|| y + dy < 0 || y + dy >= height
			|| getcolor(pix, width * 3, x + dx, y + dy) == BLACK)
		{
			rotate(&dx, &dy);
			rotcount += 1;
			ASSERT(rotcount < 4);
		}

		x += dx;
		y += dy;

		if (vismap[y * width + x] == (dy + 1) * 2 + (dx + 1)) {
			if (debug) printf("Loop detected. Stopping..\n");
			break;
		}
		vismap[y * width + x] = (dy + 1) * 2 + (dx + 1);

		nextc = getcolor(pix, width * 3, x, y);
		ASSERT(nextc != BLACK);

		inst = getinst(prevc, nextc);

		if (debug) {
			printf("[%3i,%3i]: %06X -> %06X  | %4s | ", x, y,
				colors[prevc], colors[nextc], inst_names[inst]);
			for (i = 0; i < stacktop; i++)
				printf("%i ", stack[i]);
			printf("\n");
		}

		switch (inst) {
		case PUSH:
			ASSERTI(PUSH, stacktop != stacksize);
			stack[stacktop++] = 1;
			break;
		case POP:
			ASSERTI(POP, stacktop >= 1);
			stacktop--;
			break;
		case ADD:
			ASSERTI(ADD, stacktop >= 2);
			stack[stacktop-2] += stack[stacktop-1];
			stacktop--;
			break;
		case SUB:
			ASSERTI(SUB, stacktop >= 2);
			stack[stacktop-2] -= stack[stacktop-1];
			stacktop--;
			break;
		case MUL:
			ASSERTI(DIV, stacktop >= 2);
			stack[stacktop-2] *= stack[stacktop-1];
			stacktop--;
			break;
		case DIV:
			ASSERTI(DIV, stacktop >= 2);
			stack[stacktop-2] /= stack[stacktop-1];
			stacktop--;
			break;
		case MOD:
			ASSERTI(MOD, stacktop >= 2);
			stack[stacktop-2] %= stack[stacktop-1];
			stacktop--;
			break;
		case NOT:
			ASSERTI(NOT, stacktop >= 1);
			stack[stacktop-1] = stack[stacktop-1] == 0;
			stacktop--;
			break;
		case GTR:
			ASSERTI(GTR, stacktop >= 2);
			stack[stacktop-2] = stack[stacktop-2] > stack[stacktop-1];
			stacktop--;
			break;
		case DPI:
			ASSERTI(DPI, stacktop >= 1);
			for (i = 0; i < stack[stacktop-1]; i++)
				rotate(&dx, &dy);
			stacktop--;
			break;
		case CCI:
			ASSERTI(CCI, stacktop >= 1);
			if (ABS(stack[stacktop-1]) % 2 == 1)
				edgedir ^= 1;
			stacktop--;
			break;
		case DUP:
			ASSERTI(DUP, stacktop >= 1);
			stack[stacktop] = stack[stacktop-1];
			stacktop++;
			break;
		case ROLL:
			ASSERTI(ROLL, stacktop >= 2);
			stacktop -= 2;
			ASSERTI(ROLL, stacktop >= stack[stacktop]);
			if (stack[stacktop+1] < 0) {
				for (i = 0; i < -stack[stacktop+1]; i++)
					unroll(stack, stack[stacktop]);
			} else {
				for (i = 0; i < stack[stacktop+1]; i++)
					roll(stack, stack[stacktop]);
			}
			break;
		case INN:
			ASSERTI(INN, stacktop < stacksize);
			ASSERTI(INN, scanf("%i", &tmp) == 1);
			stack[stacktop++] = tmp;
			break;
		case INC:
			ASSERTI(INC, stacktop < stacksize);
			stack[stacktop++] = getchar();
			break;
		case OUTN:
			ASSERTI(OUTN, stacktop >= 1);
			if (debug) {
				printf("OUTNUM %i\n", stack[stacktop-1]);
			} else {
				putchar(stack[stacktop-1]);
			}
			stacktop--;
			break;
		case OUTC:
			ASSERTI(OUTC, stacktop >= 1);
			if (debug) {
				printf("OUTCHAR %c\n", stack[stacktop-1]);
			} else {
				putchar(stack[stacktop-1]);
			}
			stacktop--;
			break;
		case NONE:
			break;
		default:
			errx(1, "Invalid instruction %i", inst);
		}
	}

	STBI_FREE(pix);
}