[SOLVED] CS chain /*

/*
Notation program
@(#)notation.c3.9 (C) Henry Thomas Release 3 Dated 12/10/91
*/
/* Programme danalyse de notation echiquienne
Copyright (C) 1990 Henry Thomas
Nom: notation
Auteur: Henry Thomas
Date: 27/11/90
/*
This file is part of NOTATION program.

NOTATION 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; either version 1, or (at your option)
any later version.

NOTATION 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 for more details.

You should have received a copy of the GNU General Public License
along with NOTATION; see the file COPYING.If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.*/

/* data part – */

/* les tableaux suivants sont les tables de transcription de notation
selon les langages
*/
#ifdef __STDC__
#include
#endif
#include
#include
#include

#include chesstype.h
#include notation.h
#include drivers.h
#include lexer.h

extern void close_files();

char * version_string =
@(#)notation.c3.9 (C) Henry Thomas. Release 3 Dated 12/10/91;

static char * keywords[]= {
@startplay , @clearboard , @showboard ,
@whitesmove, @blacksmove, @configwhite, @configblack ,
@default ,
/* these are keywords with arguments */
@title, @subtitle, @score, @language,
/* special keyword */
@special,
/* null and final keyword */
@null
};

int configuring = FALSE ;
int configside = 0 ;

static char * t_language[] = {
french, english, italian, spanish, german, dutch,
czech,hungarian,polish, romanian, FIDE
};

static int in_language = DEFAULT_INPUT_LANGUAGE ;
static int out_language = DEFAULT_OUTPUT_LANGUAGE ;

static char c_language[NBLANGUAGES][7] = {
/* french*/{ @ ,R , D , T , F , C , P },
/* english */{ @ ,K , Q , R , B , N , P },
/* italian */{ @ ,R , D , T , A , C , P },
/* spanish */{ @ ,R , D , T , A , C , P },
/* german*/{ @ ,K , D , T , L , S , B },
/* dutch */{ @ ,K , D , T , L , P , O },
/* czech */{ @ ,K , D , V , S , J , P },
/* hungarian */{ @ ,K , V , B , F , H , G },
/* polish*/{ @ ,K , H , W , G , S , P },
/* romanian*/{ @ ,R , D , T , N , C , P },
/* FIDE*/{ @ ,K , D , T , S , N , P }
/* UNIMPLEMENTED */
/* user_def*//*{ @ ,X , X , X , X , X , X }*/
/* russian not implemented : ASCII russian is an oxymoron */
/* russian *//*{ @ ,K , F , D , C , K , P }*/
};

/* input translation table */
char *in_table;

char *c_roque[] = { O-O , O-O-O , o-o , o-o-o , 0-0 , 0-0-0 };

/* various notations for en passant */
#define N_EP 2
char * c_en_passant[] = { ep , e.p. } ;

/* notation for catch */
char c_prise =x;

/* various comments */
char * c_comments[] = { + , ++ ,
? , ??, !, !!, !?, ?!,
mate, draw };

/* movement tables */
/* move only */
/* white pawn, move */
#define NB_M_PAWN_MOVE_WD 2
static int m_pawn_move_wd [][2] = {
{ 1, 0}, {2, 0}
};

/* black pawn, move */
#define NB_M_PAWN_MOVE_BD 2
static int m_pawn_move_bd [][2] = {
{-1, 0}, {-2, 0}
};

/* TRICK = we have added the catching move at the end of
the non catching ones; so in check_depl, we try first
the non catching one and then the catching one.
So, even if catching (x) is non indicated in the input,
we succeed in guessing the move
*/
/* white pawn, move */
/*#define NB_M_PAWN_WD 2*/
#define NB_M_PAWN_WD 4
static int m_pawn_wd [][2] = {
{ 1, 0}, {2, 0},
/* catch */
{ 1, 1}, { 1,-1}
};

/* white pawn, catch */
#define NB_M_PAWN_WX 2
static int m_pawn_wx [][2] = {
{ 1, 1}, { 1,-1}
};

/* black pawn, move */
/*#define NB_M_PAWN_BD 2*/
#define NB_M_PAWN_BD 4
static int m_pawn_bd [][2] = {
{-1, 0}, {-2, 0},
/* catch */
{-1, 1}, {-1,-1}
};

/* black pawn, catch */
#define NB_M_PAWN_BX 2
static int m_pawn_bx [][2] = {
{-1, 1}, {-1,-1}
};

#define NB_M_KNIGHT8
static int m_knight[][2] = {
{ 2, 1}, { 2,-1}, {-2, 1}, {-2,-1},
{ 1, 2}, { 1,-2}, {-1, 2}, {-1,-2}
};

#define NB_M_BISHOP 28
static int m_bishop[][2] = {
{ 7, 7},{6, 6}, { 5, 5}, { 4, 4}, { 3, 3}, { 2, 2}, { 1, 1},
{ 7,-7}, { 6,-6}, { 5,-5}, { 4,-4}, { 3,-3}, { 2,-2}, { 1,-1},
{-7,-7}, {-6,-6}, {-5,-5}, {-4,-4}, {-3,-3}, {-2,-2}, {-1,-1},
{-7, 7}, {-6, 6}, {-5, 5}, {-4, 4}, {-3, 3}, {-2, 2}, {-1, 1}
};

#define NB_M_ROOK 28
static int m_rook[][2] = {
{ 7, 0}, { 6, 0}, { 5, 0}, { 4, 0}, { 3, 0}, { 2, 0}, { 1, 0},
{-7, 0}, {-6, 0}, {-5, 0}, {-4, 0}, {-3, 0}, {-2, 0}, {-1, 0},
{ 0, 7}, { 0, 6}, { 0, 5}, { 0, 4}, { 0, 3}, { 0, 2}, { 0, 1},
{ 0,-7}, { 0,-6}, { 0,-5}, { 0,-4}, { 0,-3}, { 0,-2}, { 0,-1}
};

#define NB_M_QUEEN 56
static int m_queen[][2] = {
{ 7, 7},{6, 6}, { 5, 5}, { 4, 4}, { 3, 3}, { 2, 2}, { 1, 1},
{ 7,-7}, { 6,-6}, { 5,-5}, { 4,-4}, { 3,-3}, { 2,-2}, { 1,-1},
{-7,-7}, {-6,-6}, {-5,-5}, {-4,-4}, {-3,-3}, {-2,-2}, {-1,-1},
{-7, 7}, {-6, 6}, {-5, 5}, {-4, 4}, {-3, 3}, {-2, 2}, {-1, 1},
{ 7, 0}, { 6, 0}, { 5, 0}, { 4, 0}, { 3, 0}, { 2, 0}, { 1, 0},
{-7, 0}, {-6, 0}, {-5, 0}, {-4, 0}, {-3, 0}, {-2, 0}, {-1, 0},
{ 0, 7}, { 0, 6}, { 0, 5}, { 0, 4}, { 0, 3}, { 0, 2}, { 0, 1},
{ 0,-7}, { 0,-6}, { 0,-5}, { 0,-4}, { 0,-3}, { 0,-2}, { 0,-1}
};

#define NB_M_KING 8
static int m_king[][2] = {
{ 1, 1}, { 1, 0}, { 1,-1},
{-1, 1}, {-1, 0}, {-1,-1},
{ 0, 1}, { 0, -1}
};

/* I/O */
FILE * infile ;
FILE * fhelp;

static char * t_output[] =
{ ascii, postscript, tex, roff, xchess, gnu };

/* stack used for variation */

/* stack element */
typedef struct {
depl * d;
game * b;

/* we dont stack drivers, but only to variables */
int d1,d2; /* iswhiteturn and interrupt */
} stack_elt ;

/* size of the stack
0 = ordinary play
1 = level 1 variation
2 = level 2 variation
3 = level 3 variation
*/
#define VARIATION_MAX 3

/* the stack itself */
static stack_elt stack[VARIATION_MAX];

/* top of the stack */
/* > explicit in dr->variation */

/* – automata definitions */
/* table for syntaxic analysis of move */

#define FINAL10
#define TML FINAL /* terminal state */
#define NBETAT 11
#define NBCLAS 8

/* successor of state */
static int transit[NBETAT][NBCLAS] = {
/* P a-h 1-8 x = ? */
/*(0 1 2 3 4 5 6 7)*/
{1,2, -1, -1, -1, -1, -1, -1 }, /* etat0 */
{ -1,2, -1, -1,4, -1, -1, -1 }, /* etat1 */
{ -1,6,3,4,4,8,TML,TML }, /* etat2 */
{ -1,6, -1,4,4,8,TML,TML }, /* etat3 */
{5,6, -1, -1, -1, -1, -1, -1 }, /* etat4 */
{ -1,6, -1, -1, -1, -1, -1, -1 }, /* etat5 */
{ -1, -1,7, -1, -1, -1, -1, -1 }, /* etat6 */
{ -1, -1, -1, -1, -1,8,TML,TML }, /* etat7 */
{9, -1, -1, -1, -1, -1,TML, -1 }, /* etat8 */
{ -1, -1, -1, -1, -1, -1,TML,TML }, /* etat9 */
{ -1, -1, -1, -1, -1, -1, -1, -1 }/* etat 10 == terminal */
};

/* actions to do */
static int action[NBETAT][NBCLAS] = {
/* P a-h 1-8 x = ? */
{1,2, -1, -1, -1, -1, -1, -1 }, /* etat0 */
{ -1,2, -1, -1, 10, -1, -1, -1 }, /* etat1 */
{ -1, 13,3,4,5, 14,6,7 }, /* etat2 */
{ -1, 13, -1,4,5, 14,6,7 }, /* etat3 */
{1,2, -1, -1, -1, -1, -1, -1 }, /* etat4 */
{ -1,2, -1, -1, -1, -1, -1, -1 }, /* etat5 */
{ -1, -1,3, -1, -1, -1, -1, -1 }, /* etat6 */
{ -1, -1, -1, -1, -1, 14,8,9 }, /* etat7 */
{ 15, -1, -1, -1, -1, -1, 17, -1 }, /* etat8 */
{ -1, -1, -1, -1, -1, -1, 17, 17 }, /* etat9 */
{ -1, -1, -1, -1, -1, -1, -1, -1 }/* etat 10 */
};

/* the complete play */
play * theplay ;

/* current game
the name tos means top of stack
*/
static game * tos = GULL ;

/* variable holding current move */
static depl * m = MULL ;

int alternate_moves[10][2]; /* table of alternate moves, guessed by
the move generator: guess depl
*/

/* the output driver */
static format * dr;

static int driver; /* driver type, ie gnu, ascii */

static int movecount;

/* current move, used by the parser */
static int curpiece,curcol,curlig ;
static int curdigit, curmove;

/* booleen derreur */
int error_flag = FALSE;

/* move to display board */
static int count = 0 ;

static int move_to_display[NB_MOVE_TO_DISP] ;
static int nb_move_to_dsp = 0;
static int stop_at_display = FALSE;

/* short and long form comment table */
char * com_short[] = {
#define CHESSSYMB(LET,LASC,SASC,TEX,PS,ENG,FRA) SASC,
#include chesssymb.def

};
#undef CHESSSYMB

char * com_long[] = {
#define CHESSSYMB(LET,LASC,SASC,TEX,PS,ENG,FRA) LASC,
#include chesssymb.def

};
#undef CHESSSYMB

#define setboard(A,I,J,P,C){ (A)->board[(I)][(J)] = (P) ;
(A)->color[(I)][(J)] = (C); }
#define clsboard(A,I,J) { (A)->board[(I)][(J)] = VOID ;
(A)->color[(I)][(J)] = VOID ;}

/* code part */

#ifdef __STDC__
static int ispiece(char c)
#else
static int ispiece(c)
char c;
#endif
{
register int i;

for ( i = 0 ; (i < NUMPIECES) && (c != in_table[i]) ; i++ ) ;/*(void) fprintf(stdout, “piece %d %c
” , i , c);*/return(i board[i][j] = VOID;
g->color[i][j] = VOID;
}
}

#ifdef __STDC__
game * new_board(void)
#else
game * new_board()
#endif
{
game * tmp;
int i;

tmp = (game *) malloc (sizeof(game));
ALLOCP(tmp);
for (i=0; i < ((sizeof (game))/ sizeof (int)) ; i++)((int *) tmp)[i] = 0;return(tmp);}#ifdef __STDC__game * copy_board(game *from, game *to)#elsegame * copy_board(from, to) game * from; game * to;#endif{int i; for (i=0; i < ((sizeof (game))/ sizeof (int)) ; i++)((int *) to)[i] =((int *) from)[i] ;return(to);}#ifdef __STDC__void init_board(game *tgm)#elsevoid init_board(tgm)game * tgm;#endif{register int i,j;clear_board(tgm);for (i=1; i< 9 ; i=i+7) {tgm->board[i][1]= tgm->board[i][8] = ROOK ;
tgm->board[i][2]= tgm->board[i][7] = KNIGHT ;
tgm->board[i][3]= tgm->board[i][6] = BISHOP ;
tgm->board[i][4]= QUEEN;
tgm->board[i][5]= KING;
}
for (i=2; i< 8 ; i=i+5) for (j=1; j <=8 ; j++)tgm->board[i][j] = PAWN;

for (i=1; i <=2; i++)for (j=1; j <=8 ; j++) {tgm->color[i][j] = WHITE;
tgm->color[i+6][j] = BLACK ;
}
}

#ifdef __STDC__
depl * new_move(void)
#else
depl * new_move()
#endif
{
depl * tmp;
int i;
static int counter = 0;

tmp = (depl *) malloc (sizeof(depl *));
ALLOCP(tmp);
for (i=0; i < ((sizeof (depl))/ sizeof (int)) ; i++)((int *) tmp)[i] = 0;tmp->uid = ++counter;
tmp->whiteturn = FALSE;
tmp->move = 0;
return(tmp);
}

#ifdef __STDC__
void init_move(depl *m)
#else
void init_move(m)
depl *m;
#endif
{
m->move= 1 ;
m->whiteturn = TRUE ;
}

#ifdef __STDC__
depl * copy_move(depl *from,depl *to)
#else
depl * copy_move(from,to)
depl * from;
depl * to ;
#endif
{
int i;

for (i=0; i < ((sizeof (depl))/ sizeof (int)) ; i++)((int *) to)[i] = ((int *) from)[i];return(to);}/* add a new move as successor to the move m */#ifdef __STDC__depl * add_trailing_move(depl *mo)#elsedepl * add_trailing_move(mo) depl * mo;#endif{mo->next = new_move();

mo->next->prev = mo;
mo->next->next = (depl *) NULL;
mo->next->sub= (depl *) NULL;

mo->next->whiteturn = !( m->whiteturn ) ;
mo->next->move = mo->move;
if ( mo->next->whiteturn) {
mo->next->move++;
}

return(mo->next);
}

#ifdef __STDC__
static depl * add_variation(depl *mo)
#else
static depl * add_variation(mo)
depl * mo;
#endif
{
depl *ip ; /* insertion point */

ip = mo ;
while (ip->sub != (depl *) NULL )
ip = ip->sub ;

ip->sub = new_move();

ip->sub->prev = mo;
ip->sub->next = (depl *) NULL;
ip->sub->sub= (depl *) NULL;

/* as we have a fictif element heading our list,
( generated by add_trailing_move() )
we have to go back in the numbering */
ip->sub->whiteturn =mo->prev->whiteturn;
ip->sub->move = mo->prev->move ;

return(ip->sub);
}

#ifdef __STDC__
static void free_move_list(depl *d)
#else
static void free_move_list(d)
depl * d;
#endif
{

if (d->next != (depl *) NULL) {
free_move_list(d->next);
free(d->next);
d->next = (depl *) NULL;
}
if (d->sub != (depl *) NULL) {
free_move_list(d->sub);
free(d->sub);
d->sub = (depl *) NULL;
}
}

/* procedure upadate borad g with move m */
#ifdef __STDC__
void do_move(game *g,depl *m)
#else
void do_move(g,m)
game *g;
depl *m;
#endif
{
switch (m->type) {
case MOVE:
setboard(g,m->tolig,m->tocol,m->piece,CURCOLOR(m)) ;
clsboard(g,m->fromlig,m->fromcol) ;
break;
case PRISE:
setboard(g,m->tolig,m->tocol,m->piece,CURCOLOR(m)) ;
clsboard(g,m->fromlig,m->fromcol);
break;
case GRANDROQUE:
if (m->whiteturn)
m->fromlig = 1;
else
m->fromlig = 8;
setboard(g,m->fromlig,3,KING,CURCOLOR(m)) ;
setboard(g,m->fromlig,4,ROOK,CURCOLOR(m)) ;
clsboard(g,m->fromlig,1) ;
clsboard(g,m->fromlig,5) ;
break;
case PETITROQUE:
if (m->whiteturn)
m->fromlig = 1;
else
m->fromlig = 8;
setboard(g,m->fromlig,7,KING,CURCOLOR(m)) ;
setboard(g,m->fromlig,6,ROOK,CURCOLOR(m)) ;
clsboard(g,m->fromlig,5) ;
clsboard(g,m->fromlig,8) ;
break;
case EN_PASSANT:
setboard(g,m->tolig,m->tocol,m->piece,CURCOLOR(m)) ;
clsboard(g,m->tolig,m->fromcol) ;
clsboard(g,m->fromlig,m->fromcol) ;
break;
case PROMOTION:
setboard(g,m->tolig,m->tocol,m->piece,CURCOLOR(m)) ;
clsboard(g,m->fromlig,m->fromcol);
break;
case PROM_ET_PRISE:
setboard(g,m->tolig,m->tocol,m->piece,CURCOLOR(m)) ;
clsboard(g,m->fromlig,m->fromcol);
break;
default:
fprintf(stderr,
Unable to do move: unknown move type
);
break;
}
}

/* this procedure undo the effect of move m on the board g */
#ifdef __STDC__
void undo_move(game *g,depl *m)
#else
void undo_move(g,m)
game *g;
depl *m;
#endif
{
switch (m->type) {
case MOVE:
clsboard(g,m->tolig,m->tocol) ;
setboard(g,m->fromlig,m->fromcol,m->piece,CURCOLOR(m)) ;
break;
case PRISE:
setboard(g,m->tolig,m->tocol,m->prise,OPPCOLOR(m)) ;
setboard(g,m->fromlig,m->fromcol,m->piece,CURCOLOR(m)) ;
break;
case GRANDROQUE:
if (m->whiteturn)
m->fromlig = 1;
else
m->fromlig = 8;
clsboard(g,m->fromlig,3) ;
clsboard(g,m->fromlig,4) ;
setboard(g,m->fromlig,5,KING,CURCOLOR(m)) ;
setboard(g,m->fromlig,1,ROOK,CURCOLOR(m)) ;
break;
case PETITROQUE:
if (m->whiteturn)
m->fromlig = 1;
else
m->fromlig = 8;
clsboard(g,m->fromlig,6) ;
clsboard(g,m->fromlig,7) ;
setboard(g,m->fromlig,5,KING,CURCOLOR(m)) ;
setboard(g,m->fromlig,8,ROOK,CURCOLOR(m)) ;
break;
case EN_PASSANT:
clsboard(g,m->tolig,m->tocol) ;
setboard(g,m->tolig,m->fromcol,PAWN,OPPCOLOR(m)) ;
setboard(g,m->fromlig,m->fromcol,m->piece,CURCOLOR(m)) ;
break;
case PROMOTION:
clsboard(g,m->tolig,m->tocol);
setboard(g,m->fromlig,m->fromcol,PAWN,CURCOLOR(m)) ;
break;
case PROM_ET_PRISE:
setboard(g,m->tolig,m->tocol,m->prise,OPPCOLOR(m)) ;
setboard(g,m->fromlig,m->fromcol,PAWN,CURCOLOR(m)) ;
break;
default:
fprintf(stderr,
Unable to undo move: unknown move type
);
break;
}
}

/* variation procedures == stack manipulation */

#ifdef __STDC__
void enter_variation(void)
#else
void enter_variation()
#endif
{
int l;

l = dr->variation ;

if (l >= VARIATION_MAX) {
error((stderr,
Maximum imbricated variation is %d
,VARIATION_MAX));
} else {
/* save current line/variation */
stack[l].d = m;
stack[l].b = tos;
stack[l].d1 = dr->iswhiteturn;
stack[l].d2 = dr->interrupt = TRUE ;
/* create new */
tos = new_board();
(void) copy_board(stack[l].b, tos);

/* A variation FOLLOWS the main line
so we need to backtrack one move
*/
m = add_variation(stack[l].d);
undo_move(tos,stack[l].d);

/* set variables */
l++;
dr->variation = l;

output_variation(dr,VARIATION_IN);
}
}

#ifdef __STDC__
void exit_variation(void)
#else
void exit_variation()
#endif
{
int l ;

l = dr->variation ;

if (l == 0) {
error((stderr,
You cannot exit from the main line (a variation level error?)
));
} else {
output_variation(dr,VARIATION_OUT);

l;
free(m);
m = stack[l].d ;
tos = stack[l].b ;

dr->iswhiteturn = stack[l].d1 ;
dr->interrupt = stack[l].d2 ;
dr->variation = l;
}
}

/* semantic evaluation of move */
/* check ifposition lies within the board
*/
#ifdef __STDC__
int in_board(int l,int c)
#else
int in_board(l,c)
int l,c;
#endif
{
return ((c >= 1) && (c <= 8) && (l >= 1) && (l <= 8));}/* check that the path from pos1 to pos2 is free */#ifdef __STDC__int path_free(int l1,int c1,int l2,int c2)#elseint path_free(l1, c1, l2, c2)int l1,c1, l2, c2;#endif{int li = 1 ;int ci = 1 ;int lig, col;li = SIGN(l2-l1);ci = SIGN(c2-c1);if ( c1 == c2 ) {col = c1;for (lig = l1 +li; lig != l2 ; lig +=li)if (tos->board[lig][col] != VOID)
return (FALSE);
return(TRUE);
}

if ( l1 == l2) {
lig = l1 ;
for (col = c1 + ci; col != c2 ; col +=ci)
if (tos->board[lig][col] != VOID)
return (FALSE);
return(TRUE);
}

for (lig = l1+li,col =c1+ci; (lig!=l2) && (col!=c2); lig+=li, col+= ci)
if (tos->board[lig][col] != VOID) {
return (FALSE);
}
return(TRUE);
}

/* check roque is possible */
#ifdef __STDC__
int check_roque(void)
#else
int check_roque()
#endif
{
int lig, col ;

if (m->whiteturn)
lig = 1 ;
else
lig =8;
if (m->type == GRANDROQUE)
for (col = 2; col < 5 ; col++)if (tos->board[lig][col] != VOID)
return(FALSE);
if (m->type == PETITROQUE)
for (col = 6; col < 7 ; col++)if (tos->board[lig][col] != VOID)
return(FALSE);
return(TRUE);
}

/* check or guess where a given piece come */
#ifdef __STDC__
int guess_piece(void)
#else
int guess_piece()
#endif
{
return(tos->board[m->fromlig][m->fromcol]);
}

/* try to guess the move low-level function
it returns in the parms the coordinates of a possible move
it returns as value the number of possible move
*/
#ifdef __STDC__
int guess_depl(int nb, int tab[][2],
int * pl1, int * pc1, int l2, int c2, int path)
#else
int guess_depl(nb, tab, pl1, pc1, l2,c2,path)
int nb;
int tab[10][2];
int *pl1, *pc1;
int l2,c2;
int path; /* tell if we have to check for a free path
used for en passant */
#endif
{
int i, c, l;
int count = 0;

for (i=0; i< nb; i++ ) {l = l2 – tab[i][0];c = c2 – tab[i][1];if (in_board(l,c))if ((tos->board[l][c] == m->piece) &&
(tos->color[l][c] == CURCOLOR(m)) &&
( !path || (path && path_free(l,c, l2, c2))) &&
( ((*pl1) == 0) || ((*pl1) == l) ) &&
( ((*pc1) == 0) || ((*pc1) == c) ) )
{
alternate_moves[count][0] = l;
alternate_moves[count][1] = c;
count++;
}
}
alternate_moves[count][0] = alternate_moves[count][1] = 0;
if (count > 0) {
/* we return the first entry because the last entry, in the case of pawn,
movement, might be a catching move, even it a non-catching, more
probable, is present
*/
*pl1 = alternate_moves[0][0];
*pc1 = alternate_moves[0][1];
}
return(count);
}

/* check for ambiguity in a move
used in output function: the piece had been already moved and
if we guess another move, there is an ambiguity
*/
#ifdef __STDC__
int ambiguity(depl *d, int *amline, int *amcols)
#else
int ambiguity(d, amline, amcols )
depl *d ;
int * amline;
int *amcols;
#endif
{
int l1 = 0 ;
int c1 = 0 ;
int r = 0;
int frompiece = d->piece;
int l2 = d->tolig;
int c2 = d->tocol ;
int i;

undo_move(tos,m);

switch(frompiece) {
case PAWN:
if (m->type == PRISE) {
if (m->whiteturn)
r = guess_depl(NB_M_PAWN_WX, m_pawn_wx, &l1,&c1, l2,c2, FALSE);
else
r = guess_depl(NB_M_PAWN_BX, m_pawn_bx, &l1,&c1, l2,c2, FALSE);
} else {
if (m->whiteturn)
r = guess_depl(NB_M_PAWN_MOVE_WD,m_pawn_move_wd,&l1,&c1, l2,c2, FALSE);
else
r = guess_depl(NB_M_PAWN_MOVE_BD,m_pawn_move_bd,&l1,&c1,l2,c2, FALSE);
}
break;
case KNIGHT:
r = guess_depl(NB_M_KNIGHT, m_knight, &l1,&c1, l2,c2, FALSE);
break;
case BISHOP:
r = guess_depl(NB_M_BISHOP, m_bishop, &l1,&c1, l2,c2, TRUE);
break;
case ROOK:
r = guess_depl(NB_M_ROOK, m_rook, &l1,&c1, l2,c2, TRUE);
break;
case QUEEN:
r = guess_depl(NB_M_QUEEN,m_queen,&l1,&c1, l2,c2, TRUE);
break;
case KING:
r = guess_depl(NB_M_KING, m_king, &l1,&c1, l2,c2, TRUE);
break;
default:
break;
}
do_move(tos,m);

if (r > 1) {
/* we have an ambiguity, we use alternate_moves to resolve it:
we look through that table to find identical lines: if so,
we signal that the column determines move;
we then do the same with columns
*/
*amline = TRUE ;
*amcols = TRUE ;
for (i= 1; i < r ; i++) {if (alternate_moves[i][0] != alternate_moves[0][0])*amline = FALSE;if (alternate_moves[i][1] != alternate_moves[0][1])*amcols = FALSE;}}return( (r > 1) );
}

#ifdef __STDC__
int check_move(depl *m)
#else
int check_move(m)
depl * m;
#endif
{
int l1,c1,l2,c2;
int tmp; /* tmp boolean */

l1 = m->fromlig;
c1 = m->fromcol;
l2 = m->tolig;
c2 = m->tocol;

if ((m->type == GRANDROQUE) || (m->type == PETITROQUE))
return(check_roque());

if ((tos->board[l1][c1] != m->piece)||
(tos->color[l1][c1] != CURCOLOR(m))){
fprintf(stderr,Problem: piece should be %c
,in_table[tos->board[l1][c1]]);
if (m->whiteturn)
error ((stderr,
Originating position and piece not coherent for White move %d
,m->move));
else
error ((stderr,
Originating position and piece not coherent for Black move %d
,m->move));
return(FALSE);
}

/* if prise === FALSE, we must not take a piece */
if (tos->board[l2][c2] != VOID
&& (m->type != PRISE) && (m->type != PROM_ET_PRISE)) {
(void) fprintf(stderr,catching not indicated at move %d.
,m->move);
return(FALSE);
}

/* prendre une de ses propres pieces */
if (tos->color[l2][c2] == tos->color[l1][c1] && m->prise) {
(void) fprintf(stderr,attempt to catch same color piece at move %d.
,
m->move);
return(FALSE);
}

/* we check if the move is a possible one for the piece
*/

switch(m->piece) {
case PAWN:
if (m->prise) {
if (m->whiteturn)
tmp = guess_depl(NB_M_PAWN_WX, m_pawn_wx, &l1,&c1, l2,c2, FALSE);
else
tmp = guess_depl(NB_M_PAWN_BX, m_pawn_bx, &l1,&c1, l2,c2, FALSE);
} else {
if (m->whiteturn)
tmp = guess_depl(NB_M_PAWN_WD, m_pawn_wd, &l1,&c1, l2,c2, FALSE);
else
tmp = guess_depl(NB_M_PAWN_BD, m_pawn_bd, &l1,&c1, l2,c2, FALSE);
}
/* is it a prise en passant */
if ((c1 != c2) && (tos->board[l2][c2] == VOID)
&& (tos->board[l1][c2] == PAWN)) {
m->type = EN_PASSANT ;
/* we must perform here the en passant test */
tos->board[l1][c2] = VOID ;
tos->color[l1][c2] = VOID ;
tmp = TRUE;
}
return(tmp);
break;
case KNIGHT:
return(guess_depl(NB_M_KNIGHT, m_knight, &l1,&c1, l2,c2, FALSE));
break;
case BISHOP:
return(guess_depl(NB_M_BISHOP, m_bishop, &l1,&c1, l2,c2, TRUE));
break;
case ROOK:
return(guess_depl(NB_M_ROOK, m_rook, &l1,&c1, l2,c2, TRUE));
break;
case QUEEN:
return(guess_depl(NB_M_QUEEN,m_queen,&l1,&c1, l2,c2, TRUE));
break;
case KING:
return(guess_depl(NB_M_KING, m_king, &l1,&c1, l2,c2, TRUE));
break;
default:
break;
}

return(TRUE);
}

/* try to guess the move used for shortened notation
*/
#ifdef __STDC__
int guess_move(void)
#else
int guess_move()
#endif
{
int l1,c1,l2,c2;

if ((m->type == GRANDROQUE) || (m->type == PETITROQUE))
return(TRUE);

l1 = m->fromlig ;
c1 = m->fromcol ;
l2 = m->tolig;
c2 = m->tocol;

switch(m->piece) {
case PAWN:
if (m->prise) {
if (m->whiteturn)
(void) guess_depl(NB_M_PAWN_WX, m_pawn_wx, &l1,&c1, l2,c2, FALSE);
else
(void) guess_depl(NB_M_PAWN_BX, m_pawn_bx, &l1,&c1, l2,c2, FALSE);
} else {
if (m->whiteturn)
(void) guess_depl(NB_M_PAWN_WD, m_pawn_wd, &l1,&c1, l2,c2, FALSE);
else
(void) guess_depl(NB_M_PAWN_BD, m_pawn_bd, &l1,&c1, l2,c2, FALSE);
}
break;
case KNIGHT:
(void) guess_depl(NB_M_KNIGHT, m_knight, &l1,&c1, l2,c2, FALSE);
break;
case BISHOP:
(void) guess_depl(NB_M_BISHOP, m_bishop, &l1,&c1, l2,c2, TRUE);
break;
case ROOK:
(void) guess_depl(NB_M_ROOK, m_rook, &l1,&c1, l2,c2, TRUE);
break;
case QUEEN:
(void) guess_depl(NB_M_QUEEN, m_queen, &l1,&c1, l2,c2, TRUE);
break;
case KING:
(void) guess_depl(NB_M_KING, m_king, &l1,&c1, l2,c2, TRUE);
break;
default:
break;
}

if ((l1 == 0) || (c1 == 0)) {
if (m->whiteturn)
error((stderr,
Unable to guess white move %d, with piece %c
,
m->move,in_table[m->piece]));
else
error((stderr,
Unable to guess black move %d, with piece %c
,
m->move,in_table[m->piece]));
return(FALSE);
} else {
m->fromcol = c1;
m->fromlig = l1;
return(TRUE);
}
}

/* execution of move */

/* clear a position */
#ifdef __STDC__
int clear_pos(int lig, int col)
#else
int clear_pos(lig,col)
int lig;
int col;
#endif
{
tos->board[lig][col] = VOID ;
tos->color[lig][col] = VOID ;
return(TRUE);
}

/* configure the board */
#ifdef __STDC__
int configure(void)
#else
int configure()
#endif
{
if (configuring) {
if (m->piece == VOID)
m->piece = PAWN ;
tos->board[m->tolig][m->tocol] = m->piece ;
tos->color[m->tolig][m->tocol] = configside ;
}
return(TRUE);
}

/* execute a move, no checking */
#ifdef __STDC__
int execute_move(void)
#else
int execute_move()
#endif
{
register int i;

if (m->piece == VOID )
m->piece = PAWN;

if ((m->fromlig == 0) || (m->fromcol == 0))
(void) guess_move();

/* supply to the maybe deficiency of input notation
*/
if ((m->fromlig !=0) || (m->fromcol != 0))
m->piece = tos->board[m->fromlig][m->fromcol];

if (tos->board[m->tolig][m->tocol] != VOID) {
m->type = PRISE;
m->prise = tos->board[m->tolig][m->tocol] ;
}

if (!check_move(m)) {
if (m->whiteturn)
error((stderr,
White move %d illegal
,m->move));
else
error((stderr,
Black move %d illegal
,m->move));
}

do_move(tos, m);

output_move(dr,m);

if (error_flag) {
(void) fprintf(dr->outfile,
Last position encountered:
);
output_board(dr,tos);
close_files();
exit(0);
}

/* do we need to display the move ? */
if (nb_move_to_dsp > 0) {
for (i=0; i < nb_move_to_dsp; i++)if (m->move == (move_to_display[i] ) && !m->whiteturn ) {
output_board(dr,tos);
if (stop_at_display) {
output_end(dr);
close_files();
exit(0);
}
}
}

return(TRUE);
}

/* automata */

/* categorise the input for the automata */
#ifdef __STDC__
int typechar(char c)
#else
int typechar(c)
char c;
#endif
{
if (ispiece(c))
return(0);
if ((c >=a) && ( c <= ‘h’))return(1);if ((c >=1) && ( c <= ‘8’))return(2);if ( c== ‘-‘ )return(3);if ((c == ‘x’) || (c == ‘X’ ))return(4);if (c == ‘=’ )return(5);if (c == ‘’ )return(6);return(7);}/* execute the actions decided by the automata */#ifdef __STDC__int execute(int num,char c)#elseint execute(num,c) int num; char c;#endif{switch (num) {case 1: /* set cur piece */curpiece = piece(c);break;case 2: /* set cur col */curcol = lettertocol(c);break;case 3: /* set cur lig */curlig = lettertolig(c);break;case 4: /* from = cur ; prise = false */m->piece = curpiece ;
m->fromcol = curcol ;
m->fromlig = curlig;
/*m->topiece = curpiece;*/
break;
case 5: /* from = cur ; prise = true */
m->piece = curpiece ;
m->fromcol = curcol ;
m->fromlig = curlig;
m->type = PRISE ;
m->prise = curpiece;
break;
case 6: /* to = cur ; guess from */
case 7: /* to = cur ; guess from ; parse remaining token */
m->piece = curpiece ;
m->tocol = curcol;
m->tolig = curlig ;

/*m->topiece = curpiece ; /* ? */

if (configuring)
(void) configure();
else {
(void) execute_move();
}
break;
case 8: /* to = cur */
case 9: /* to = cur */
m->tocol = curcol;
m->tolig = curlig ;

if (configuring)
(void) configure();
else {
(void) execute_move();
}
break;
case 10: /* piece = cur piece ; prise = true */
/* later : guess from position */
m->piece = curpiece ;
m->type = PRISE ;
break;
case 11: /* grand roque */
case 12: /* petit roque */
(void) execute_move();
break;
case 13: /* case of simpliest algebraic notation ;
only e2e4 : this is the transition from e2 to e4
also the case of move such as Nge2
from =cur; prise = FALSE;
also:
curcol =
*/
m->piece = curpiece ;
m->fromcol = curcol ;
m->fromlig = curlig;

m->type = MOVE;
curcol = lettertocol(c);
break;
case 14: /* promotion, the = */
/* NB: actions need some clean up here */
/* to = cur */

m->tocol = curcol;
m->tolig = curlig ;
/*m->topiece = curpiece ;*/

if (m->type == PRISE )
m->type = PROM_ET_PRISE ;
else
m->type = PROMOTION ;
/* by default, we promote to queen
this can be overwritten by explicit naming
*/
m->promotion = curpiece = QUEEN ;
break;
case 15: /* promotion, the piece name */
m->promotion = curpiece = piece(c) ;
break;
case 16: /* not used */
break;
case 17: /* execute move for promotion */
(void) execute_move();
break;
case -1:
break;
default:
break;
}
return(TRUE);
}

#ifdef __STDC__
int parse_number(char *token)
#else
int parse_number(token)
char *token;
#endif
{
int curmove = 0 ;
int i;

/* check coherency with internal numbering */
i = 0;
while (isdigit(token[i])) {
curmove = curmove * 10 +((int) token[i++] (int) 0 );
}
movecount = curmove ;
return(TRUE);
}

#ifdef __STDC__
int parse_text(char *text)
#else
int parse_text(text)
char *text;
#endif
{
output_text(dr,T_TEXT, text, 0);
return(TRUE);
}

#ifdef __STDC__
int parse_comment(char *com)
#else
int parse_comment(com)
char *com;
#endif
{
int t;

if (com[0] == $)
/* we look in the long ascii table */
t = find_keyword(com_long, NUM_COM_CODE, NUM_COM_CODE, com, TRUE);
else {
/* we look for the comment in the short ascii table */
t = find_keyword(com_short, NUM_COM_CODE, NUM_COM_CODE, com,FALSE);
if (t == NUM_COM_CODE)
fprintf (stderr,
What is %s ?
,com);
}
if (t != NUM_COM_CODE)
output_text(dr,T_COMMENT, com, t);
return(TRUE);
}

#ifdef __STDC__
int parse_keyword(char *token, char *text)
#else
int parse_keyword(token,text)
char *token;
char *text;
#endif
{
char c;

switch (find_keyword(keywords, NBKEYWORD, KNULL, token, TRUE)) {
case START:
/* dont forget we are configuring the previous move */
/* -> move 0, black */
configuring = FALSE;
m->move = 0;
m->whiteturn = FALSE;
break;
case CLEAR:
clear_board(tos);
m= theplay->chain;
free_move_list(m);
break;
case SHOWBOARD:
output_board(dr,tos);
break;
case TOWHITE:
/* dont forget we are configuring the previous move */
/* reset to 0,black > 1,white */
m->move = 0;
m->whiteturn = FALSE;
break;
case TOBLACK:
/* reset to 1,white -> 1 black */
m->move = 1;
m->whiteturn = TRUE;
break;
case CONFIGWH:
configuring = TRUE ;
configside = WHITE;
m= theplay->chain;
free_move_list(m);
break;
case CONFIGBL:
configuring = TRUE ;
configside = BLACK;
m= theplay->chain;
free_move_list(m);
break;
case DEFAULTP:
init_board(tos);
m= theplay->chain;
free_move_list(m);
break;
case TITLE:
output_text(dr, T_TITLE, text, NULL);
break;
case SUBTITLE:
output_text(dr, T_SUBTITLE, text, NULL);
break;
case SCORE:
output_text(dr, T_SCORE, text, NULL);
break;
case LANGUE:
in_language = find_keyword (t_language, NBLANGUAGES, in_language,
text,TRUE);
associe_traduction( &in_table, in_language);
break;
case SPECIAL: /* all input, up to
is copied to output */
while ((( c = getc(infile)) != EOF) && (c !=
))
(void) putc (c,dr->outfile);
putc (
, dr->outfile);
break;
case KNULL:
default:
fprintf(stderr,unknown keyword %s
,token);
break;
}
return(TRUE);
}

#ifdef __STDC__
int parse_roque(char *token)
#else
int parse_roque(token)
char * token;
#endif
{
int i;

for (i=0; i < NBROQUE && (strcmp(c_roque[i],token)!=0); i++) ;if ( i < NBROQUE ) {m = add_trailing_move(m);init_parse(m);if (strlen(token) == 3) {m->type = PETITROQUE ;
(void) execute(12,DUMMYCHAR);
} else {
m->type = GRANDROQUE ;
(void) execute(11,DUMMYCHAR);
}
/*(void) fprintf(stderr,ROQUE
);*/
return(TRUE);
}

return(FALSE);
}

#ifdef __STDC__
intparse_move(char *token)
#else
intparse_move(token)
char *token;
#endif
{
register int i;
int correcte = FALSE ;
int erreursyntaxe = FALSE ;
int etat =0;
int code;

m = add_trailing_move(m);
init_parse(m);
m->type = MOVE;

i=0;
while ( !correcte && !erreursyntaxe ) {
code = typechar(token[i]);
(void) execute(action[etat][code],token[i]);
etat = transit[etat][code] ;
if (etat == -1)
erreursyntaxe = TRUE;
if (etat == FINAL)
correcte = TRUE ;
i++;
}
if (erreursyntaxe) {
(void) fprintf(stderr, no comprende, senor: %s
,token);
return(FALSE);
}
if (correcte) {
/*(void) fprintf(stderr, ia panimaiou, davai
);*/
}
/*init_parse(m);*/
return(TRUE);
}

#ifdef __STDC__
void init_parse(depl *m)
#else
void init_parse(m)
depl * m ;
#endif
{

/* global position and piece variable initialised to 0
*/
/* move and whiteturn unchanged */

m->type = MOVE ;

curpiece = m->piece = VOID ;
curcol = m->tocol = m->fromcol = 0;
curlig = m->tolig = m->fromlig = 0;

m->promotion = VOID;
m->prise = VOID;
m->is_check = FALSE ;

curdigit = curmove = 0;

/*if (movecount != m->move)
(void) fprintf(stderr,problem in move numbering: %d vs %d
,
m->move, movecount);*/

}

/* – top routines */

/* cette fonction analyse les arguments de la ligne de commande
*/
#ifdef __STDC__
int parse_options(int argc,char *argv[])
#else
int parse_options(argc,argv)
int argc;
char * argv[];
#endif
{
int narg =1 ;
int i;
register int c;
char cp[132];
char chaine[MAXTOKLEN];

infile = stdin;
dr->outfile = stdout;
nb_move_to_dsp = 0;

while (narg < argc ) {(void) strcpy (cp,argv[narg]);switch (cp[0]) {case ‘-‘ :switch (cp[1]) {case ‘f’ : /* from langage */if((narg+1) >= argc )
fatal((stderr,missing argument to %s option,cp));
narg++ ;
in_language = find_keyword (t_language, NBLANGUAGES,
DEFAULT_INPUT_LANGUAGE,
argv[narg],TRUE);
break;
case t : /* to langage */
if((narg+1) >= argc )
fatal((stderr,missing argument to %s option,cp));
narg++ ;
out_language = find_keyword (t_language, NBLANGUAGES,
DEFAULT_OUTPUT_LANGUAGE,
argv[narg],TRUE);
break;
case o : /* next arg is output file */
narg++ ;
if ((dr->outfile = fopen (argv[narg],w+)) == NULL) {
(void) fprintf (stderr,cant open %s output file
,argv[narg]);
(void) fprintf (stderr,assume stdout for output
);
}
case e:
if((narg+1) >= argc )
fatal((stderr,missing argument to %s option,cp));
narg++ ;

i=0;
nb_move_to_dsp = 0;
move_to_display[nb_move_to_dsp] = 0;
while (isdigit(argv[narg][i])) {
move_to_display[nb_move_to_dsp] =
((int) argv[narg][i] (int) 0)
+ move_to_display[nb_move_to_dsp] * 10;
i++;
}
nb_move_to_dsp++;
stop_at_display = TRUE;
break;
case c:
if((narg+1) >= argc )
fatal((stderr,missing argument to %s option,cp));
narg++ ;

i=0;
while (isdigit(argv[narg][i])) {
move_to_display[nb_move_to_dsp] = 0;
while (isdigit(argv[narg][i])) {
move_to_display[nb_move_to_dsp] =
((int) argv[narg][i] (int) 0)
+ move_to_display[nb_move_to_dsp] * 10;
i++;
}
nb_move_to_dsp++;

if (nb_move_to_dsp > NB_MOVE_TO_DISP)
fatal((stderr,max. number of move to display exceeded));

/* process next number */
if (argv[narg][i] == ,)
i++;
}
break;
case a: /* algebraic output */
dr->output_move_format = ALGEBRAIC;
break;
case s:/* shortened output */
dr->output_move_format = SHORTENED;
break;
case b: /* display only the board, no move */
dr->only_board = TRUE;
break;
case d: /* output driver */
if((narg+1) >= argc )
fatal((stderr,missing argument to %s option,cp));
narg++ ;
driver = find_keyword(t_output, NB_DRIVER, DEFAULT_DRIVER,
argv[narg],TRUE);
break;
case i: /* no headers */
dr->print_headers = FALSE;
break;
case v: /* print version */
/* this already done, so exit() */
exit(0);
break;
case h: /* help file */
(void) strcpy(chaine,LIB_DIR);
if ((fhelp = fopen(strcat(chaine,HELP_FILE),r)) == NULL)
fatal((stderr,Cant find help file.
));
else {
while ((c = getc(fhelp)) != EOF)
(void) fputc(c,stderr);
(void) fclose(fhelp);
exit(0);
}
break;
default:
error((stderr,
Unknown command line options %s
,cp));
break;
}
break;
default: /* assume this is the input file */
if ((infile = fopen (cp,r)) == NULL)
fatal((stderr,cant open %s input file
,cp));
}
narg++;
} /* process next arg */
return(argc);
}

#ifdef __STDC__
void close_files(void)
#else
void close_files()
#endif
{
if (!((infile == stdin)||(infile == NULL)))
(void) fclose(infile);
if (dr->outfile != stdout )
(void) fclose(dr->outfile);
}

#ifdef __STDC__
int associe_traduction (char **table, int language)
#else
int associe_traduction (table, language)
char ** table;
int language ;
#endif
{
if (language < 0 || (language >= NBLANGUAGES))
error((stderr,
Unknown language
));
else
*table = c_language[language];
return(language);
}

#ifdef __STDC__
static void print_all_play(play *p)
#else
static void print_all_play(p)
play *p;
#endif
{
depl *d;
d = p->chain;
while (d->next != NULL){
d = d->next;
output_move(dr,d);
}
}

/* – main */

#ifdef __STDC__
int notation_main(int argc,char *argv[])
#else
int notation_main(argc,argv)
int argc;
char * argv[];
#endif
{
(void) fprintf(stderr,%s
,version_string);

/* allocation of driver descriptor */
dr = new_driver();

/* default configuration */
init_driver(dr,DEFAULT_DRIVER);
(void) associe_traduction(&in_table,DEFAULT_INPUT_LANGUAGE );
(void) associe_traduction(&(dr->out_table), DEFAULT_OUTPUT_LANGUAGE);

(void) parse_options(argc,argv);

(void) associe_traduction (&in_table, in_language);
(void) associe_traduction (&(dr->out_table), out_language);

/* assoc driver */
init_driver(dr,driver);

configuring = FALSE;
configside = VOID;

/* initialise output file */
output_init(dr);

if (error_flag)
fatal((stderr,
Too many errors));

/* allocation of board descriptor */
tos = new_board();
init_board(tos);

/* allocation of move descriptor */
m->type = VOID ;
/*init_move(m);*/

/* allocation of the play descriptor */
theplay = (play *) malloc (sizeof(play)) ;
theplay->initial = tos ;
theplay->chain = m ;
movecount = 1;

/* main analysis routine */
yyin = infile ;
yyout = stderr ;

/*init_parse(m); */
yylex();

if ((count == 0) && !error_flag)
output_board(dr,tos);

if (error_flag) {
error((stderr,
Last valid position:
));
output_board(dr,tos);
fatal((stderr,
Too many errors));
}

/* terminates output files */
output_end(dr);

/* close files */
close_files();

/* exit properly */
return 0;
}