Home | History | Annotate | Line # | Download | only in common_source
table.c revision 1.6
      1 /*	$NetBSD: table.c,v 1.6 1999/02/10 12:29:48 hubertf Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1980, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. All advertising materials mentioning features or use of this software
     16  *    must display the following acknowledgement:
     17  *	This product includes software developed by the University of
     18  *	California, Berkeley and its contributors.
     19  * 4. Neither the name of the University nor the names of its contributors
     20  *    may be used to endorse or promote products derived from this software
     21  *    without specific prior written permission.
     22  *
     23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     33  * SUCH DAMAGE.
     34  */
     35 
     36 #include <sys/cdefs.h>
     37 #ifndef lint
     38 #if 0
     39 static char sccsid[] = "@(#)table.c	8.1 (Berkeley) 5/31/93";
     40 #else
     41 __RCSID("$NetBSD: table.c,v 1.6 1999/02/10 12:29:48 hubertf Exp $");
     42 #endif
     43 #endif /* not lint */
     44 
     45 #include "back.h"
     46 
     47 const char   *const help2[] = {
     48 	"   Enter moves as <s>-<f> or <s>/<r> where <s> is the starting",
     49 	"position, <f> is the finishing position, and <r> is the roll.",
     50 	"Remember, each die roll must be moved separately.",
     51 	0
     52 };
     53 
     54 struct state {
     55 	char    ch;
     56 	int     fcode;
     57 	int     newst;
     58 };
     59 
     60 static const struct state atmata[] = {
     61 
     62 	{'R', 1, 0},	{'?', 7, 0},	{'Q', 0, -3},	{'B', 8, 25},
     63 	{'9', 2, 25},	{'8', 2, 25},	{'7', 2, 25},	{'6', 2, 25},
     64 	{'5', 2, 25},	{'4', 2, 25},	{'3', 2, 25},	{'2', 2, 19},
     65 	{'1', 2, 15},	{'0', 2, 25},	{'.', 0, 0},	{'9', 2, 25},
     66 	{'8', 2, 25},	{'7', 2, 25},	{'6', 2, 25},	{'5', 2, 25},
     67 
     68 	{'4', 2, 25},	{'3', 2, 25},	{'2', 2, 25},	{'1', 2, 25},
     69 	{'0', 2, 25},	{'/', 0, 32},	{'-', 0, 39},	{'.', 0, 0},
     70 	{'/', 5, 32},	{' ', 6, 3},	{',', 6, 3},	{'\n', 0, -1},
     71 	{'6', 3, 28},	{'5', 3, 28},	{'4', 3, 28},	{'3', 3, 28},
     72 	{'2', 3, 28},	{'1', 3, 28},	{'.', 0, 0},	{'H', 9, 61},
     73 
     74 	{'9', 4, 61},	{'8', 4, 61},	{'7', 4, 61},	{'6', 4, 61},
     75 	{'5', 4, 61},	{'4', 4, 61},	{'3', 4, 61},	{'2', 4, 53},
     76 	{'1', 4, 51},	{'0', 4, 61},	{'.', 0, 0},	{'9', 4, 61},
     77 	{'8', 4, 61},	{'7', 4, 61},	{'6', 4, 61},	{'5', 4, 61},
     78 	{'4', 4, 61},	{'3', 4, 61},	{'2', 4, 61},	{'1', 4, 61},
     79 
     80 	{'0', 4, 61},	{' ', 6, 3},	{',', 6, 3},	{'-', 5, 39},
     81 	{'\n', 0, -1},	{'.', 0, 0}
     82 };
     83 
     84 int
     85 checkmove(ist)
     86 	int     ist;
     87 {
     88 	int     j, n;
     89 	char    c;
     90 
     91 domove:
     92 	if (ist == 0) {
     93 		if (tflag)
     94 			curmove(curr, 32);
     95 		else
     96 			writel("\t\t");
     97 		writel("Move:  ");
     98 	}
     99 	ist = mvl = ncin = 0;
    100 	for (j = 0; j < 5; j++)
    101 		p[j] = g[j] = -1;
    102 
    103 dochar:
    104 	c = readc();
    105 
    106 	if (c == 'S') {
    107 		raflag = 0;
    108 		save(1);
    109 		if (tflag) {
    110 			curmove(cturn == -1 ? 18 : 19, 39);
    111 			ist = -1;
    112 			goto domove;
    113 		} else {
    114 			proll();
    115 			ist = 0;
    116 			goto domove;
    117 		}
    118 	}
    119 	if (c == old.c_cc[VERASE] && ncin > 0) {
    120 		if (tflag)
    121 			curmove(curr, curc - 1);
    122 		else {
    123 			if (old.c_cc[VERASE] == '\010')
    124 				writel("\010 \010");
    125 			else
    126 				writec(cin[ncin - 1]);
    127 		}
    128 		ncin--;
    129 		n = rsetbrd();
    130 		if (n == 0) {
    131 			n = -1;
    132 			if (tflag)
    133 				refresh();
    134 		}
    135 		if ((ist = n) > 0)
    136 			goto dochar;
    137 		goto domove;
    138 	}
    139 	if (c == old.c_cc[VKILL] && ncin > 0) {
    140 		if (tflag) {
    141 			refresh();
    142 			curmove(curr, 39);
    143 			ist = -1;
    144 			goto domove;
    145 		} else
    146 			if (old.c_cc[VERASE] == '\010') {
    147 				for (j = 0; j < ncin; j++)
    148 					writel("\010 \010");
    149 				ist = -1;
    150 				goto domove;
    151 			} else {
    152 				writec('\\');
    153 				writec('\n');
    154 				proll();
    155 				ist = 0;
    156 				goto domove;
    157 			}
    158 	}
    159 	n = dotable(c, ist);
    160 	if (n >= 0) {
    161 		cin[ncin++] = c;
    162 		if (n > 2)
    163 			if ((!tflag) || c != '\n')
    164 				writec(c);
    165 		ist = n;
    166 		if (n)
    167 			goto dochar;
    168 		else
    169 			goto domove;
    170 	}
    171 	if (n == -1 && mvl >= mvlim)
    172 		return (0);
    173 	if (n == -1 && mvl < mvlim - 1)
    174 		return (-4);
    175 
    176 	if (n == -6) {
    177 		if (!tflag) {
    178 			if (movokay(mvl + 1)) {
    179 				wrboard();
    180 				movback(mvl + 1);
    181 			}
    182 			proll();
    183 			writel("\t\tMove:  ");
    184 			for (j = 0; j < ncin;)
    185 				writec(cin[j++]);
    186 		} else {
    187 			if (movokay(mvl + 1)) {
    188 				refresh();
    189 				movback(mvl + 1);
    190 			} else
    191 				curmove(cturn == -1 ? 18 : 19, ncin + 39);
    192 		}
    193 		ist = n = rsetbrd();
    194 		goto dochar;
    195 	}
    196 	if (n != -5)
    197 		return (n);
    198 	writec('\007');
    199 	goto dochar;
    200 }
    201 
    202 int
    203 dotable(c, i)
    204 	char    c;
    205 	int     i;
    206 {
    207 	int     a;
    208 	int     test;
    209 
    210 	test = (c == 'R');
    211 
    212 	while ((a = atmata[i].ch) != '.') {
    213 		if (a == c || (test && a == '\n')) {
    214 			switch (atmata[i].fcode) {
    215 
    216 			case 1:
    217 				wrboard();
    218 				if (tflag) {
    219 					curmove(cturn == -1 ? 18 : 19, 0);
    220 					proll();
    221 					writel("\t\t");
    222 				} else
    223 					proll();
    224 				break;
    225 
    226 			case 2:
    227 				if (p[mvl] == -1)
    228 					p[mvl] = c - '0';
    229 				else
    230 					p[mvl] = p[mvl] * 10 + c - '0';
    231 				break;
    232 
    233 			case 3:
    234 				if (g[mvl] != -1) {
    235 					if (mvl < mvlim)
    236 						mvl++;
    237 					p[mvl] = p[mvl - 1];
    238 				}
    239 				g[mvl] = p[mvl] + cturn * (c - '0');
    240 				if (g[mvl] < 0)
    241 					g[mvl] = 0;
    242 				if (g[mvl] > 25)
    243 					g[mvl] = 25;
    244 				break;
    245 
    246 			case 4:
    247 				if (g[mvl] == -1)
    248 					g[mvl] = c - '0';
    249 				else
    250 					g[mvl] = g[mvl] * 10 + c - '0';
    251 				break;
    252 
    253 			case 5:
    254 				if (mvl < mvlim)
    255 					mvl++;
    256 				p[mvl] = g[mvl - 1];
    257 				break;
    258 
    259 			case 6:
    260 				if (mvl < mvlim)
    261 					mvl++;
    262 				break;
    263 
    264 			case 7:
    265 				if (tflag)
    266 					curmove(20, 0);
    267 				else
    268 					writec('\n');
    269 				(void) text(help2);
    270 				if (tflag) {
    271 					curmove(cturn == -1 ? 18 : 19, 39);
    272 				} else {
    273 					writec('\n');
    274 					proll();
    275 					writel("\t\tMove:  ");
    276 				}
    277 				break;
    278 
    279 			case 8:
    280 				p[mvl] = bar;
    281 				break;
    282 
    283 			case 9:
    284 				g[mvl] = home;
    285 			}
    286 
    287 			if (!test || a != '\n')
    288 				return (atmata[i].newst);
    289 			else
    290 				return (-6);
    291 		}
    292 		i++;
    293 	}
    294 
    295 	return (-5);
    296 }
    297 
    298 int
    299 rsetbrd()
    300 {
    301 	int     i, j, n;
    302 
    303 	n = 0;
    304 	mvl = 0;
    305 	for (i = 0; i < 4; i++)
    306 		p[i] = g[i] = -1;
    307 	for (j = 0; j < ncin; j++)
    308 		n = dotable(cin[j], n);
    309 	return (n);
    310 }
    311