[sgk-go] / interface / gtp_examples / metamachine.c

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
 * This is GNU Go, a Go program. Contact gnugo@gnu.org, or see       *
 * http://www.gnu.org/software/gnugo/ for more information.          *
 *                                                                   *
 * Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,   *
 * 2008 and 2009 by the Free Software Foundation.                    *
 *                                                                   *
 * This program is free software; you can redistribute it and/or     *
 * modify it under the terms of the GNU General Public License as    *
 * published by the Free Software Foundation - version 3             *
 * or (at your option) any later version.                            *
 *                                                                   *
 * This program is distributed in the hope that it will be useful,   *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of    *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the     *
 * GNU General Public License in file COPYING for more details.      *
 *                                                                   *
 * You should have received a copy of the GNU General Public         *
 * License along with this program; if not, write to the Free        *
 * Software Foundation, Inc., 51 Franklin Street, Fifth Floor,       *
 * Boston, MA 02111, USA.                                            *
\* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/*
 * This program sits between a GTP client and a GTP engine,
 * passing commands back and forth and modifying them in 
 * some cases.
 *
 * To the client it appears to be a GTP engine. 
 *                
 *             stdin             pipe a
 *  GTP client ----> metamachine -----> GTP engine
 *             <----             <-----
 *            stdout             pipe b
 *
 * Most commands are passed verbatim to the engine. The
 * exception is gg_genmove, which is intercepted then
 * processed differently. The top two moves are both
 * tried, the position evaluated by estimate_score,
 * and the move yielding the higher score is selected.
 *
 * Usage: no arguments gives normal GTP behavior.
 * 'metamachine --debug' sends diagnostics to stderr.  */

#include <stdio.h>
#include <unistd.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>

void error(const char *msg);
void gprintf(FILE *outputfile, const char *fmt, ...);
void trace(const char *fmt, ...);
void tell_gnugo(char *gnugo_line, const char *msg);

int boardsize = 19;
char delimiters[] = " \t\r\n";
char gnugo_line[128], client_line[128];
FILE *to_gnugo_stream, *from_gnugo_stream;

int debug = 0;

#define EMPTY        0
#define WHITE        1
#define BLACK        2

#define GTP_BUFSIZE  1000

void ask_gnugo(char *line, int verbose, const char *msg);

int
main(int argc, char *const *argv)
{
  int pfd_a[2];
  int pfd_b[2];
  int id;
  int k;
  char command[GTP_BUFSIZE];

  for (k = 1; k < argc; k++)
    if (argc > 1 && strstr(argv[k], "debug"))
      debug = 1;
  if (pipe(pfd_a) == -1)
    error("can't open pipe a");
  if (pipe(pfd_b) == -1)
    error("can't open pipe b");
  switch (fork()) {
  case -1:
    error("fork failed (try chopsticks)");
  case 0:
    /* Attach pipe a to stdin */
    if (dup2(pfd_a[0], 0) == -1) 
      error("dup pfd_a[0] failed");
    /* attach pipe b to stdout" */
    if (dup2(pfd_b[1], 1) == -1)
      error("dup pfd_b[1] failed");
    execlp("gnugo", "gnugo", "--mode", "gtp", "--quiet", NULL);
    error("execlp failed");
  }
  /* Attach pipe a to to_gnugo_stream  */
  to_gnugo_stream = fdopen(pfd_a[1], "w");
  /* Attach pipe b to from_gnugo_stream */
  from_gnugo_stream = fdopen(pfd_b[0], "r");
  
  while (1) {
    char *p;
    int n;

    if (!fgets(client_line, GTP_BUFSIZE, stdin)
	|| (strstr(client_line, "quit") == client_line)) {
      tell_gnugo("quit\n", "a");
	return 1;
    }

    /* remove comments */
    if ((p = strchr(client_line, '#')) != NULL)
      *p = 0;
    
    p = client_line;

    /* Look for an identification number. */
    if (sscanf(p, "%d%n", &id, &n) == 1)
      p += n;
    else
      id = -1; /* No identification number. */
    trace("id = %d\n", id);

    /* Look for command name. */
    if (sscanf(p, " %s %n", command, &n) < 1)
      continue; /* Whitespace only on this line, ignore. */
    p += n;
    trace("command: %s\n", command);

    if (!strncmp(command, "boardsize", 9)) {
      char *token;
      tell_gnugo(client_line, "b");
      ask_gnugo(gnugo_line, 1, "1");

      token = strtok(client_line, delimiters);
      token = strtok(NULL, delimiters);
      boardsize = atoi(token);
    }
    else if (!strncmp(command, "gg_genmove", 10)) {
      int move_i[10], move_j[10];
      float move_value[10], position_value[10];
      int moves_considered;
      int k;
      char *token;
      int line_length = 0;
      int color;

      if (strstr(client_line, "black"))
	color = BLACK;
      else if (strstr(client_line, "white"))
	color = WHITE;
      else {
	color = EMPTY;
	printf("?\n\n");
      }

      if (color == BLACK)
	tell_gnugo("top_moves_black\n", "c");
      else 
	tell_gnugo("top_moves_white\n", "d");

      ask_gnugo(gnugo_line, 0, "2");
      token = strtok(gnugo_line, delimiters);
      for (k = 0; k < 10; k++) {
	move_i[k] = -1;
	move_j[k] = -1;
	move_value[k] = 0.0;
      }
      for (k = 0; k < 10; k++) {
	token = strtok(NULL, delimiters);
	if (!token)
	  break;
	string_to_location(boardsize, token, move_i+k, move_j+k);
	token = strtok(NULL, delimiters);
	if (!token)
	  break;
	sscanf(token, "%f", move_value+k);
	trace("move %d: %m valued %f\n", k,
		  move_i[k], move_j[k], move_value[k]);
      }
      moves_considered = k;
      if (debug)
	fprintf(stderr, "moves considered: %d\n",
		moves_considered);
      for (k = 0; k < 2 && k < moves_considered; k++) {
	float upper, lower;
	int n;

	trace("%s %m\n", color == BLACK ? "black" : "white",
		  move_i[k], move_j[k]);
	gprintf(to_gnugo_stream, "%s %m\n", color == BLACK ? "black" : "white",
		move_i[k], move_j[k]);
	fflush(to_gnugo_stream);
	ask_gnugo(gnugo_line, 0, "3");
	tell_gnugo("estimate_score\n", "e");
	ask_gnugo(gnugo_line, 0, "4");
	strtok(gnugo_line, "()\n");
	token = strtok(NULL, "()\n");
	trace("%s\n", token);
	sscanf(token, "upper bound: %f, lower: %f%n",
	       &upper, &lower, &n);
	if (n < 2)
	  error("can't read territory");
	trace("upper %f, lower %f\n", upper, lower);
	tell_gnugo("undo\n", "f");
	ask_gnugo(gnugo_line, 0, "5");
	fflush(stdout);
	if (color == BLACK)
	  position_value[k] = - upper;
	else
	  position_value[k] = lower;
	trace("position value %f\n", position_value[k]);
      }
      if (moves_considered == 0) {
	if (id == -1)
	  gprintf(stdout, "= PASS\n\n");
	else
	  gprintf(stdout, "=%d PASS\n\n", id);
	fflush(stdout);
      }
      else if (moves_considered == 1
	       || position_value[0] > position_value[1]) {
	gprintf(to_gnugo_stream, "%s %m\n", color == BLACK ? "black" : "white",
		move_i[0], move_j[0]);
	ask_gnugo(gnugo_line, 0, "6");
	if (id == -1)
	  gprintf(stdout, "= %m\n\n", move_i[0], move_j[0]);
	else
	  gprintf(stdout, "=%d %m\n\n", id, move_i[0], move_j[0]);
	fflush(stdout);
      }
      else {
	gprintf(to_gnugo_stream, "%s %m\n", color == BLACK ? "black" : "white",
		move_i[1], move_j[1]);
	ask_gnugo(gnugo_line, 0, "7");
	if (id == -1)
	  gprintf(stdout, "= %m\n\n", move_i[1], move_j[1]);
	else
	  gprintf(stdout, "=%d %m\n\n", id, move_i[1], move_j[1]);
	fflush(stdout);
      }
    }
    else {
      tell_gnugo(client_line, "g");
      ask_gnugo(gnugo_line, 1, "8");
    }
    /* loadsgf commands could change the boardsize, so we get
     * it from the engine, after the command is run. */
    if (!strncmp(command, "loadsgf", 7)) {
      tell_gnugo("query_boardsize\n", "i");
      ask_gnugo(gnugo_line, 0, "10");
      if (!sscanf(gnugo_line, "= %d", &boardsize))
	error("can't get boardsize");
      trace("setting boardsize %d\n", boardsize);
      fflush(stderr);
    }
  }
}

 
/* bark and barf */

void
error(const char *msg)      
{
  fprintf(stderr, "metamachine: %s\n", msg);
  tell_gnugo("quit\n", msg);
  abort();
}

/* Send a GTP command to the engine. */

void
tell_gnugo(char *gnugo_line, const char *msg)
{
  gprintf(to_gnugo_stream, gnugo_line);
  fflush(to_gnugo_stream);
  if (debug) {
    fprintf(stderr, "%s: %s", msg, gnugo_line);
    fflush(stderr);
  }
}

/* Obtains the engine's response to a GTP command. If verbose is true,
 * the reply is echoed to stdout.
 */

void
ask_gnugo(char *gnugo_line, int verbose, const char *msg)
{
  int line_length = 0;
  char line[GTP_BUFSIZE];

  while (line_length != 1) {
    if (!fgets(line, 128, from_gnugo_stream))
      error("can't get response");
    line_length = strlen(line);
    if (line_length > 1 
	&& (line[0] == '=' || line[0] == '?'))
      strncpy(gnugo_line, line, 128);
    if (verbose)
      printf(line);
    if (debug)
      fprintf(stderr, "%s: %s\n", msg, gnugo_line);
  }
  if (verbose)
    fflush(stdout);
  fflush(stderr);
}


/* Adapted from GNU Go. Formatted output with %m format. */

void 
gprintf(FILE *outputfile, const char *fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  vgprintf(outputfile, fmt, ap);
  fflush(outputfile);
  va_end(ap);
}

/* print diagnostic */

void
trace(const char *fmt, ...)
{
  va_list ap;
  if (debug) {
    va_start(ap, fmt);
    vgprintf(stderr, fmt, ap);
    fflush(stderr);
    va_end(ap);
  }
}

int
vgprintf(FILE *outputfile, const char *fmt, va_list ap)
{
  for ( ; *fmt; ++fmt) {
    if (*fmt == '%') {
      switch (*++fmt) {
      case 'c':
	{
	  /* rules of promotion => passed as int, not char */

	  int c = va_arg(ap, int);
	  putc(c, outputfile);
	  break;
	}
      case 'd':
	{
	  int d = va_arg(ap, int);
	  fprintf(outputfile, "%d", d);
	  break;
	}
      case 'f':
	{
	  double f = va_arg(ap, double); /* passed as double, not float */
	  fprintf(outputfile, "%.2f", f);
	  break;
	}
      case 's':
	{
	  char *s = va_arg(ap, char *);
	  fputs(s, outputfile);
	  break;
	}
      case 'm':
      case 'M':
	{
	  char movename[4];
	  int m = va_arg(ap, int);
	  int n = va_arg(ap, int);
	  if (m == -1 && n == -1)
	    fputs("PASS", outputfile);
	  else if (m < 0 || n < 0 || m >= 19 || n >= 19)
	    fprintf(outputfile, "[%d,%d]", m, n);
	  else {
	    /* Generate the move name. */
	    if (n < 8)
	      movename[0] = n + 65;
	    else
	      movename[0] = n + 66;
	    if (*fmt == 'm')
	      sprintf(movename+1, "%d", boardsize-m);
	    else
	      sprintf(movename+1, "%-2d", boardsize-m);
	    fputs(movename, outputfile);
	  }
	  break;
	}
      default:
	{
	  fprintf(outputfile, "\n\nUnknown format character: '%c'\n", *fmt);
	  abort();
	}
      }
    }
    else
      putc(*fmt, outputfile);
  }
  fflush(outputfile);
}

/* Extracts coordinates from a location in algebraic notation */

int
string_to_location(int boardsize, char *str, int *m, int *n)
{
  if (*str == '\0')
    return 0;

  if (!isalpha((int) *str))
    return 0;
  *n = tolower((int) *str) - 'a';
  if (tolower((int) *str) >= 'i')
    --*n;
  if (*n < 0 || *n > boardsize - 1)
    return 0;

  if (!isdigit((int) *(str+1)))
    return 0;
  *m = boardsize - atoi(str + 1);
  if (*m < 0 || *m > boardsize - 1)
    return 0;

  return 1;
}
Commit	Line	Data
7eeb782e AT	1	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
	2	* This is GNU Go, a Go program. Contact gnugo@gnu.org, or see *
	3	* http://www.gnu.org/software/gnugo/ for more information. *
	4	* *
	5	* Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, *
	6	* 2008 and 2009 by the Free Software Foundation. *
	7	* *
	8	* This program is free software; you can redistribute it and/or *
	9	* modify it under the terms of the GNU General Public License as *
	10	* published by the Free Software Foundation - version 3 *
	11	* or (at your option) any later version. *
	12	* *
	13	* This program is distributed in the hope that it will be useful, *
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	16	* GNU General Public License in file COPYING for more details. *
	17	* *
	18	* You should have received a copy of the GNU General Public *
	19	* License along with this program; if not, write to the Free *
	20	* Software Foundation, Inc., 51 Franklin Street, Fifth Floor, *
	21	* Boston, MA 02111, USA. *
	22	\* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	23
	24	/*
	25	* This program sits between a GTP client and a GTP engine,
	26	* passing commands back and forth and modifying them in
	27	* some cases.
	28	*
	29	* To the client it appears to be a GTP engine.
	30	*
	31	* stdin pipe a
	32	* GTP client ----> metamachine -----> GTP engine
	33	* <---- <-----
	34	* stdout pipe b
	35	*
	36	* Most commands are passed verbatim to the engine. The
	37	* exception is gg_genmove, which is intercepted then
	38	* processed differently. The top two moves are both
	39	* tried, the position evaluated by estimate_score,
	40	* and the move yielding the higher score is selected.
	41	*
	42	* Usage: no arguments gives normal GTP behavior.
	43	* 'metamachine --debug' sends diagnostics to stderr. */
	44
	45	#include <stdio.h>
	46	#include <unistd.h>
	47	#include <stdarg.h>
	48	#include <string.h>
	49	#include <ctype.h>
	50
	51	void error(const char *msg);
	52	void gprintf(FILE outputfile, const char fmt, ...);
	53	void trace(const char *fmt, ...);
	54	void tell_gnugo(char gnugo_line, const char msg);
	55
	56	int boardsize = 19;
	57	char delimiters[] = " \t\r\n";
	58	char gnugo_line[128], client_line[128];
	59	FILE to_gnugo_stream, from_gnugo_stream;
	60
	61	int debug = 0;
	62
	63	#define EMPTY 0
	64	#define WHITE 1
65	#define BLACK 2
66
67	#define GTP_BUFSIZE 1000
68
69	void ask_gnugo(char line, int verbose, const char msg);
70
71	int
72	main(int argc, char const argv)
73	{
74	int pfd_a[2];
75	int pfd_b[2];
76	int id;
77	int k;
78	char command[GTP_BUFSIZE];
79
80	for (k = 1; k < argc; k++)
81	if (argc > 1 && strstr(argv[k], "debug"))
82	debug = 1;
83	if (pipe(pfd_a) == -1)
84	error("can't open pipe a");
85	if (pipe(pfd_b) == -1)
86	error("can't open pipe b");
87	switch (fork()) {
88	case -1:
89	error("fork failed (try chopsticks)");
90	case 0:
91	/* Attach pipe a to stdin */
92	if (dup2(pfd_a[0], 0) == -1)
93	error("dup pfd_a[0] failed");
94	/* attach pipe b to stdout" */
95	if (dup2(pfd_b[1], 1) == -1)
96	error("dup pfd_b[1] failed");
97	execlp("gnugo", "gnugo", "--mode", "gtp", "--quiet", NULL);
98	error("execlp failed");
99	}
100	/* Attach pipe a to to_gnugo_stream */
101	to_gnugo_stream = fdopen(pfd_a[1], "w");
102	/* Attach pipe b to from_gnugo_stream */
103	from_gnugo_stream = fdopen(pfd_b[0], "r");
104
105	while (1) {
106	char *p;
107	int n;
108
109	if (!fgets(client_line, GTP_BUFSIZE, stdin)
110	\|\| (strstr(client_line, "quit") == client_line)) {
111	tell_gnugo("quit\n", "a");
112	return 1;
113	}
114
115	/* remove comments */
116	if ((p = strchr(client_line, '#')) != NULL)
117	*p = 0;
118
119	p = client_line;
120
121	/* Look for an identification number. */
122	if (sscanf(p, "%d%n", &id, &n) == 1)
123	p += n;
124	else
125	id = -1; /* No identification number. */
126	trace("id = %d\n", id);
127
128	/* Look for command name. */
129	if (sscanf(p, " %s %n", command, &n) < 1)
130	continue; /* Whitespace only on this line, ignore. */
131	p += n;
132	trace("command: %s\n", command);
133
134	if (!strncmp(command, "boardsize", 9)) {
135	char *token;
136	tell_gnugo(client_line, "b");
137	ask_gnugo(gnugo_line, 1, "1");
138
139	token = strtok(client_line, delimiters);
140	token = strtok(NULL, delimiters);
141	boardsize = atoi(token);
142	}
143	else if (!strncmp(command, "gg_genmove", 10)) {
144	int move_i[10], move_j[10];
145	float move_value[10], position_value[10];
146	int moves_considered;
147	int k;
148	char *token;
149	int line_length = 0;
150	int color;
151
152	if (strstr(client_line, "black"))
153	color = BLACK;
154	else if (strstr(client_line, "white"))
155	color = WHITE;
156	else {
157	color = EMPTY;
158	printf("?\n\n");
159	}
160
161	if (color == BLACK)
162	tell_gnugo("top_moves_black\n", "c");
163	else
164	tell_gnugo("top_moves_white\n", "d");
165
166	ask_gnugo(gnugo_line, 0, "2");
167	token = strtok(gnugo_line, delimiters);
168	for (k = 0; k < 10; k++) {
169	move_i[k] = -1;
170	move_j[k] = -1;
171	move_value[k] = 0.0;
172	}
173	for (k = 0; k < 10; k++) {
174	token = strtok(NULL, delimiters);
175	if (!token)
176	break;
177	string_to_location(boardsize, token, move_i+k, move_j+k);
178	token = strtok(NULL, delimiters);
179	if (!token)
180	break;
181	sscanf(token, "%f", move_value+k);
182	trace("move %d: %m valued %f\n", k,
183	move_i[k], move_j[k], move_value[k]);
184	}
185	moves_considered = k;
186	if (debug)
187	fprintf(stderr, "moves considered: %d\n",
188	moves_considered);
189	for (k = 0; k < 2 && k < moves_considered; k++) {
190	float upper, lower;
191	int n;
192
193	trace("%s %m\n", color == BLACK ? "black" : "white",
194	move_i[k], move_j[k]);
195	gprintf(to_gnugo_stream, "%s %m\n", color == BLACK ? "black" : "white",
196	move_i[k], move_j[k]);
197	fflush(to_gnugo_stream);
198	ask_gnugo(gnugo_line, 0, "3");
199	tell_gnugo("estimate_score\n", "e");
200	ask_gnugo(gnugo_line, 0, "4");
201	strtok(gnugo_line, "()\n");
202	token = strtok(NULL, "()\n");
203	trace("%s\n", token);
204	sscanf(token, "upper bound: %f, lower: %f%n",
205	&upper, &lower, &n);
206	if (n < 2)
207	error("can't read territory");
208	trace("upper %f, lower %f\n", upper, lower);
209	tell_gnugo("undo\n", "f");
210	ask_gnugo(gnugo_line, 0, "5");
211	fflush(stdout);
212	if (color == BLACK)
213	position_value[k] = - upper;
214	else
215	position_value[k] = lower;
216	trace("position value %f\n", position_value[k]);
217	}
218	if (moves_considered == 0) {
219	if (id == -1)
220	gprintf(stdout, "= PASS\n\n");
221	else
222	gprintf(stdout, "=%d PASS\n\n", id);
223	fflush(stdout);
224	}
225	else if (moves_considered == 1
226	\|\| position_value[0] > position_value[1]) {
227	gprintf(to_gnugo_stream, "%s %m\n", color == BLACK ? "black" : "white",
228	move_i[0], move_j[0]);
229	ask_gnugo(gnugo_line, 0, "6");
230	if (id == -1)
231	gprintf(stdout, "= %m\n\n", move_i[0], move_j[0]);
232	else
233	gprintf(stdout, "=%d %m\n\n", id, move_i[0], move_j[0]);
234	fflush(stdout);
235	}
236	else {
237	gprintf(to_gnugo_stream, "%s %m\n", color == BLACK ? "black" : "white",
238	move_i[1], move_j[1]);
239	ask_gnugo(gnugo_line, 0, "7");
240	if (id == -1)
241	gprintf(stdout, "= %m\n\n", move_i[1], move_j[1]);
242	else
243	gprintf(stdout, "=%d %m\n\n", id, move_i[1], move_j[1]);
244	fflush(stdout);
245	}
246	}
247	else {
248	tell_gnugo(client_line, "g");
249	ask_gnugo(gnugo_line, 1, "8");
250	}
251	/* loadsgf commands could change the boardsize, so we get
252	* it from the engine, after the command is run. */
253	if (!strncmp(command, "loadsgf", 7)) {
254	tell_gnugo("query_boardsize\n", "i");
255	ask_gnugo(gnugo_line, 0, "10");
256	if (!sscanf(gnugo_line, "= %d", &boardsize))
257	error("can't get boardsize");
258	trace("setting boardsize %d\n", boardsize);
259	fflush(stderr);
260	}
261	}
262	}
263
264
265	/* bark and barf */
266
267	void
268	error(const char *msg)
269	{
270	fprintf(stderr, "metamachine: %s\n", msg);
271	tell_gnugo("quit\n", msg);
272	abort();
273	}
274
275	/* Send a GTP command to the engine. */
276
277	void
278	tell_gnugo(char gnugo_line, const char msg)
279	{
280	gprintf(to_gnugo_stream, gnugo_line);
281	fflush(to_gnugo_stream);
282	if (debug) {
283	fprintf(stderr, "%s: %s", msg, gnugo_line);
284	fflush(stderr);
285	}
286	}
287
288	/* Obtains the engine's response to a GTP command. If verbose is true,
289	* the reply is echoed to stdout.
290	*/
291
292	void
293	ask_gnugo(char gnugo_line, int verbose, const char msg)
294	{
295	int line_length = 0;
296	char line[GTP_BUFSIZE];
297
298	while (line_length != 1) {
299	if (!fgets(line, 128, from_gnugo_stream))
300	error("can't get response");
301	line_length = strlen(line);
302	if (line_length > 1
303	&& (line[0] == '=' \|\| line[0] == '?'))
304	strncpy(gnugo_line, line, 128);
305	if (verbose)
306	printf(line);
307	if (debug)
308	fprintf(stderr, "%s: %s\n", msg, gnugo_line);
309	}
310	if (verbose)
311	fflush(stdout);
312	fflush(stderr);
313	}
314
315
316	/* Adapted from GNU Go. Formatted output with %m format. */
317
318	void
319	gprintf(FILE outputfile, const char fmt, ...)
320	{
321	va_list ap;
322	va_start(ap, fmt);
323	vgprintf(outputfile, fmt, ap);
324	fflush(outputfile);
325	va_end(ap);
326	}
327
328	/* print diagnostic */
329
330	void
331	trace(const char *fmt, ...)
332	{
333	va_list ap;
334	if (debug) {
335	va_start(ap, fmt);
336	vgprintf(stderr, fmt, ap);
337	fflush(stderr);
338	va_end(ap);
339	}
340	}
341
342	int
343	vgprintf(FILE outputfile, const char fmt, va_list ap)
344	{
345	for ( ; *fmt; ++fmt) {
346	if (*fmt == '%') {
347	switch (*++fmt) {
348	case 'c':
349	{
350	/* rules of promotion => passed as int, not char */
351
352	int c = va_arg(ap, int);
353	putc(c, outputfile);
354	break;
355	}
356	case 'd':
357	{
358	int d = va_arg(ap, int);
359	fprintf(outputfile, "%d", d);
360	break;
361	}
362	case 'f':
363	{
364	double f = va_arg(ap, double); /* passed as double, not float */
365	fprintf(outputfile, "%.2f", f);
366	break;
367	}
368	case 's':
369	{
370	char s = va_arg(ap, char );
371	fputs(s, outputfile);
372	break;
373	}
374	case 'm':
375	case 'M':
376	{
377	char movename[4];
378	int m = va_arg(ap, int);
379	int n = va_arg(ap, int);
380	if (m == -1 && n == -1)
381	fputs("PASS", outputfile);
382	else if (m < 0 \|\| n < 0 \|\| m >= 19 \|\| n >= 19)
383	fprintf(outputfile, "[%d,%d]", m, n);
384	else {
385	/* Generate the move name. */
386	if (n < 8)
387	movename[0] = n + 65;
388	else
389	movename[0] = n + 66;
390	if (*fmt == 'm')
391	sprintf(movename+1, "%d", boardsize-m);
392	else
393	sprintf(movename+1, "%-2d", boardsize-m);
394	fputs(movename, outputfile);
395	}
396	break;
397	}
398	default:
399	{
400	fprintf(outputfile, "\n\nUnknown format character: '%c'\n", *fmt);
401	abort();
402	}
403	}
404	}
405	else
406	putc(*fmt, outputfile);
407	}
408	fflush(outputfile);
409	}
410
411	/* Extracts coordinates from a location in algebraic notation */
412
413	int
414	string_to_location(int boardsize, char str, int m, int *n)
415	{
416	if (*str == '\0')
417	return 0;
418
419	if (!isalpha((int) *str))
420	return 0;
421	n = tolower((int) str) - 'a';
422	if (tolower((int) *str) >= 'i')
423	--*n;
424	if (n < 0 \|\| n > boardsize - 1)
425	return 0;
426
427	if (!isdigit((int) *(str+1)))
428	return 0;
429	*m = boardsize - atoi(str + 1);
430	if (m < 0 \|\| m > boardsize - 1)
431	return 0;
432
433	return 1;
434	}
435