Home | History | Annotate | Line # | Download | only in cgram
cgram.c revision 1.23.2.1 
      1 /* $NetBSD: cgram.c,v 1.23.2.1 2021/05/31 22:15:06 cjep Exp $ */
      2 
      3 /*-
      4  * Copyright (c) 2013, 2021 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Roland Illig.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 #include <sys/cdefs.h>
     33 #if defined(__RCSID) && !defined(lint)
     34 __RCSID("$NetBSD: cgram.c,v 1.23.2.1 2021/05/31 22:15:06 cjep Exp $");
     35 #endif
     36 
     37 #include <assert.h>
     38 #include <ctype.h>
     39 #include <curses.h>
     40 #include <err.h>
     41 #include <stdbool.h>
     42 #include <stdio.h>
     43 #include <stdlib.h>
     44 #include <string.h>
     45 #include <time.h>
     46 
     47 #include "pathnames.h"
     48 
     49 
     50 static bool
     51 ch_isspace(char ch)
     52 {
     53 	return isspace((unsigned char)ch) != 0;
     54 }
     55 
     56 static bool
     57 ch_islower(char ch)
     58 {
     59 	return ch >= 'a' && ch <= 'z';
     60 }
     61 
     62 static bool
     63 ch_isupper(char ch)
     64 {
     65 	return ch >= 'A' && ch <= 'Z';
     66 }
     67 
     68 static bool
     69 ch_isalpha(char ch)
     70 {
     71 	return ch_islower(ch) || ch_isupper(ch);
     72 }
     73 
     74 static char
     75 ch_toupper(char ch)
     76 {
     77 	return ch_islower(ch) ? (char)(ch - 'a' + 'A') : ch;
     78 }
     79 
     80 static char
     81 ch_tolower(char ch)
     82 {
     83 	return ch_isupper(ch) ? (char)(ch - 'A' + 'a') : ch;
     84 }
     85 
     86 static int
     87 imax(int a, int b)
     88 {
     89 	return a > b ? a : b;
     90 }
     91 
     92 static int
     93 imin(int a, int b)
     94 {
     95 	return a < b ? a : b;
     96 }
     97 
     98 ////////////////////////////////////////////////////////////
     99 
    100 struct string {
    101 	char *s;
    102 	size_t len;
    103 	size_t cap;
    104 };
    105 
    106 struct stringarray {
    107 	struct string *v;
    108 	size_t num;
    109 };
    110 
    111 static void
    112 string_init(struct string *s)
    113 {
    114 	s->s = NULL;
    115 	s->len = 0;
    116 	s->cap = 0;
    117 }
    118 
    119 static void
    120 string_add(struct string *s, char ch)
    121 {
    122 	if (s->len >= s->cap) {
    123 		s->cap = 2 * s->cap + 16;
    124 		s->s = realloc(s->s, s->cap);
    125 		if (s->s == NULL)
    126 			errx(1, "Out of memory");
    127 	}
    128 	s->s[s->len++] = ch;
    129 }
    130 
    131 static void
    132 string_finish(struct string *s)
    133 {
    134 	string_add(s, '\0');
    135 	s->len--;
    136 }
    137 
    138 static void
    139 stringarray_init(struct stringarray *a)
    140 {
    141 	a->v = NULL;
    142 	a->num = 0;
    143 }
    144 
    145 static void
    146 stringarray_done(struct stringarray *a)
    147 {
    148 	for (size_t i = 0; i < a->num; i++)
    149 		free(a->v[i].s);
    150 	free(a->v);
    151 }
    152 
    153 static void
    154 stringarray_add(struct stringarray *a, struct string *s)
    155 {
    156 	size_t num = a->num++;
    157 	a->v = realloc(a->v, a->num * sizeof a->v[0]);
    158 	if (a->v == NULL)
    159 		errx(1, "Out of memory");
    160 	a->v[num] = *s;
    161 }
    162 
    163 static void
    164 stringarray_dup(struct stringarray *dst, const struct stringarray *src)
    165 {
    166 	assert(dst->num == 0);
    167 	for (size_t i = 0; i < src->num; i++) {
    168 		struct string str;
    169 		string_init(&str);
    170 		for (const char *p = src->v[i].s; *p != '\0'; p++)
    171 			string_add(&str, *p);
    172 		string_finish(&str);
    173 		stringarray_add(dst, &str);
    174 	}
    175 }
    176 
    177 ////////////////////////////////////////////////////////////
    178 
    179 static struct stringarray lines;
    180 static struct stringarray sollines;
    181 static bool hinting;
    182 static int extent_x;
    183 static int extent_y;
    184 static int offset_x;
    185 static int offset_y;
    186 static int cursor_x;
    187 static int cursor_y;
    188 
    189 static int
    190 cur_max_x(void)
    191 {
    192 	return (int)lines.v[cursor_y].len;
    193 }
    194 
    195 static int
    196 cur_max_y(void)
    197 {
    198 	return extent_y - 1;
    199 }
    200 
    201 static char
    202 char_left_of_cursor(void)
    203 {
    204 	if (cursor_x > 0)
    205 		return lines.v[cursor_y].s[cursor_x - 1];
    206 	assert(cursor_y > 0);
    207 	return '\n'; /* eol of previous line */
    208 }
    209 
    210 static char
    211 char_at_cursor(void)
    212 {
    213 	if (cursor_x == cur_max_x())
    214 		return '\n';
    215 	return lines.v[cursor_y].s[cursor_x];
    216 }
    217 
    218 static void
    219 getquote(FILE *f)
    220 {
    221 	struct string line;
    222 	string_init(&line);
    223 
    224 	int ch;
    225 	while ((ch = fgetc(f)) != EOF) {
    226 		if (ch == '\n') {
    227 			string_finish(&line);
    228 			stringarray_add(&lines, &line);
    229 			string_init(&line);
    230 		} else if (ch == '\t') {
    231 			string_add(&line, ' ');
    232 			while (line.len % 8 != 0)
    233 				string_add(&line, ' ');
    234 		} else if (ch == '\b') {
    235 			if (line.len > 0)
    236 				line.len--;
    237 		} else {
    238 			string_add(&line, (char)ch);
    239 		}
    240 	}
    241 
    242 	stringarray_dup(&sollines, &lines);
    243 
    244 	extent_y = (int)lines.num;
    245 	for (int i = 0; i < extent_y; i++)
    246 		extent_x = imax(extent_x, (int)lines.v[i].len);
    247 }
    248 
    249 static void
    250 readfile(const char *name)
    251 {
    252 	FILE *f = fopen(name, "r");
    253 	if (f == NULL)
    254 		err(1, "%s", name);
    255 
    256 	getquote(f);
    257 
    258 	if (fclose(f) != 0)
    259 		err(1, "%s", name);
    260 }
    261 
    262 
    263 static void
    264 readquote(void)
    265 {
    266 	FILE *f = popen(_PATH_FORTUNE, "r");
    267 	if (f == NULL)
    268 		err(1, "%s", _PATH_FORTUNE);
    269 
    270 	getquote(f);
    271 
    272 	if (pclose(f) != 0)
    273 		exit(1); /* error message must come from child process */
    274 }
    275 
    276 static void
    277 encode(void)
    278 {
    279 	int key[26];
    280 
    281 	for (int i = 0; i < 26; i++)
    282 		key[i] = i;
    283 
    284 	for (int i = 26; i > 1; i--) {
    285 		int c = (int)(random() % i);
    286 		int t = key[i - 1];
    287 		key[i - 1] = key[c];
    288 		key[c] = t;
    289 	}
    290 
    291 	for (int y = 0; y < extent_y; y++) {
    292 		for (char *p = lines.v[y].s; *p != '\0'; p++) {
    293 			if (ch_islower(*p))
    294 				*p = (char)('a' + key[*p - 'a']);
    295 			if (ch_isupper(*p))
    296 				*p = (char)('A' + key[*p - 'A']);
    297 		}
    298 	}
    299 }
    300 
    301 static void
    302 substitute(char a, char b)
    303 {
    304 	char la = ch_tolower(a);
    305 	char ua = ch_toupper(a);
    306 	char lb = ch_tolower(b);
    307 	char ub = ch_toupper(b);
    308 
    309 	for (int y = 0; y < (int)lines.num; y++) {
    310 		for (char *p = lines.v[y].s; *p != '\0'; p++) {
    311 			if (*p == la)
    312 				*p = lb;
    313 			else if (*p == ua)
    314 				*p = ub;
    315 			else if (*p == lb)
    316 				*p = la;
    317 			else if (*p == ub)
    318 				*p = ua;
    319 		}
    320 	}
    321 }
    322 
    323 static bool
    324 is_solved(void)
    325 {
    326 	for (size_t i = 0; i < lines.num; i++)
    327 		if (strcmp(lines.v[i].s, sollines.v[i].s) != 0)
    328 			return false;
    329 	return true;
    330 }
    331 
    332 ////////////////////////////////////////////////////////////
    333 
    334 static void
    335 redraw(void)
    336 {
    337 	erase();
    338 
    339 	int max_y = imin(LINES - 1, extent_y - offset_y);
    340 	for (int y = 0; y < max_y; y++) {
    341 		move(y, 0);
    342 
    343 		int len = (int)lines.v[offset_y + y].len;
    344 		int max_x = imin(COLS - 1, len - offset_x);
    345 		const char *line = lines.v[offset_y + y].s;
    346 		const char *solline = sollines.v[offset_y + y].s;
    347 
    348 		for (int x = 0; x < max_x; x++) {
    349 			char ch = line[offset_x + x];
    350 			bool bold = hinting &&
    351 			    (ch == solline[offset_x + x] || !ch_isalpha(ch));
    352 
    353 			if (bold)
    354 				attron(A_BOLD);
    355 			addch(ch);
    356 			if (bold)
    357 				attroff(A_BOLD);
    358 		}
    359 		clrtoeol();
    360 	}
    361 
    362 	move(LINES - 1, 0);
    363 	addstr("~ to quit, * to cheat, ^pnfb to move");
    364 
    365 	if (is_solved()) {
    366 		if (extent_y + 1 - offset_y < LINES - 2)
    367 			move(extent_y + 1 - offset_y, 0);
    368 		else
    369 			addch(' ');
    370 		attron(A_BOLD | A_STANDOUT);
    371 		addstr("*solved*");
    372 		attroff(A_BOLD | A_STANDOUT);
    373 	}
    374 
    375 	move(cursor_y - offset_y, cursor_x - offset_x);
    376 
    377 	refresh();
    378 }
    379 
    380 ////////////////////////////////////////////////////////////
    381 
    382 static void
    383 saturate_cursor(void)
    384 {
    385 	cursor_y = imax(cursor_y, 0);
    386 	cursor_y = imin(cursor_y, cur_max_y());
    387 
    388 	assert(cursor_x >= 0);
    389 	cursor_x = imin(cursor_x, cur_max_x());
    390 }
    391 
    392 static void
    393 scroll_into_view(void)
    394 {
    395 	if (cursor_x < offset_x)
    396 		offset_x = cursor_x;
    397 	if (cursor_x > offset_x + COLS - 1)
    398 		offset_x = cursor_x - (COLS - 1);
    399 
    400 	if (cursor_y < offset_y)
    401 		offset_y = cursor_y;
    402 	if (cursor_y > offset_y + LINES - 2)
    403 		offset_y = cursor_y - (LINES - 2);
    404 }
    405 
    406 static bool
    407 can_go_left(void)
    408 {
    409 	return cursor_y > 0 ||
    410 	    (cursor_y == 0 && cursor_x > 0);
    411 }
    412 
    413 static bool
    414 can_go_right(void)
    415 {
    416 	return cursor_y < cur_max_y() ||
    417 	    (cursor_y == cur_max_y() && cursor_x < cur_max_x());
    418 }
    419 
    420 static void
    421 go_to_prev_line(void)
    422 {
    423 	cursor_y--;
    424 	cursor_x = cur_max_x();
    425 }
    426 
    427 static void
    428 go_to_next_line(void)
    429 {
    430 	cursor_x = 0;
    431 	cursor_y++;
    432 }
    433 
    434 static void
    435 go_left(void)
    436 {
    437 	if (cursor_x > 0)
    438 		cursor_x--;
    439 	else if (cursor_y > 0)
    440 		go_to_prev_line();
    441 }
    442 
    443 static void
    444 go_right(void)
    445 {
    446 	if (cursor_x < cur_max_x())
    447 		cursor_x++;
    448 	else if (cursor_y < cur_max_y())
    449 		go_to_next_line();
    450 }
    451 
    452 static void
    453 go_to_prev_word(void)
    454 {
    455 	while (can_go_left() && ch_isspace(char_left_of_cursor()))
    456 		go_left();
    457 
    458 	while (can_go_left() && !ch_isspace(char_left_of_cursor()))
    459 		go_left();
    460 }
    461 
    462 static void
    463 go_to_next_word(void)
    464 {
    465 	while (can_go_right() && !ch_isspace(char_at_cursor()))
    466 		go_right();
    467 
    468 	while (can_go_right() && ch_isspace(char_at_cursor()))
    469 		go_right();
    470 }
    471 
    472 static bool
    473 can_substitute_here(int ch)
    474 {
    475 	return isascii(ch) &&
    476 	    ch_isalpha((char)ch) &&
    477 	    cursor_x < cur_max_x() &&
    478 	    ch_isalpha(char_at_cursor());
    479 }
    480 
    481 static void
    482 handle_char_input(int ch)
    483 {
    484 	if (ch == char_at_cursor())
    485 		go_right();
    486 	else if (can_substitute_here(ch)) {
    487 		substitute(char_at_cursor(), (char)ch);
    488 		go_right();
    489 	} else
    490 		beep();
    491 }
    492 
    493 static bool
    494 handle_key(void)
    495 {
    496 	int ch = getch();
    497 
    498 	switch (ch) {
    499 	case 1:			/* ^A */
    500 	case KEY_HOME:
    501 		cursor_x = 0;
    502 		break;
    503 	case 2:			/* ^B */
    504 	case KEY_LEFT:
    505 		go_left();
    506 		break;
    507 	case 5:			/* ^E */
    508 	case KEY_END:
    509 		cursor_x = cur_max_x();
    510 		break;
    511 	case 6:			/* ^F */
    512 	case KEY_RIGHT:
    513 		go_right();
    514 		break;
    515 	case '\t':
    516 		go_to_next_word();
    517 		break;
    518 	case KEY_BTAB:
    519 		go_to_prev_word();
    520 		break;
    521 	case '\n':
    522 		go_to_next_line();
    523 		break;
    524 	case 12:		/* ^L */
    525 		clear();
    526 		break;
    527 	case 14:		/* ^N */
    528 	case KEY_DOWN:
    529 		cursor_y++;
    530 		break;
    531 	case 16:		/* ^P */
    532 	case KEY_UP:
    533 		cursor_y--;
    534 		break;
    535 	case KEY_PPAGE:
    536 		cursor_y -= LINES - 2;
    537 		break;
    538 	case KEY_NPAGE:
    539 		cursor_y += LINES - 2;
    540 		break;
    541 	case '*':
    542 		hinting = !hinting;
    543 		break;
    544 	case '~':
    545 		return false;
    546 	case KEY_RESIZE:
    547 		break;
    548 	default:
    549 		handle_char_input(ch);
    550 		break;
    551 	}
    552 	return true;
    553 }
    554 
    555 static void
    556 init(const char *filename)
    557 {
    558 	stringarray_init(&lines);
    559 	stringarray_init(&sollines);
    560 	srandom((unsigned int)time(NULL));
    561 	if (filename != NULL) {
    562 	    readfile(filename);
    563 	} else {
    564 	    readquote();
    565 	}
    566 	encode();
    567 
    568 	initscr();
    569 	cbreak();
    570 	noecho();
    571 	keypad(stdscr, true);
    572 }
    573 
    574 static void
    575 loop(void)
    576 {
    577 	for (;;) {
    578 		redraw();
    579 		if (!handle_key())
    580 			break;
    581 		saturate_cursor();
    582 		scroll_into_view();
    583 	}
    584 }
    585 
    586 static void
    587 done(void)
    588 {
    589 	endwin();
    590 
    591 	stringarray_done(&sollines);
    592 	stringarray_done(&lines);
    593 }
    594 
    595 
    596 static void __dead
    597 usage(void)
    598 {
    599 
    600 	fprintf(stderr, "usage: %s [file]\n", getprogname());
    601 	exit(1);
    602 }
    603 
    604 int
    605 main(int argc, char *argv[])
    606 {
    607 
    608 	setprogname(argv[0]);
    609 	if (argc != 1 && argc != 2)
    610 		usage();
    611 
    612 	init(argc > 1 ? argv[1] : NULL);
    613 	loop();
    614 	done();
    615 	return 0;
    616 }
    617