Initial commit of GNU Go v3.8.

[sgk-go] / interface / gtp_examples / vanilla.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 uses two pipes to communicate with the
 * GNU Go client. To an external client it appears to
 * be a gtp engine. It accomplishes this by intercepting
 * gtp commands and passing them on to GNU Go.
 *
 * This program in and of itself is not useful but it
 * can be the basis of useful programs. Example: hack
 * in gmp.c and get a gtp / gmp mediator.
 * 
 * Pipe a: client --> gnugo
 * Pipe b: gnugo --> client
 */

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

void error(const char *msg);
#define TELL_GNUGO(x) if (verbose) fprintf(stderr, "%s", x); \
                      if (fprintf(to_gnugo_stream, "%s", x) < 0) \
                         error ("can't write command in to_gnugo_stream"); \
                      fflush(to_gnugo_stream);
#define ASK_GNUGO(x)  if (!fgets(x, 128, from_gnugo_stream)) \
                         error("can't get response");
int
main()
{
  int pfd_a[2];
  int pfd_b[2];
  char gnugo_line[128], client_line[128];
  int length = 0;
  int verbose = 1;
  FILE *to_gnugo_stream, *from_gnugo_stream;

  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");
  }
  /* We use stderr to communicate with the client since stdout is needed. */
  /* 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) {
    int length = 0;
    if (!fgets(client_line, 128, stdin) 
	|| !strncmp(client_line, "quit", 4)) {
      TELL_GNUGO("quit\n");
      return 1;
    }
    if (!strncmp(client_line, "genmove_black", 13)) {
      char *token;
      const char delimiters[] = " \t\r\n";
      float value1, value2;

      TELL_GNUGO("top_moves_black\n");
      ASK_GNUGO(gnugo_line);
      token = strtok(gnugo_line, delimiters);
      token = strtok(NULL, delimiters);
      TELL_GNUGO("black ");
      TELL_GNUGO(token);
      TELL_GNUGO("\n");
      ASK_GNUGO(gnugo_line);
      while (length != 1) {
	ASK_GNUGO(gnugo_line);
	length = strlen(gnugo_line);
	printf(gnugo_line);
	fflush(stdout);
      }
    }
    else {
      TELL_GNUGO(client_line);
      while (length != 1) {
	ASK_GNUGO(gnugo_line);
	length = strlen(gnugo_line);
	printf(gnugo_line);
	fflush(stdout);
      }
    }
  }
}

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



/*
 * Local Variables:
 * tab-width: 8
 * c-basic-offset: 2
 * End:
 */