/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
* 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. *
\* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* Parts of this code were given to us by Tommy Thorn */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <assert.h>
#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
# include <sys/time.h>
# else
# include <time.h>
# endif
#endif
#include "sgftree.h"
#include "gg_utils.h"
#define STRICT_SGF 's'
#define LAX_SGF 'l'
/* Set this to 1 if you want warnings for missing GM and FF properties. */
#define VERBOSE_WARNINGS 0
/* ================================================================ */
/* Some utility functions. */
/* ================================================================ */
/*
* Utility: a checking, initializing malloc
*/
void *
xalloc(unsigned int size)
{
void *pt = malloc(size);
if (!pt) {
fprintf(stderr, "xalloc: Out of memory!\n");
exit(EXIT_FAILURE);
}
memset(pt, 0, (unsigned long) size);
return pt;
}
void *
xrealloc(void *pt, unsigned int size)
{
void *ptnew = realloc(pt, size);
if (!ptnew) {
fprintf(stderr, "xrealloc: Out of memory!\n");
exit(EXIT_FAILURE);
}
return ptnew;
}
/* ================================================================ */
/* SGF Nodes */
/* ================================================================ */
/*
* Allocate memory for a new SGF node.
*/
SGFNode *
sgfNewNode()
{
SGFNode *newnode;
newnode = xalloc(sizeof(SGFNode));
newnode->next = NULL;
newnode->props = NULL;
newnode->parent = NULL;
newnode->child = NULL;
return newnode;
}
/*
* Recursively free an sgf node
*/
void
sgfFreeNode(SGFNode *node)
{
if (node == NULL)
return;
sgfFreeNode(node->next);
sgfFreeNode(node->child);
sgfFreeProperty(node->props);
free(node);
}
/*
* Add a generic text property to an SGF node.
*/
void
sgfAddProperty(SGFNode *node, const char *name, const char *value)
{
SGFProperty *prop = node->props;
if (prop)
while (prop->next)
prop = prop->next;
sgfMkProperty(name, value, node, prop);
}
/*
* Add an integer property to an SGF node.
*/
void
sgfAddPropertyInt(SGFNode *node, const char *name, long val)
{
char buffer[10];
gg_snprintf(buffer, 10, "%ld", val);
sgfAddProperty(node, name, buffer);
}
/*
* Add a float property to an SGF node.
*/
void
sgfAddPropertyFloat(SGFNode *node, const char *name, float val)
{
char buffer[10];
gg_snprintf(buffer, 10, "%3.1f", val);
sgfAddProperty(node, name, buffer);
}
/*
* Read a property as int from an SGF node.
*/
int
sgfGetIntProperty(SGFNode *node, const char *name, int *value)
{
SGFProperty *prop;
short nam = name[0] | name[1] << 8;
for (prop = node->props; prop; prop = prop->next)
if (prop->name == nam) {
*value = atoi(prop->value);
return 1;
}
return 0;
}
/*
* Read a property as float from an SGF node.
*/
int
sgfGetFloatProperty(SGFNode *node, const char *name, float *value)
{
SGFProperty *prop;
short nam = name[0] | name[1] << 8;
for (prop = node->props; prop; prop = prop->next)
if (prop->name == nam) {
*value = (float) atof(prop->value);
/* MS-C warns of loss of data (double to float) */
return 1;
}
return 0;
}
/*
* Read a property as text from an SGF node.
*/
int
sgfGetCharProperty(SGFNode *node, const char *name, char **value)
{
SGFProperty *prop;
short nam = name[0] | name[1] << 8;
for (prop = node->props; prop; prop = prop->next)
if (prop->name == nam) {
*value = prop->value;
return 1;
}
return 0;
}
/*
* Is there a property of this type in the node?
*/
static int
sgfHasProperty(SGFNode *node, const char *name)
{
SGFProperty *prop;
short nam = name[0] | name[1] << 8;
for (prop = node->props; prop; prop = prop->next)
if (prop->name == nam)
return 1;
return 0;
}
/*
* Overwrite a property from an SGF node with text or create a new
* one if it does not exist.
*/
void
sgfOverwriteProperty(SGFNode *node, const char *name, const char *text)
{
SGFProperty *prop;
short nam = name[0] | name[1] << 8;
for (prop = node->props; prop; prop = prop->next)
if (prop->name == nam) {
prop->value = xrealloc(prop->value, strlen(text)+1);
strcpy(prop->value, text);
return;
}
sgfAddProperty(node, name, text);
}
/*
* Overwrite an int property in an SGF node with val or create a new
* one if it does not exist.
*/
void
sgfOverwritePropertyInt(SGFNode *node, const char *name, int val)
{
SGFProperty *prop;
short nam = name[0] | name[1] << 8;
for (prop = node->props; prop; prop = prop->next)
if (prop->name == nam) {
prop->value = xrealloc(prop->value, 12);
gg_snprintf(prop->value, 12, "%d", val);
return;
}
sgfAddPropertyInt(node, name, val);
}
/*
* Overwrite a float property in the gametree with val or create
* a new one if it does not exist.
*/
void
sgfOverwritePropertyFloat(SGFNode *node, const char *name, float val)
{
SGFProperty *prop;
short nam = name[0] | name[1] << 8;
for (prop = node->props; prop; prop = prop->next)
if (prop->name == nam) {
prop->value = xrealloc(prop->value, 15);
gg_snprintf(prop->value, 15, "%3.1f", val);
return;
}
sgfAddPropertyFloat(node, name, val);
}
/*
* Goto previous node.
*/
SGFNode *
sgfPrev(SGFNode *node)
{
SGFNode *q;
SGFNode *prev;
if (!node->parent)
return NULL;
q = node->parent->child;
prev = NULL;
while (q && q != node) {
prev = q;
q = q->next;
}
return prev;
}
/*
* Goto root node.
*/
SGFNode *
sgfRoot(SGFNode *node)
{
while (node->parent)
node = node->parent;
return node;
}
/* ================================================================ */
/* SGF Properties */
/* ================================================================ */
/*
* Make an SGF property.
*/
static SGFProperty *
do_sgf_make_property(short sgf_name, const char *value,
SGFNode *node, SGFProperty *last)
{
SGFProperty *prop;
prop = (SGFProperty *) xalloc(sizeof(SGFProperty));
prop->name = sgf_name;
prop->value = xalloc(strlen(value) + 1);
strcpy(prop->value, value);
prop->next = NULL;
if (last == NULL)
node->props = prop;
else
last->next = prop;
return prop;
}
/* Make an SGF property. In case of a property with a range it
* expands it and makes several properties instead.
*/
SGFProperty *
sgfMkProperty(const char *name, const char *value,
SGFNode *node, SGFProperty *last)
{
static const short properties_allowing_ranges[12] = {
/* Board setup properties. */
SGFAB, SGFAW, SGFAE,
/* Markup properties. */
SGFCR, SGFMA, SGFSQ, SGFTR, SGFDD, SGFSL,
/* Miscellaneous properties. */
SGFVW,
/* Go-specific properties. */
SGFTB, SGFTW
};
int k;
short sgf_name;
if (strlen(name) == 1)
sgf_name = name[0] | (short) (' ' << 8);
else
sgf_name = name[0] | name[1] << 8;
for (k = 0; k < 12; k++) {
if (properties_allowing_ranges[k] == sgf_name)
break;
}
if (k < 12
&& strlen(value) == 5
&& value[2] == ':') {
char x1 = value[0];
char y1 = value[1];
char x2 = value[3];
char y2 = value[4];
char new_value[] = "xy";
if (x1 <= x2 && y1 <= y2) {
for (new_value[0] = x1; new_value[0] <= x2; new_value[0]++) {
for (new_value[1] = y1; new_value[1] <= y2; new_value[1]++)
last = do_sgf_make_property(sgf_name, new_value, node, last);
}
return last;
}
}
/* Not a range property. */
return do_sgf_make_property(sgf_name, value, node, last);
}
/*
* Recursively free an SGF property.
*
*/
void
sgfFreeProperty(SGFProperty *prop)
{
if (prop == NULL)
return;
sgfFreeProperty(prop->next);
free(prop->value);
free(prop);
}
/* ================================================================ */
/* High level functions */
/* ================================================================ */
/*
* Add a stone to the current or the given node.
* Return the node where the stone was added.
*/
SGFNode *
sgfAddStone(SGFNode *node, int color, int movex, int movey)
{
char move[3];
sprintf(move, "%c%c", movey + 'a', movex + 'a');
sgfAddProperty(node, (color == BLACK) ? "AB" : "AW", move);
return node;
}
/*
* Add a move to the gametree.
*/
SGFNode *
sgfAddPlay(SGFNode *node, int who, int movex, int movey)
{
char move[3];
SGFNode *new;
/* a pass move? */
if (movex == -1 && movey == -1)
move[0] = 0;
else
sprintf(move, "%c%c", movey + 'a', movex + 'a');
if (node->child)
new = sgfStartVariantFirst(node->child);
else {
new = sgfNewNode();
node->child = new;
new->parent = node;
}
sgfAddProperty(new, (who == BLACK) ? "B" : "W", move);
return new;
}
/*
* Add a move to the gametree. New variations are added after the old
* ones rather than before.
*/
SGFNode *
sgfAddPlayLast(SGFNode *node, int who, int movex, int movey)
{
char move[3];
SGFNode *new;
/* a pass move? */
if (movex == -1 && movey == -1)
move[0] = 0;
else
sprintf(move, "%c%c", movey + 'a', movex + 'a');
new = sgfAddChild(node);
sgfAddProperty(new, (who == BLACK) ? "B" : "W", move);
return new;
}
SGFNode *
sgfCreateHeaderNode(int boardsize, float komi, int handicap)
{
SGFNode *root = sgfNewNode();
sgfAddPropertyInt(root, "SZ", boardsize);
sgfAddPropertyFloat(root, "KM", komi);
sgfAddPropertyInt(root, "HA", handicap);
return root;
}
/*
* Add a comment to an SGF node.
*/
SGFNode *
sgfAddComment(SGFNode *node, const char *comment)
{
sgfAddProperty(node, "C ", comment);
return node;
}
/*
* Place text on the board at position (i, j).
*/
SGFNode *
sgfBoardText(SGFNode *node, int i, int j, const char *text)
{
void *str = xalloc(strlen(text) + 3);
sprintf(str, "%c%c:%s", j+'a', i+'a', text);
sgfAddProperty(node, "LB", str);
free(str);
return node;
}
/*
* Place a character on the board at position (i, j).
*/
SGFNode *
sgfBoardChar(SGFNode *node, int i, int j, char c)
{
char text[2] = "";
text[0] = c;
text[1] = 0;
return sgfBoardText(node, i, j, text);
}
/*
* Place a number on the board at position (i, j).
*/
SGFNode *
sgfBoardNumber(SGFNode *node, int i, int j, int number)
{
char text[10];
gg_snprintf(text, 10, "%c%c:%i", j+'a', i+'a', number);
sgfAddProperty(node, "LB", text);
return node;
}
/*
* Place a triangle mark on the board at position (i, j).
*/
SGFNode *
sgfTriangle(SGFNode *node, int i, int j)
{
char text[3];
gg_snprintf(text, 3, "%c%c", j+'a', i+'a');
sgfAddProperty(node, "TR", text);
return node;
}
/*
* Place a label on the board at position (i, j).
*/
SGFNode *
sgfLabel(SGFNode *node, const char *label, int i, int j)
{
/* allows 12 chars labels - more than enough */
char text[16];
gg_snprintf(text, 16, "%c%c:%s", j+'a', i+'a', label);
sgfAddProperty(node, "LB", text);
return node;
}
/*
* Place a numeric label on the board at position (i, j).
*/
SGFNode *
sgfLabelInt(SGFNode *node, int num, int i, int j)
{
char text[16];
gg_snprintf(text, 16, "%c%c:%d", j+'a', i+'a', num);
sgfAddProperty(node, "LB", text);
return node;
}
/*
* Place a circle mark on the board at position (i, j).
*/
SGFNode *
sgfCircle(SGFNode *node, int i, int j)
{
char text[3];
gg_snprintf(text, 3, "%c%c", j+'a', i+'a');
sgfAddProperty(node, "CR", text);
return node;
}
/*
* Place a square mark on the board at position (i, j).
*/
SGFNode *
sgfSquare(SGFNode *node, int i, int j)
{
return sgfMark(node, i, j); /* cgoban 1.9.5 does not understand SQ */
}
/*
* Place a (square) mark on the board at position (i, j).
*/
SGFNode *
sgfMark(SGFNode *node, int i, int j)
{
char text[3];
gg_snprintf(text, 3, "%c%c", j+'a', i+'a');
sgfAddProperty(node, "MA", text);
return node;
}
/*
* Start a new variant. Returns a pointer to the new node.
*/
SGFNode *
sgfStartVariant(SGFNode *node)
{
assert(node);
assert(node->parent);
while (node->next)
node = node->next;
node->next = sgfNewNode();
node->next->parent = node->parent;
return node->next;
}
/*
* Start a new variant as first child. Returns a pointer to the new node.
*/
SGFNode *
sgfStartVariantFirst(SGFNode *node)
{
SGFNode *old_first_child = node;
SGFNode *new_first_child = sgfNewNode();
assert(node);
assert(node->parent);
new_first_child->next = old_first_child;
new_first_child->parent = old_first_child->parent;
new_first_child->parent->child = new_first_child;
return new_first_child;
}
/*
* If no child exists, add one. Otherwise add a sibling to the
* existing children. Returns a pointer to the new node.
*/
SGFNode *
sgfAddChild(SGFNode *node)
{
SGFNode *new_node = sgfNewNode();
assert(node);
new_node->parent = node;
if (!node->child)
node->child = new_node;
else {
node = node->child;
while (node->next)
node = node->next;
node->next = new_node;
}
return new_node;
}
/*
* Write result of the game to the game tree.
*/
void
sgfWriteResult(SGFNode *node, float score, int overwrite)
{
char text[8];
char winner;
float s;
int dummy;
/* If not writing to the SGF file, skip everything and return now. */
if (!node)
return;
/* If not overwriting and there already is a result property, return. */
if (!overwrite)
if (sgfGetIntProperty(node, "RE", &dummy))
return;
if (score > 0.0) {
winner = 'W';
s = score;
}
else if (score < 0.0) {
winner = 'B';
s = -score;
}
else {
winner = '0';
s = 0;
}
if (winner == '0')
gg_snprintf(text, 8, "0");
else if (score < 1000.0 && score > -1000.0)
gg_snprintf(text, 8, "%c+%3.1f", winner, s);
else
gg_snprintf(text, 8, "%c+%c", winner, 'R');
sgfOverwriteProperty(node, "RE", text);
}
static void
sgf_write_header_reduced(SGFNode *root, int overwrite)
{
time_t curtime = time(NULL);
struct tm *loctime = localtime(&curtime);
char str[128];
int dummy;
gg_snprintf(str, 128, "%4.4i-%2.2i-%2.2i",
loctime->tm_year+1900, loctime->tm_mon+1, loctime->tm_mday);
if (overwrite || !sgfGetIntProperty(root, "DT", &dummy))
sgfOverwriteProperty(root, "DT", str);
if (overwrite || !sgfGetIntProperty(root, "AP", &dummy))
sgfOverwriteProperty(root, "AP", "GNU Go:"VERSION);
sgfOverwriteProperty(root, "FF", "4");
}
void
sgf_write_header(SGFNode *root, int overwrite, int seed, float komi,
int handicap, int level, int rules)
{
char str[128];
int dummy;
gg_snprintf(str, 128, "GNU Go %s Random Seed %d level %d",
VERSION, seed, level);
if (overwrite || !sgfGetIntProperty(root, "GN", &dummy))
sgfOverwriteProperty(root, "GN", str);
if (overwrite || !sgfGetIntProperty(root, "RU", &dummy))
sgfOverwriteProperty(root, "RU", rules ? "Chinese" : "Japanese");
sgfOverwritePropertyFloat(root, "KM", komi);
sgfOverwritePropertyInt(root, "HA", handicap);
sgf_write_header_reduced(root, overwrite);
}
/* ================================================================ */
/* Read SGF tree */
/* ================================================================ */
#define MAX_FILE_BUFFER 200000 /* buffer for reading SGF file. */
/*
* SGF grammar:
*
* Collection = GameTree { GameTree }
* GameTree = "(" Sequence { GameTree } ")"
* Sequence = Node { Node }
* Node = ";" { Property }
* Property = PropIdent PropValue { PropValue }
* PropIdent = UcLetter { UcLetter }
* PropValue = "[" CValueType "]"
* CValueType = (ValueType | Compose)
* ValueType = (None | Number | Real | Double | Color | SimpleText |
* Text | Point | Move | Stone)
*
* The above grammar has a number of simple properties which enables us
* to write a simpler parser:
* 1) There is never a need for backtracking
* 2) The only recursion is on gametree.
* 3) Tokens are only one character
*
* We will use a global state to keep track of the remaining input
* and a global char variable, `lookahead' to hold the next token.
* The function `nexttoken' skips whitespace and fills lookahead with
* the new token.
*/
static void parse_error(const char *msg, int arg);
static void nexttoken(void);
static void match(int expected);
static FILE *sgffile;
#define sgf_getch() (getc(sgffile))
static char *sgferr;
#ifdef TEST_SGFPARSER
static int sgferrarg;
#endif
static int sgferrpos;
static int lookahead;
/* ---------------------------------------------------------------- */
/* Parsing primitives */
/* ---------------------------------------------------------------- */
static void
parse_error(const char *msg, int arg)
{
fprintf(stderr, msg, arg);
fprintf(stderr, "\n");
exit(EXIT_FAILURE);
}
static void
nexttoken()
{
do
lookahead = sgf_getch();
while (isspace(lookahead));
}
static void
match(int expected)
{
if (lookahead != expected)
parse_error("expected: %c", expected);
else
nexttoken();
}
/* ---------------------------------------------------------------- */
/* The parser proper */
/* ---------------------------------------------------------------- */
static void
propident(char *buffer, int size)
{
if (lookahead == EOF || !isupper(lookahead))
parse_error("Expected an upper case letter.", 0);
while (lookahead != EOF && isalpha(lookahead)) {
if (isupper(lookahead) && size > 1) {
*buffer++ = lookahead;
size--;
}
nexttoken();
}
*buffer = '\0';
}
static void
propvalue(char *buffer, int size)
{
char *p = buffer;
match('[');
while (lookahead != ']' && lookahead != EOF) {
if (lookahead == '\\') {
lookahead = sgf_getch();
/* Follow the FF4 definition of backslash */
if (lookahead == '\r') {
lookahead = sgf_getch();
if (lookahead == '\n')
lookahead = sgf_getch();
}
else if (lookahead == '\n') {
lookahead = sgf_getch();
if (lookahead == '\r')
lookahead = sgf_getch();
}
}
if (size > 1) {
*p++ = lookahead;
size--;
}
lookahead = sgf_getch();
}
match(']');
/* Remove trailing whitespace. The double cast below is needed
* because "char" may be represented as a signed char, in which case
* characters between 128 and 255 would be negative and a direct
* cast to int would cause a negative value to be passed to isspace,
* possibly causing an assertion failure.
*/
--p;
while (p > buffer && isspace((int) (unsigned char) *p))
--p;
*++p = '\0';
}
static SGFProperty *
property(SGFNode *n, SGFProperty *last)
{
char name[3];
char buffer[4000];
propident(name, sizeof(name));
do {
propvalue(buffer, sizeof(buffer));
last = sgfMkProperty(name, buffer, n, last);
} while (lookahead == '[');
return last;
}
static void
node(SGFNode *n)
{
SGFProperty *last = NULL;
match(';');
while (lookahead != EOF && isupper(lookahead))
last = property(n, last);
}
static SGFNode *
sequence(SGFNode *n)
{
node(n);
while (lookahead == ';') {
SGFNode *new = sgfNewNode();
new->parent = n;
n->child = new;
n = new;
node(n);
}
return n;
}
static void
gametree(SGFNode **p, SGFNode *parent, int mode)
{
if (mode == STRICT_SGF)
match('(');
else
for (;;) {
if (lookahead == EOF) {
parse_error("Empty file?", 0);
break;
}
if (lookahead == '(') {
while (lookahead == '(')
nexttoken();
if (lookahead == ';')
break;
}
nexttoken();
}
/* The head is parsed */
{
SGFNode *head = sgfNewNode();
SGFNode *last;
head->parent = parent;
*p = head;
last = sequence(head);
p = &last->child;
while (lookahead == '(') {
gametree(p, last, STRICT_SGF);
p = &((*p)->next);
}
if (mode == STRICT_SGF)
match(')');
}
}
/*
* Fuseki readers
* Reads an SGF file for extract_fuseki in a compact way
*/
static void
gametreefuseki(SGFNode **p, SGFNode *parent, int mode,
int moves_per_game, int i)
{
if (mode == STRICT_SGF)
match('(');
else
for (;;) {
if (lookahead == EOF) {
parse_error("Empty file?", 0);
break;
}
if (lookahead == '(') {
while (lookahead == '(')
nexttoken();
if (lookahead == ';')
break;
}
nexttoken();
}
/* The head is parsed */
{
SGFNode *head = sgfNewNode();
SGFNode *last;
head->parent = parent;
*p = head;
last = sequence(head);
p = &last->child;
while (lookahead == '(') {
if (last->props
&& (last->props->name == SGFB || last->props->name == SGFW))
i++;
/* break after number_of_moves moves in SGF file */
if (i >= moves_per_game) {
last->child = NULL;
last->next = NULL;
break;
}
else {
gametreefuseki(p, last, mode, moves_per_game, i);
p = &((*p)->next);
}
}
if (mode == STRICT_SGF)
match(')');
}
}
SGFNode *
readsgffilefuseki(const char *filename, int moves_per_game)
{
SGFNode *root;
int tmpi = 0;
if (strcmp(filename, "-") == 0)
sgffile = stdin;
else
sgffile = fopen(filename, "r");
if (!sgffile)
return NULL;
nexttoken();
gametreefuseki(&root, NULL, LAX_SGF, moves_per_game, 0);
fclose(sgffile);
if (sgferr) {
fprintf(stderr, "Parse error: %s at position %d\n", sgferr, sgferrpos);
sgfFreeNode(root);
return NULL;
}
/* perform some simple checks on the file */
if (!sgfGetIntProperty(root, "GM", &tmpi)) {
if (VERBOSE_WARNINGS)
fprintf(stderr, "Couldn't find the game type (GM) attribute!\n");
}
else if (tmpi != 1) {
fprintf(stderr, "SGF file might be for game other than go: %d\n", tmpi);
fprintf(stderr, "Trying to load anyway.\n");
}
if (!sgfGetIntProperty(root, "FF", &tmpi)) {
if (VERBOSE_WARNINGS)
fprintf(stderr, "Can not determine SGF spec version (FF)!\n");
}
else if ((tmpi < 3 || tmpi > 4) && VERBOSE_WARNINGS)
fprintf(stderr, "Unsupported SGF spec version: %d\n", tmpi);
return root;
}
/*
* Wrapper around readsgf which reads from a file rather than a string.
* Returns NULL if file will not open, or some other parsing error.
* Filename "-" means read from stdin, and leave it open when done.
*/
SGFNode *
readsgffile(const char *filename)
{
SGFNode *root;
int tmpi = 0;
if (strcmp(filename, "-") == 0)
sgffile = stdin;
else
sgffile = fopen(filename, "r");
if (!sgffile)
return NULL;
nexttoken();
gametree(&root, NULL, LAX_SGF);
if (sgffile != stdin)
fclose(sgffile);
if (sgferr) {
fprintf(stderr, "Parse error: %s at position %d\n", sgferr, sgferrpos);
sgfFreeNode(root);
return NULL;
}
/* perform some simple checks on the file */
if (!sgfGetIntProperty(root, "GM", &tmpi)) {
if (VERBOSE_WARNINGS)
fprintf(stderr, "Couldn't find the game type (GM) attribute!\n");
}
else if (tmpi != 1) {
fprintf(stderr, "SGF file might be for game other than go: %d\n", tmpi);
fprintf(stderr, "Trying to load anyway.\n");
}
if (!sgfGetIntProperty(root, "FF", &tmpi)) {
if (VERBOSE_WARNINGS)
fprintf(stderr, "Can not determine SGF spec version (FF)!\n");
}
else if ((tmpi < 3 || tmpi > 4) && VERBOSE_WARNINGS)
fprintf(stderr, "Unsupported SGF spec version: %d\n", tmpi);
return root;
}
/* ================================================================ */
/* Write SGF tree */
/* ================================================================ */
#define OPTION_STRICT_FF4 0
static int sgf_column = 0;
static void
sgf_putc(int c, FILE *file)
{
if (c == '\n' && sgf_column == 0)
return;
fputc(c, file);
if (c == '\n')
sgf_column = 0;
else
sgf_column++;
if (c == ']' && sgf_column > 60) {
fputc('\n', file);
sgf_column = 0;
}
}
static void
sgf_puts(const char *s, FILE *file)
{
for (; *s; s++) {
if (*s == '[' || *s == ']' || *s == '\\') {
fputc('\\', file);
sgf_column++;
}
fputc((int) *s, file);
sgf_column++;
}
}
/* Print all properties with the given name in a node to file and mark
* them as printed.
*
* If is_comment is 1, multiple properties are concatenated with a
* newline. I.e. we write
*
* C[comment1
* comment2]
*
* instead of
*
* C[comment1][comment2]
*
* Most other property types should be written in the latter style.
*/
static void
sgf_print_name(FILE *file, short name)
{
sgf_putc(name & 0xff, file);
if (name >> 8 != ' ')
sgf_putc(name >> 8, file);
}
static void
sgf_print_property(FILE *file, SGFNode *node, short name, int is_comment)
{
int n = 0;
SGFProperty *prop;
for (prop = node->props; prop; prop = prop->next) {
if (prop->name == name) {
prop->name |= 0x20; /* Indicate already printed. */
if (n == 0) {
sgf_print_name(file, name);
sgf_putc('[', file);
}
else if (is_comment)
sgf_putc('\n', file);
else {
sgf_putc(']', file);
sgf_putc('[', file);
}
sgf_puts(prop->value, file);
n++;
}
}
if (n > 0)
sgf_putc(']', file);
/* Add a newline after certain properties. */
if (name == SGFAB || name == SGFAW || name == SGFAE || (is_comment && n > 1))
sgf_putc('\n', file);
}
/*
* Print all remaining unprinted property values at node N to file.
*/
static void
sgfPrintRemainingProperties(FILE *file, SGFNode *node)
{
SGFProperty *prop;
for (prop = node->props; prop; prop = prop->next)
if (!(prop->name & 0x20))
sgf_print_property(file, node, prop->name, 0);
}
/*
* Print the property values of NAME at node N and mark it as printed.
*/
static void
sgfPrintCharProperty(FILE *file, SGFNode *node, const char *name)
{
short nam = name[0] | name[1] << 8;
sgf_print_property(file, node, nam, 0);
}
/*
* Print comments from Node node.
*
* NOTE: cgoban does not print "C[comment1][comment2]" and I don't know
* what the sgfspec says.
*/
static void
sgfPrintCommentProperty(FILE *file, SGFNode *node, const char *name)
{
short nam = name[0] | name[1] << 8;
sgf_print_property(file, node, nam, 1);
}
static void
unparse_node(FILE *file, SGFNode *node)
{
sgf_putc(';', file);
sgfPrintCharProperty(file, node, "B ");
sgfPrintCharProperty(file, node, "W ");
sgfPrintCommentProperty(file, node, "N ");
sgfPrintCommentProperty(file, node, "C ");
sgfPrintRemainingProperties(file, node);
}
static void
unparse_root(FILE *file, SGFNode *node)
{
sgf_putc(';', file);
if (sgfHasProperty(node, "GM"))
sgfPrintCharProperty(file, node, "GM");
else {
fputs("GM[1]", file);
sgf_column += 5;
}
sgfPrintCharProperty(file, node, "FF");
sgf_putc('\n', file);
sgfPrintCharProperty(file, node, "SZ");
sgf_putc('\n', file);
sgfPrintCharProperty(file, node, "GN");
sgf_putc('\n', file);
sgfPrintCharProperty(file, node, "DT");
sgf_putc('\n', file);
sgfPrintCommentProperty(file, node, "PB");
sgfPrintCommentProperty(file, node, "BR");
sgf_putc('\n', file);
sgfPrintCommentProperty(file, node, "PW");
sgfPrintCommentProperty(file, node, "WR");
sgf_putc('\n', file);
sgfPrintCommentProperty(file, node, "N ");
sgfPrintCommentProperty(file, node, "C ");
sgfPrintRemainingProperties(file, node);
sgf_putc('\n', file);
}
/*
* p->child is the next move.
* p->next is the next variation
*/
static void
unparse_game(FILE *file, SGFNode *node, int root)
{
if (!root)
sgf_putc('\n', file);
sgf_putc('(', file);
if (root)
unparse_root(file, node);
else
unparse_node(file, node);
node = node->child;
while (node != NULL && node->next == NULL) {
unparse_node(file, node);
node = node->child;
}
while (node != NULL) {
unparse_game(file, node, 0);
node = node->next;
}
sgf_putc(')', file);
if (root)
sgf_putc('\n', file);
}
/* Printed properties are marked by adding the 0x20 bit to the
* property name (changing an upper case letter to lower case). This
* function removes this mark so that we can print the property next
* time too. It recurses to all properties in the linked list.
*/
static void
restore_property(SGFProperty *prop)
{
if (prop) {
restore_property(prop->next);
prop->name &= ~0x20;
}
}
/* When called with the tree root, recurses to all properties in the
* tree and removes all print marks.
*/
static void
restore_node(SGFNode *node)
{
if (node) {
restore_property(node->props);
restore_node(node->child);
restore_node(node->next);
}
}
/*
* Opens filename and writes the game stored in the sgf structure.
*/
int
writesgf(SGFNode *root, const char *filename)
{
FILE *outfile;
if (strcmp(filename, "-") == 0)
outfile = stdout;
else
outfile = fopen(filename, "w");
if (!outfile) {
fprintf(stderr, "Can not open %s\n", filename);
return 0;
}
sgf_write_header_reduced(root, 0);
sgf_column = 0;
unparse_game(outfile, root, 1);
if (outfile != stdout)
fclose(outfile);
/* Remove "printed" marks so that the tree can be written multiple
* times.
*/
restore_node(root);
return 1;
}
#ifdef TEST_SGFPARSER
int
main()
{
static char buffer[25000];
static char output[25000];
SGFNode *game;
sgffile = stdin;
nexttoken();
gametree(&game, LAX_SGF);
if (sgferr) {
fprintf(stderr, "Parse error:");
fprintf(stderr, sgferr, sgferrarg);
fprintf(stderr, " at position %d\n", sgferrpos);
}
else {
unparse_game(stdin, game, 1);
write(1, output, outputp - output);
}
}
#endif
/*
* Local Variables:
* tab-width: 8
* c-basic-offset: 2
* End:
*/