cgram/cgram.c

   1 /* $NetBSD: cgram.c,v 1.11 2021/02/21 22:21:56 rillig 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 David A. Holland and 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.11 2021/02/21 22:21:56 rillig 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
  51 static char
  52 ch_toupper(char ch)
  53 {
  54         return (char)toupper((unsigned char)ch);
  55 }
  56
  57 static char
  58 ch_tolower(char ch)
  59 {
  60         return (char)tolower((unsigned char)ch);
  61 }
  62
  63 static bool
  64 ch_isalpha(char ch)
  65 {
  66         return isalpha((unsigned char)ch) != 0;
  67 }
  68
  69 static bool
  70 ch_islower(char ch)
  71 {
  72         return islower((unsigned char)ch) != 0;
  73 }
  74
  75 static bool
  76 ch_isupper(char ch)
  77 {
  78         return isupper((unsigned char)ch) != 0;
  79 }
  80
  81 static int
  82 imax(int a, int b)
  83 {
  84         return a > b ? a : b;
  85 }
  86
  87 static int
  88 imin(int a, int b)
  89 {
  90         return a < b ? a : b;
  91 }
  92
  93 ////////////////////////////////////////////////////////////
  94
  95 struct string {
  96         char *s;
  97         size_t len;
  98         size_t cap;
  99 };
 100
 101 struct stringarray {
 102         struct string *v;
 103         size_t num;
 104 };
 105
 106 static void
 107 string_init(struct string *s)
 108 {
 109         s->s = NULL;
 110         s->len = 0;
 111         s->cap = 0;
 112 }
 113
 114 static void
 115 string_add(struct string *s, char ch)
 116 {
 117         if (s->len >= s->cap) {
 118                 s->cap = 2 * s->cap + 16;
 119                 s->s = realloc(s->s, s->cap);
 120                 if (s->s == NULL)
 121                         errx(1, "Out of memory");
 122         }
 123         s->s[s->len++] = ch;
 124 }
 125
 126 static void
 127 string_finish(struct string *s)
 128 {
 129         string_add(s, '\0');
 130         s->len--;
 131 }
 132
 133 static void
 134 stringarray_init(struct stringarray *a)
 135 {
 136         a->v = NULL;
 137         a->num = 0;
 138 }
 139
 140 static void
 141 stringarray_cleanup(struct stringarray *a)
 142 {
 143         for (size_t i = 0; i < a->num; i++)
 144                 free(a->v[i].s);
 145         free(a->v);
 146 }
 147
 148 static void
 149 stringarray_add(struct stringarray *a, struct string *s)
 150 {
 151         size_t num = a->num++;
 152         a->v = realloc(a->v, a->num * sizeof a->v[0]);
 153         if (a->v == NULL)
 154                 errx(1, "Out of memory");
 155         a->v[num] = *s;
 156 }
 157
 158 static void
 159 stringarray_dup(struct stringarray *dst, const struct stringarray *src)
 160 {
 161         assert(dst->num == 0);
 162         for (size_t i = 0; i < src->num; i++) {
 163                 struct string str;
 164                 string_init(&str);
 165                 for (const char *p = src->v[i].s; *p != '\0'; p++)
 166                         string_add(&str, *p);
 167                 string_finish(&str);
 168                 stringarray_add(dst, &str);
 169         }
 170 }
 171
 172 ////////////////////////////////////////////////////////////
 173
 174 static struct stringarray lines;
 175 static struct stringarray sollines;
 176 static bool hinting;
 177 static int extent_x;
 178 static int extent_y;
 179 static int offset_x;
 180 static int offset_y;
 181 static int cursor_x;
 182 static int cursor_y;
 183
 184 static int
 185 cur_max_x(void)
 186 {
 187         return (int)lines.v[cursor_y].len;
 188 }
 189
 190 static int
 191 cur_max_y(void)
 192 {
 193         return extent_y - 1;
 194 }
 195
 196 static void
 197 readquote(void)
 198 {
 199         FILE *f = popen(_PATH_FORTUNE, "r");
 200         if (f == NULL)
 201                 err(1, "%s", _PATH_FORTUNE);
 202
 203         struct string line;
 204         string_init(&line);
 205
 206         int ch;
 207         while ((ch = fgetc(f)) != EOF) {
 208                 if (ch == '\n') {
 209                         string_finish(&line);
 210                         stringarray_add(&lines, &line);
 211                         string_init(&line);
 212                 } else if (ch == '\t') {
 213                         string_add(&line, ' ');
 214                         while (line.len % 8 != 0)
 215                                 string_add(&line, ' ');
 216                 } else if (ch == '\b') {
 217                         if (line.len > 0)
 218                                 line.len--;
 219                 } else {
 220                         string_add(&line, (char)ch);
 221                 }
 222         }
 223
 224         stringarray_dup(&sollines, &lines);
 225
 226         extent_y = (int)lines.num;
 227         for (int i = 0; i < extent_y; i++)
 228                 extent_x = imax(extent_x, (int)lines.v[i].len);
 229
 230         pclose(f);
 231 }
 232
 233 static void
 234 encode(void)
 235 {
 236         int key[26];
 237
 238         for (int i = 0; i < 26; i++)
 239                 key[i] = i;
 240
 241         for (int i = 26; i > 1; i--) {
 242                 int c = (int)(random() % i);
 243                 int t = key[i - 1];
 244                 key[i - 1] = key[c];
 245                 key[c] = t;
 246         }
 247
 248         for (int y = 0; y < extent_y; y++) {
 249                 for (char *p = lines.v[y].s; *p != '\0'; p++) {
 250                         if (ch_islower(*p))
 251                                 *p = (char)('a' + key[*p - 'a']);
 252                         if (ch_isupper(*p))
 253                                 *p = (char)('A' + key[*p - 'A']);
 254                 }
 255         }
 256 }
 257
 258 static bool
 259 substitute(char ch)
 260 {
 261         assert(cursor_x >= 0 && cursor_x < extent_x);
 262         assert(cursor_y >= 0 && cursor_y < extent_y);
 263         if (cursor_x >= cur_max_x()) {
 264                 beep();
 265                 return false;
 266         }
 267
 268         char och = lines.v[cursor_y].s[cursor_x];
 269         if (!ch_isalpha(och)) {
 270                 beep();
 271                 return false;
 272         }
 273
 274         char loch = ch_tolower(och);
 275         char uoch = ch_toupper(och);
 276         char lch = ch_tolower(ch);
 277         char uch = ch_toupper(ch);
 278
 279         for (int y = 0; y < (int)lines.num; y++) {
 280                 for (char *p = lines.v[y].s; *p != '\0'; p++) {
 281                         if (*p == loch)
 282                                 *p = lch;
 283                         else if (*p == uoch)
 284                                 *p = uch;
 285                         else if (*p == lch)
 286                                 *p = loch;
 287                         else if (*p == uch)
 288                                 *p = uoch;
 289                 }
 290         }
 291         return true;
 292 }
 293
 294 ////////////////////////////////////////////////////////////
 295
 296 static bool
 297 is_solved(void)
 298 {
 299         for (size_t i = 0; i < lines.num; i++)
 300                 if (strcmp(lines.v[i].s, sollines.v[i].s) != 0)
 301                         return false;
 302         return true;
 303 }
 304
 305 static void
 306 redraw(void)
 307 {
 308         erase();
 309
 310         int max_y = imin(LINES - 1, extent_y - offset_y);
 311         for (int y = 0; y < max_y; y++) {
 312                 move(y, 0);
 313
 314                 int len = (int)lines.v[offset_y + y].len;
 315                 int max_x = imin(COLS - 1, len - offset_x);
 316                 const char *line = lines.v[offset_y + y].s;
 317                 const char *solline = sollines.v[offset_y + y].s;
 318
 319                 for (int x = 0; x < max_x; x++) {
 320                         char ch = line[offset_x + x];
 321                         bool bold = hinting &&
 322                             ch == solline[offset_x + x] &&
 323                             ch_isalpha(ch);
 324
 325                         if (bold)
 326                                 attron(A_BOLD);
 327                         addch(ch);
 328                         if (bold)
 329                                 attroff(A_BOLD);
 330                 }
 331                 clrtoeol();
 332         }
 333
 334         move(LINES - 1, 0);
 335         if (is_solved())
 336                 addstr("*solved* ");
 337         addstr("~ to quit, * to cheat, ^pnfb to move");
 338
 339         move(cursor_y - offset_y, cursor_x - offset_x);
 340
 341         refresh();
 342 }
 343
 344 static void
 345 opencurses(void)
 346 {
 347         initscr();
 348         cbreak();
 349         noecho();
 350         keypad(stdscr, true);
 351 }
 352
 353 static void
 354 closecurses(void)
 355 {
 356         endwin();
 357 }
 358
 359 ////////////////////////////////////////////////////////////
 360
 361 static void
 362 saturate_cursor(void)
 363 {
 364         cursor_y = imax(cursor_y, 0);
 365         cursor_y = imin(cursor_y, cur_max_y());
 366
 367         assert(cursor_x >= 0);
 368         cursor_x = imin(cursor_x, cur_max_x());
 369 }
 370
 371 static void
 372 scroll_into_view(void)
 373 {
 374         if (cursor_x < offset_x)
 375                 offset_x = cursor_x;
 376         if (cursor_x > offset_x + COLS - 1)
 377                 offset_x = cursor_x - (COLS - 1);
 378
 379         if (cursor_y < offset_y)
 380                 offset_y = cursor_y;
 381         if (cursor_y > offset_y + LINES - 2)
 382                 offset_y = cursor_y - (LINES - 2);
 383 }
 384
 385 static void
 386 handle_char_input(int ch)
 387 {
 388         if (isascii(ch) && ch_isalpha((char)ch)) {
 389                 if (substitute((char)ch)) {
 390                         if (cursor_x < cur_max_x())
 391                                 cursor_x++;
 392                         if (cursor_x == cur_max_x() &&
 393                             cursor_y < cur_max_y()) {
 394                                 cursor_x = 0;
 395                                 cursor_y++;
 396                         }
 397                 }
 398         } else if (cursor_x < cur_max_x() &&
 399             ch == lines.v[cursor_y].s[cursor_x]) {
 400                 cursor_x++;
 401                 if (cursor_x == cur_max_x() &&
 402                     cursor_y < cur_max_y()) {
 403                         cursor_x = 0;
 404                         cursor_y++;
 405                 }
 406         } else {
 407                 beep();
 408         }
 409 }
 410
 411 static bool
 412 handle_key(void)
 413 {
 414         int ch = getch();
 415
 416         switch (ch) {
 417         case 1:                 /* ^A */
 418         case KEY_HOME:
 419                 cursor_x = 0;
 420                 break;
 421         case 2:                 /* ^B */
 422         case KEY_LEFT:
 423                 if (cursor_x > 0) {
 424                         cursor_x--;
 425                 } else if (cursor_y > 0) {
 426                         cursor_y--;
 427                         cursor_x = cur_max_x();
 428                 }
 429                 break;
 430         case 5:                 /* ^E */
 431         case KEY_END:
 432                 cursor_x = cur_max_x();
 433                 break;
 434         case 6:                 /* ^F */
 435         case KEY_RIGHT:
 436                 if (cursor_x < cur_max_x()) {
 437                         cursor_x++;
 438                 } else if (cursor_y < cur_max_y()) {
 439                         cursor_y++;
 440                         cursor_x = 0;
 441                 }
 442                 break;
 443         case 12:                /* ^L */
 444                 clear();
 445                 break;
 446         case 14:                /* ^N */
 447         case KEY_DOWN:
 448                 cursor_y++;
 449                 break;
 450         case 16:                /* ^P */
 451         case KEY_UP:
 452                 cursor_y--;
 453                 break;
 454         case KEY_PPAGE:
 455                 cursor_y -= LINES - 2;
 456                 break;
 457         case KEY_NPAGE:
 458                 cursor_y += LINES - 2;
 459                 break;
 460         case '*':
 461                 hinting = !hinting;
 462                 break;
 463         case '~':
 464                 return false;
 465         default:
 466                 handle_char_input(ch);
 467                 break;
 468         }
 469         return true;
 470 }
 471
 472 static void
 473 init(void)
 474 {
 475         stringarray_init(&lines);
 476         stringarray_init(&sollines);
 477         srandom((unsigned int)time(NULL));
 478         readquote();
 479         encode();
 480         opencurses();
 481 }
 482
 483 static void
 484 loop(void)
 485 {
 486         for (;;) {
 487                 redraw();
 488                 if (!handle_key())
 489                         break;
 490                 saturate_cursor();
 491                 scroll_into_view();
 492         }
 493 }
 494
 495 static void
 496 clean_up(void)
 497 {
 498         closecurses();
 499         stringarray_cleanup(&sollines);
 500         stringarray_cleanup(&lines);
 501 }
 502
 503 ////////////////////////////////////////////////////////////
 504
 505 int
 506 main(void)
 507 {
 508         init();
 509         loop();
 510         clean_up();
 511 }