home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume28 / notation / part01 < prev    next >
Encoding:
Text File  |  1992-02-13  |  57.5 KB  |  2,253 lines
  1. Newsgroups: comp.sources.misc
  2. From: hthomas@ph.tn.tudelft.nl (Henry Thomas)
  3. Subject:  v28i036:  notation - chess preprocessor v3.9, Part01/04
  4. Message-ID: <csm-v28i036=notation.144616@sparky.IMD.Sterling.COM>
  5. X-Md4-Signature: 3472b8a36c3064f13281bf047492679d
  6. Date: Tue, 11 Feb 1992 20:46:48 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: hthomas@ph.tn.tudelft.nl (Henry Thomas)
  10. Posting-number: Volume 28, Issue 36
  11. Archive-name: notation/part01
  12. Environment: UNIX
  13. Supersedes: notation: Volume20, Issue 52-55
  14.  
  15. This program is is chess preprocessor. It reads chess games, either
  16. in full algebraic or shortened notation (ie Nf1-g3 or f1g3 or Ng3) and
  17. is able to output the games and/or the board af any move, in ascii,
  18. postscript, TeX, or nroff. It also can generate output for the gnuan
  19. and xboard programs. It is multi-lingual (european) for piece
  20. identification. The program understands french, english, german,
  21. spanish dutch, italian, polish etc. The program also handles variations
  22. and symbolized comments.
  23.  
  24. This program is ok on UNIX (Sun Sparc Station and Sun-3). It uses
  25. standard C, and function declarations are done in both K&R-C and
  26. ANSI-C.  It won't difficult to compile on a IBM-PC with MSC (I 
  27. easily got an older version to work with TURBO-C).
  28.  
  29. I hope the program is clear enough to be easily modified. Anyway,
  30. I would like to centralize modifications, in order to manage an
  31. up-to-date version. So send me any modifications, in forms of diff
  32. files, if possible, along with the version number of the program.
  33. ---------------------
  34. #! /bin/sh
  35. # This is a shell archive.  Remove anything before this line, then feed it
  36. # into a shell via "sh file" or similar.  To overwrite existing files,
  37. # type "sh file -c".
  38. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  39. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  40. # Contents:  README chesssymb.def notation.c
  41. # Wrapped by kent@sparky on Tue Feb 11 14:22:45 1992
  42. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  43. echo If this archive is complete, you will see the following message:
  44. echo '          "shar: End of archive 1 (of 4)."'
  45. if test -f 'README' -a "${1}" != "-c" ; then 
  46.   echo shar: Will not clobber existing file \"'README'\"
  47. else
  48.   echo shar: Extracting \"'README'\" \(5243 characters\)
  49.   sed "s/^X//" >'README' <<'END_OF_FILE'
  50. X** DESCRIPTION
  51. X  This program is is chess preprocessor. It reads chess games, either
  52. Xin full algebraic or shortened notation (ie Nf1-g3 or f1g3 or Ng3) and
  53. Xis able to output the games and/or the board af any move, in ascii,
  54. Xpostscript, TeX, or nroff. It also can generate output for the gnuan
  55. Xand xboard programs. It is multi-lingual (european) for piece
  56. Xidentification. The program understand french, english, german,
  57. Xspanish dutch, italian, polish etc. The program also handle variations
  58. Xand symbolized comments.
  59. X
  60. XThis is a freeware program. You have the right to modify it, give it,
  61. Xprovided you don't modify the copyright notice and my name still
  62. Xremains.  The distribution has 4 shar-type files.
  63. X
  64. X** COMPATIBILITY
  65. X  This program is ok on UNIX (Sun Sparc Station and Sun-3). It uses
  66. Xstandard C, and fonctions declarations are done in both K&R-C and
  67. XANSI-C.  It won't difficult to compile on a IBM-PC with
  68. XMSC (I easily get to work an older function with TURBO-C).
  69. X
  70. X** QUICK USE
  71. X  Anyway, you want to try quickly the program, issue the command
  72. X"make" in this directory, and then type "notation algebric.txt" to
  73. Xtest the programm on Kasparov/Karpov game 13 (Lyon, November 1990).
  74. XIf you want to install it completely ( TeX, helpfile etc), edit the
  75. XMakefile and type "make install".  Read and modify the makefile for
  76. Xcustomizing notation to your national language and library path.  If
  77. Xyou want a complete manual, read notation.doc.  To print a postscript
  78. Xfile, merge the ps font definition and the output of the Notation
  79. Xprogram (say foo.ps) and send it to the printer (for instance "cat
  80. XCheq foo.ps | lpr").
  81. X
  82. X** SOURCES
  83. X  NOTA: <version number> is currently 3.9
  84. X
  85. X  They are posted to "comp.sources.misc". You can then get them from
  86. Xany site archiving "comp.sources.misc".
  87. X
  88. X  They are available by anonymous ftp on wuarchive.wustl.edu,
  89. X(user:anonymous, password:<your address>). The path is
  90. X"pub/Notation.tar.Z" ou "pub/Notation<version number>.tar.Z"
  91. XThe patch are also available as "Notation-patch<version number>.shar.Z".
  92. X
  93. X ** I expect the source to show up soon on garbo.uwasa.fi.
  94. XIf you're in Europe, you can get notation from the server
  95. Xgarbo.uwasa.fi:
  96. X-- by anonymous ftp with path /unix/util/notation.tar.Z
  97. X-- by e-mail by sending the message
  98. X
  99. X        mail mailserv@garbo.uwasa.fi
  100. X        Subject:garbo-request
  101. X        send unix/util/notation.tar.Z
  102. X
  103. X        (or  send unix/util/notation<version number>.tar.Z)
  104. X
  105. X   You will receive the uuencoded-split program within hours.
  106. X
  107. X  You can also get them by mail, from "hthomas@ph.tn.tudelft.nl". But
  108. XI prefer you try the others before.
  109. X
  110. X
  111. X** IMPORTANT
  112. X  If you want to use PostScript or LaTeX, you need two packages not
  113. Xprovided here. However, here is a way to get them:
  114. X
  115. X**** Postscript: 
  116. X  You need the font "Cheq", freely distributed by Adobe.  Send a mail
  117. Xto "ps-file-server@adobe.com" with the body "send Programs
  118. Xchessfont.ps". For use with "notation", rename the file "Cheq".
  119. X
  120. X------------------------------------------------------------------
  121. Xchessfont.ps              58548 Jun 22 1989
  122. X    This is the Adobe chess font "Cheq", created by John Renner. It 
  123. X    is an ASCII downloadable version of the font that is not in any 
  124. X    particular font format for a specific platform. See also
  125. X    "chessfontUNIX.shar" and "chessfontMAC.shar" for the font bundled 
  126. X    with other useful files like screen fonts and AFM files. If you 
  127. X    just want the font, it is available in this file separately for 
  128. X    convenience.
  129. X------------------------------------------------------------------
  130. X
  131. X**** LaTeX: 
  132. X  You need the chess fonts designed by Piet Tutalaers
  133. X"rcpt@urc.tue.nl". YOU NEED VERSION 1.2 (released 10/02/91). The
  134. Xcomplete distribution is available
  135. X
  136. X-- by ftp : on sol.cs.ruu.nl (131.211.80.5) with path TEX/chess.tar.Z
  137. X(please restrict access to weekends or evening/night (i.e.  between
  138. Xabout 2000 and 0.900 UTC)).
  139. X
  140. X------------------------------------------------------------------
  141. X-rw-r--r--  1 piet     staff        2984 Dec  3 10:11 chess.README
  142. X-rwxr--r--  1 piet     staff      129679 Dec  3 15:57 chess.tar.Z
  143. X------------------------------------------------------------------
  144. X
  145. X-- by e-mail : send the following message to 
  146. Xmail-server@cs..ruu.nl (or uunet!mcsun!hp4nl!ruuinf):
  147. X
  148. Xbegin
  149. Xpath john@highbrown.edu
  150. Xsend TEX/chess.tar.Z
  151. Xend
  152. X
  153. XThe path command can be deleted if we receive a valid from address in
  154. Xyour message. If this is the first time you use the mail server, we
  155. Xsuggest you first issue the request:
  156. Xsend help
  157. X
  158. X
  159. X** DOCUMENTATION
  160. X  See the file notation.doc for any info
  161. X
  162. X** COPYRIGHT
  163. X
  164. X  This is a freeware program. Commercial use is prohibited. It is free
  165. Xfor non-commercial use.  You have the right to modify it, give it,
  166. Xprovided you don't modify the copyright notice and my name still
  167. Xremains clearly indicated. For the others packages (Cheq and chess
  168. Xfont) refer to the original copyright notice.
  169. X
  170. X** USER FEEDBACK
  171. X
  172. X  If you're happy with this program, let me know :-) Thanks.
  173. X
  174. X
  175. X** MODIFICATIONS
  176. X
  177. X  I hope the program to be clear enough to be easily modified. Anyway,
  178. XI would like to centralize modification, in order to manage an
  179. Xup-to-date version. So send me the modification, in forms of diff
  180. Xfiles, if possible, along with the version number of the program.
  181. END_OF_FILE
  182.   if test 5243 -ne `wc -c <'README'`; then
  183.     echo shar: \"'README'\" unpacked with wrong size!
  184.   fi
  185.   # end of 'README'
  186. fi
  187. if test -f 'chesssymb.def' -a "${1}" != "-c" ; then 
  188.   echo shar: Will not clobber existing file \"'chesssymb.def'\"
  189. else
  190.   echo shar: Extracting \"'chesssymb.def'\" \(5043 characters\)
  191.   sed "s/^X//" >'chesssymb.def' <<'END_OF_FILE'
  192. X/*
  193. X  chess symbols : arguments (all are strings)
  194. X  0: ident
  195. X  1: ascii name
  196. X  2: ascii abbrev
  197. X  3: TeX name
  198. X  4: Postscript name (Mr. Walker font)
  199. X  5: english text
  200. X  6: french text
  201. X  */
  202. X
  203. XCHESSSYMB ( COM_CHK, "+", "+" ,  "+", "",
  204. X       "check",
  205. X       "echec" )
  206. XCHESSSYMB ( COM_DCK, "++", "++" ,  "++", "",
  207. X       "double check",
  208. X       "echec double" )
  209. XCHESSSYMB ( COM_WSB, "$wsb", "+=", "\\wbetter", "",
  210. X       "white stands lightly better",
  211. X       "les blancs ont un jeu un peu meilleur" )
  212. XCHESSSYMB ( COM_BSB, "$bsb", "=+", "\\bbetter", "",
  213. X       "black stands lightly better",
  214. X       "les noirs ont un jeu un peu meilleur" )
  215. XCHESSSYMB ( COM_WBE, "$wbe", "+_", "\\wupperhand", "",
  216. X       "white has the upper hand",
  217. X       "les blancs ont le meilleur jeu" )
  218. XCHESSSYMB ( COM_BBE, "$bbe", "_+", "\\bupperhand", "",
  219. X       "black has the upper hand",
  220. X       "les noirs ont le meilleur jeu" )
  221. XCHESSSYMB ( COM_WDA, "$wda", "+-", "\\wdecisive", "",
  222. X       "white has a decisive advantage",
  223. X       "les blancs ont un avantage de'cisif" )
  224. XCHESSSYMB ( COM_BDA, "$bda", "-+", "\\bdecisive", "",
  225. X       "black has a decisive advantage",
  226. X       "les noirs ont un avantage de'cisif" )
  227. XCHESSSYMB ( COM_EQA, "="  , "=",  "\\equal", "",
  228. X       "even",
  229. X       "e'gal" )
  230. XCHESSSYMB ( COM_UCR, "$ucr", "~" ,  "\\unclear", "",
  231. X       "unclear",
  232. X       "incertain" )
  233. XCHESSSYMB ( COM_WCO, "$wco", "=~" ,  "\\compensation", "",
  234. X       "with compensation for the material",
  235. X       "avec compensation pour le mate'riel" )
  236. XCHESSSYMB ( COM_DAD, "$dad", "(^)" ,  "\\devadvantage", "",
  237. X       "development advantage",
  238. X       "avance de de'veloppement" )
  239. XCHESSSYMB ( COM_SPA, "$spa", "()" ,  "\\moreroom", "",
  240. X       "greater space advantage",
  241. X       "grand avantage d'espace" )
  242. XCHESSSYMB ( COM_WTA, "$wta", "->" ,  "\\withattack", "",
  243. X       "with attack",
  244. X       "avec attaque" )
  245. XCHESSSYMB ( COM_WIN, "$win", "|^" ,  "\\withinit", "",
  246. X       "with initiative",
  247. X       "avec initiative" )
  248. XCHESSSYMB ( COM_WCP, "$wcp", "<->" ,  "\\counterplay", "",
  249. X       "with counter-play",
  250. X       "avec contre-attaque" )
  251. XCHESSSYMB ( COM_ZUG, "$zug", "(.)" ,  "\\zugzwang", "",
  252. X       "zugzwang",
  253. X       "zug zwang" )
  254. XCHESSSYMB ( COM_MAT, "#", "#" ,  "\\mate", "",
  255. X       "mate",
  256. X       "mat" )
  257. XCHESSSYMB ( COM_VGM, "!", "!" ,  "!", "",
  258. X       "very good move",
  259. X       "un tre`s bon coup" )
  260. XCHESSSYMB ( COM_VBM, "?", "?" ,  "?", "",
  261. X       "very bad move",
  262. X       "un tre`s mauvais coup" )
  263. XCHESSSYMB ( COM_EXM, "!!", "!!" ,  "!!", "",
  264. X       "excellent move",
  265. X       "un excellent coup" )
  266. XCHESSSYMB ( COM_MIS, "??", "??" ,  "??", "",
  267. X       "a mistake",
  268. X       "un coup faible" )
  269. XCHESSSYMB ( COM_MDA, "!?", "!?" ,  "!?", "",
  270. X       "a move deserving attention",
  271. X       "un coup qui me'rite l'attention" )
  272. XCHESSSYMB ( COM_DUM, "?!", "?!" ,  "?!", "",
  273. X       "a dubious move",
  274. X       "un coup d'une valeur douteuse" )
  275. XCHESSSYMB ( COM_WTI, "$wti", "/\\" ,  "\\withidea", "",
  276. X       "with the idea...",
  277. X       "avec l'ide'e..." )
  278. XCHESSSYMB ( COM_OLM, "$olm", "[]" ,  "\\onlymove", "",
  279. X       "only move",
  280. X       "seul coup possible" )
  281. XCHESSSYMB ( COM_BEI, "$bei", "^_" ,  "\\betteris", "",
  282. X       "better is",
  283. X       "est meilleur" )
  284. XCHESSSYMB ( COM_FIL, "$fil", "<=>" ,  "\\file", "",
  285. X       "file",
  286. X       "colonne" )
  287. XCHESSSYMB ( COM_DIA, "$dia", "/^" ,  "\\diagonal", "",
  288. X       "diagonal",
  289. X       "diagonale" )
  290. XCHESSSYMB ( COM_CNT, "$cnt", "[+]" ,  "\\centre", "",
  291. X       "center",
  292. X       "centre" )
  293. XCHESSSYMB ( COM_KGS, "$kgs", ">>" ,  "\\kside", "",
  294. X       "king's side",
  295. X       "aile roi" )
  296. XCHESSSYMB ( COM_QNS, "$qns", "<<" ,  "\\qside", "",
  297. X       "queen's side",
  298. X       "aile reine" )
  299. XCHESSSYMB ( COM_WKP, "$wkp", "><" ,  "\\weakpt", "",
  300. X       "weak point",
  301. X       "point faigle" )
  302. XCHESSSYMB ( COM_END, "$end", "_|_" ,  "\\ending", "",
  303. X       "ending",
  304. X       "finale" )
  305. XCHESSSYMB ( COM_POB, "$pob", "==" ,  "\\bishoppair", "",
  306. X       "pair of bishops",
  307. X       "paire de fous" )
  308. XCHESSSYMB ( COM_OPC, "$opc", "=#" ,  "\\opposbishops", "",
  309. X       "bishops of opposite colors",
  310. X       "fous de couleurs oppose'es" )
  311. XCHESSSYMB ( COM_SCB, "$scb", "##" ,  "\\samebishops", "",
  312. X       "same coloured bishops",
  313. X       "fous de me^me couleur" )
  314. XCHESSSYMB ( COM_UNP, "$unp", "oo" ,  "\\unitedpawns", "",
  315. X       "united pawns",
  316. X       "pions unis" )
  317. XCHESSSYMB ( COM_SEP, "$sep", "o..o" ,  "\\seppawns", "",
  318. X       "separated pawns",
  319. X       "pions se'pare's" )
  320. XCHESSSYMB ( COM_DOP, "$dop", "o/o" ,  "\\doublepawns", "",
  321. X       "doubled pawns",
  322. X       "pions double's" )
  323. XCHESSSYMB ( COM_TIM, "$tim", "(+)" ,  "\\timelimit", "",
  324. X       "time",
  325. X       "temps" )
  326. XCHESSSYMB ( COM_NOV, "$nov", "N" ,  "\\novelty", "",
  327. X       "novelty",
  328. X       "nouveaute'" )
  329. XCHESSSYMB ( COM_COM, "$com", "RR" ,  "\\comment", "",
  330. X       "editorial comment",
  331. X       "commentaire e'ditorial" )
  332. XCHESSSYMB ( COM_VAR, "$var", "R" ,  "\\various", "",
  333. X       "various moves",
  334. X       "coups divers" )
  335. XCHESSSYMB ( COM_WTO, "$wto", "_|" ,  "\\without", "",
  336. X       "without",
  337. X       "sans" )
  338. XCHESSSYMB ( COM_ETC, "etc", "etc" ,  "{etc}", "",
  339. X       "etc",
  340. X       "etc" )
  341. XCHESSSYMB ( COM_ETD, "||", "||" ,  "\\etc", "",
  342. X       "etc",
  343. X       "etc" )
  344. XCHESSSYMB ( COM_SEE, "$see", "" ,  "\\see", "",
  345. X       "see",
  346. X       "voir" )
  347. XCHESSSYMB ( COM_ENP, "ep", "ep" ,  "{ep}", "",
  348. X       "en passant",
  349. X       "en passant" )
  350. END_OF_FILE
  351.   if test 5043 -ne `wc -c <'chesssymb.def'`; then
  352.     echo shar: \"'chesssymb.def'\" unpacked with wrong size!
  353.   fi
  354.   # end of 'chesssymb.def'
  355. fi
  356. if test -f 'notation.c' -a "${1}" != "-c" ; then 
  357.   echo shar: Will not clobber existing file \"'notation.c'\"
  358. else
  359.   echo shar: Extracting \"'notation.c'\" \(42748 characters\)
  360.   sed "s/^X//" >'notation.c' <<'END_OF_FILE'
  361. X/*
  362. X  Notation program
  363. X  @(#)notation.c    3.9 (C) Henry Thomas   Release 3     Dated 12/10/91
  364. X */
  365. X/* Programme d'analyse de notation echiquienne
  366. X   Copyright (C) 1990 Henry Thomas
  367. X   Nom: notation
  368. X   Auteur: Henry Thomas
  369. X   Date: 27/11/90
  370. X/*
  371. XThis file is part of NOTATION program.
  372. X
  373. XNOTATION is free software; you can redistribute it and/or modify
  374. Xit under the terms of the GNU General Public License as published by
  375. Xthe Free Software Foundation; either version 1, or (at your option)
  376. Xany later version.
  377. X
  378. XNOTATION is distributed in the hope that it will be useful,
  379. Xbut WITHOUT ANY WARRANTY; without even the implied warranty of
  380. XMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  381. XGNU General Public License for more details.
  382. X
  383. XYou should have received a copy of the GNU General Public License
  384. Xalong with NOTATION; see the file COPYING.  If not, write to
  385. Xthe Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  386. X
  387. X/* --------------------- data part ---------------------- */
  388. X
  389. X/* les tableaux suivants sont les tables de transcription de notation
  390. X   selon les langages
  391. X   */
  392. X#ifdef __STDC__
  393. X#include <stdlib.h>
  394. X#endif
  395. X#include <stdio.h>
  396. X#include <string.h>
  397. X#include <ctype.h>
  398. X
  399. X#include "chesstype.h"
  400. X#include "notation.h"
  401. X#include "drivers.h"
  402. X#include "lexer.h"
  403. X
  404. Xextern void close_files();
  405. X
  406. Xchar * version_string =
  407. X  "@(#)notation.c    3.9 (C) Henry Thomas.   Release 3     Dated 12/10/91";
  408. X
  409. Xstatic char * keywords[]= {
  410. X  "@startplay" , "@clearboard" , "@showboard" ,
  411. X  "@whitesmove", "@blacksmove", "@configwhite", "@configblack" ,
  412. X  "@default" , 
  413. X  /* these are keywords with arguments */
  414. X  "@title", "@subtitle", "@score", "@language",
  415. X  /* "special" keyword */
  416. X  "@special", 
  417. X  /* null and final keyword */
  418. X  "@null"
  419. X  };
  420. X
  421. Xint configuring = FALSE ;
  422. Xint configside = 0 ;
  423. X
  424. X
  425. Xstatic char * t_language[] = {
  426. X  "french", "english", "italian", "spanish", "german", "dutch",
  427. X  "czech",  "hungarian","polish", "romanian", "FIDE"
  428. X};
  429. X
  430. Xstatic int in_language = DEFAULT_INPUT_LANGUAGE ;
  431. Xstatic int out_language = DEFAULT_OUTPUT_LANGUAGE ;
  432. X
  433. Xstatic char c_language[NBLANGUAGES][7] = {
  434. X/* french    */  { '@' ,'R' , 'D' , 'T' , 'F' , 'C' , 'P' },
  435. X/* english   */  { '@' ,'K' , 'Q' , 'R' , 'B' , 'N' , 'P' },
  436. X/* italian   */  { '@' ,'R' , 'D' , 'T' , 'A' , 'C' , 'P' },
  437. X/* spanish   */  { '@' ,'R' , 'D' , 'T' , 'A' , 'C' , 'P' },
  438. X/* german    */  { '@' ,'K' , 'D' , 'T' , 'L' , 'S' , 'B' },
  439. X/* dutch     */  { '@' ,'K' , 'D' , 'T' , 'L' , 'P' , 'O' },
  440. X/* czech     */  { '@' ,'K' , 'D' , 'V' , 'S' , 'J' , 'P' },
  441. X/* hungarian */  { '@' ,'K' , 'V' , 'B' , 'F' , 'H' , 'G' },
  442. X/* polish    */  { '@' ,'K' , 'H' , 'W' , 'G' , 'S' , 'P' },
  443. X/* romanian  */  { '@' ,'R' , 'D' , 'T' , 'N' , 'C' , 'P' },
  444. X/* FIDE      */  { '@' ,'K' , 'D' , 'T' , 'S' , 'N' , 'P' }
  445. X/* UNIMPLEMENTED ... */
  446. X/* user_def  *//*{ '@' ,'X' , 'X' , 'X' , 'X' , 'X' , 'X' }*/
  447. X/* russian not implemented : ASCII russian is an oxymoron */
  448. X/* russian   *//*{ '@' ,'K' , 'F' , 'D' , 'C' , 'K' , 'P' }*/
  449. X           };
  450. X
  451. X/* input translation table */
  452. Xchar *in_table;
  453. X 
  454. X
  455. Xchar *  c_roque[] = { "O-O" , "O-O-O" , "o-o" , "o-o-o" , "0-0" , "0-0-0" };
  456. X
  457. X/* various notations for en passant */
  458. X#define N_EP 2
  459. Xchar * c_en_passant[] = { "ep" , "e.p." } ;
  460. X
  461. X
  462. X/* notation for catch */
  463. Xchar c_prise ='x';
  464. X
  465. X/* various comments */
  466. Xchar * c_comments[] = { "+" , "++" , 
  467. X              "?" , "??", "!", "!!", "!?", "?!",
  468. X              "mate", "draw" };
  469. X
  470. X/* movement tables */
  471. X/* move only */
  472. X/* white pawn, move */
  473. X#define NB_M_PAWN_MOVE_WD 2
  474. Xstatic int m_pawn_move_wd [][2] = {
  475. X  { 1, 0}, {2, 0}
  476. X};
  477. X
  478. X/* black pawn, move */
  479. X#define NB_M_PAWN_MOVE_BD 2
  480. Xstatic int m_pawn_move_bd [][2] = {
  481. X  {-1, 0}, {-2, 0}
  482. X};
  483. X
  484. X/* TRICK = we have added the catching move at the end of
  485. X   the non catching ones; so in check_depl, we try first 
  486. X   the non catching one and then the catching one.
  487. X   So, even if catching (x) is non indicated in the input, 
  488. X   we succeed in guessing the move
  489. X   */
  490. X/* white pawn, move */
  491. X/*#define NB_M_PAWN_WD 2*/
  492. X#define NB_M_PAWN_WD 4
  493. Xstatic int m_pawn_wd [][2] = {
  494. X  { 1, 0}, {2, 0},
  495. X/* catch... */
  496. X  { 1, 1}, { 1,-1}
  497. X};
  498. X
  499. X/* white pawn, catch */
  500. X#define NB_M_PAWN_WX 2
  501. Xstatic int m_pawn_wx [][2] = {
  502. X  { 1, 1}, { 1,-1}
  503. X};
  504. X
  505. X/* black pawn, move */
  506. X/*#define NB_M_PAWN_BD 2*/
  507. X#define NB_M_PAWN_BD 4
  508. Xstatic int m_pawn_bd [][2] = {
  509. X  {-1, 0}, {-2, 0},
  510. X/* catch... */
  511. X  {-1, 1}, {-1,-1} 
  512. X};
  513. X
  514. X/* black pawn, catch */
  515. X#define NB_M_PAWN_BX 2
  516. Xstatic int m_pawn_bx [][2] = {
  517. X  {-1, 1}, {-1,-1} 
  518. X};
  519. X
  520. X
  521. X#define NB_M_KNIGHT  8
  522. Xstatic int m_knight[][2] = { 
  523. X  { 2, 1}, { 2,-1}, {-2, 1}, {-2,-1},
  524. X  { 1, 2}, { 1,-2}, {-1, 2}, {-1,-2}
  525. X};
  526. X
  527. X#define NB_M_BISHOP 28
  528. Xstatic int m_bishop[][2] = {
  529. X  { 7, 7},  {6, 6}, { 5, 5}, { 4, 4}, { 3, 3}, { 2, 2}, { 1, 1},
  530. X  { 7,-7}, { 6,-6}, { 5,-5}, { 4,-4}, { 3,-3}, { 2,-2}, { 1,-1},
  531. X  {-7,-7}, {-6,-6}, {-5,-5}, {-4,-4}, {-3,-3}, {-2,-2}, {-1,-1},
  532. X  {-7, 7}, {-6, 6}, {-5, 5}, {-4, 4}, {-3, 3}, {-2, 2}, {-1, 1}
  533. X};
  534. X
  535. X#define NB_M_ROOK 28
  536. Xstatic int m_rook[][2] = {
  537. X  { 7, 0}, { 6, 0}, { 5, 0}, { 4, 0}, { 3, 0}, { 2, 0}, { 1, 0},
  538. X  {-7, 0}, {-6, 0}, {-5, 0}, {-4, 0}, {-3, 0}, {-2, 0}, {-1, 0},
  539. X  { 0, 7}, { 0, 6}, { 0, 5}, { 0, 4}, { 0, 3}, { 0, 2}, { 0, 1},
  540. X  { 0,-7}, { 0,-6}, { 0,-5}, { 0,-4}, { 0,-3}, { 0,-2}, { 0,-1}
  541. X};
  542. X
  543. X#define NB_M_QUEEN 56
  544. Xstatic int m_queen[][2] = {
  545. X  { 7, 7},  {6, 6}, { 5, 5}, { 4, 4}, { 3, 3}, { 2, 2}, { 1, 1},
  546. X  { 7,-7}, { 6,-6}, { 5,-5}, { 4,-4}, { 3,-3}, { 2,-2}, { 1,-1},
  547. X  {-7,-7}, {-6,-6}, {-5,-5}, {-4,-4}, {-3,-3}, {-2,-2}, {-1,-1},
  548. X  {-7, 7}, {-6, 6}, {-5, 5}, {-4, 4}, {-3, 3}, {-2, 2}, {-1, 1},
  549. X  { 7, 0}, { 6, 0}, { 5, 0}, { 4, 0}, { 3, 0}, { 2, 0}, { 1, 0},
  550. X  {-7, 0}, {-6, 0}, {-5, 0}, {-4, 0}, {-3, 0}, {-2, 0}, {-1, 0},
  551. X  { 0, 7}, { 0, 6}, { 0, 5}, { 0, 4}, { 0, 3}, { 0, 2}, { 0, 1},
  552. X  { 0,-7}, { 0,-6}, { 0,-5}, { 0,-4}, { 0,-3}, { 0,-2}, { 0,-1}
  553. X};
  554. X
  555. X#define NB_M_KING 8
  556. Xstatic int m_king[][2] = {
  557. X  { 1, 1}, { 1, 0}, { 1,-1},
  558. X  {-1, 1}, {-1, 0}, {-1,-1},
  559. X  { 0, 1}, { 0, -1}
  560. X};
  561. X
  562. X
  563. X/* I/O */
  564. XFILE * infile ;
  565. XFILE * fhelp;
  566. X
  567. Xstatic char * t_output[] = 
  568. X{ "ascii", "postscript", "tex", "roff", "xchess", "gnu" };
  569. X
  570. X/* stack -- used for variation */
  571. X
  572. X/* stack element */
  573. Xtypedef struct {
  574. X  depl * d;
  575. X  game * b;
  576. X  
  577. X  /* we don't stack drivers, but only to variables */
  578. X  int d1,d2; /* iswhiteturn and interrupt */
  579. X} stack_elt ;
  580. X
  581. X/* size of the stack
  582. X   0 = ordinary play
  583. X   1 = level 1 variation
  584. X   2 = level 2 variation
  585. X   3 = level 3 variation
  586. X*/
  587. X#define VARIATION_MAX 3
  588. X
  589. X/* the stack itself */
  590. Xstatic stack_elt stack[VARIATION_MAX];
  591. X
  592. X/* top of the stack */
  593. X/* --> explicit in dr->variation */
  594. X
  595. X
  596. X/* ---------- automata definitions --------- */
  597. X/* table for syntaxic analysis of move */
  598. X
  599. X#define FINAL    10
  600. X#define TML     FINAL   /* terminal state */
  601. X#define NBETAT     11
  602. X#define NBCLAS     8
  603. X
  604. X/* successor of state */
  605. Xstatic int transit[NBETAT][NBCLAS] = { 
  606. X/*   P a-h 1-8   -   x   =  \0   ? */ 
  607. X/*(  0   1   2   3   4   5   6   7)*/
  608. X  {  1,  2, -1, -1, -1, -1, -1, -1 }, /* etat  0 */
  609. X  { -1,  2, -1, -1,  4, -1, -1, -1 }, /* etat  1 */
  610. X  { -1,  6,  3,  4,  4,  8,TML,TML }, /* etat  2 */
  611. X  { -1,  6, -1,  4,  4,  8,TML,TML }, /* etat  3 */
  612. X  {  5,  6, -1, -1, -1, -1, -1, -1 }, /* etat  4 */
  613. X  { -1,  6, -1, -1, -1, -1, -1, -1 }, /* etat  5 */
  614. X  { -1, -1,  7, -1, -1, -1, -1, -1 }, /* etat  6 */
  615. X  { -1, -1, -1, -1, -1,  8,TML,TML }, /* etat  7 */
  616. X  {  9, -1, -1, -1, -1, -1,TML, -1 }, /* etat  8 */
  617. X  { -1, -1, -1, -1, -1, -1,TML,TML }, /* etat  9 */
  618. X  { -1, -1, -1, -1, -1, -1, -1, -1 }  /* etat 10 == terminal */
  619. X};
  620. X
  621. X/* actions to do */
  622. Xstatic int action[NBETAT][NBCLAS] = {
  623. X/*   P a-h 1-8   -   x   =  \0   ? */ 
  624. X  {  1,  2, -1, -1, -1, -1, -1, -1 }, /* etat  0 */
  625. X  { -1,  2, -1, -1, 10, -1, -1, -1 }, /* etat  1 */
  626. X  { -1, 13,  3,  4,  5, 14,  6,  7 }, /* etat  2 */
  627. X  { -1, 13, -1,  4,  5, 14,  6,  7 }, /* etat  3 */
  628. X  {  1,  2, -1, -1, -1, -1, -1, -1 }, /* etat  4 */
  629. X  { -1,  2, -1, -1, -1, -1, -1, -1 }, /* etat  5 */
  630. X  { -1, -1,  3, -1, -1, -1, -1, -1 }, /* etat  6 */
  631. X  { -1, -1, -1, -1, -1, 14,  8,  9 }, /* etat  7 */
  632. X  { 15, -1, -1, -1, -1, -1, 17, -1 }, /* etat  8 */
  633. X  { -1, -1, -1, -1, -1, -1, 17, 17 }, /* etat  9 */
  634. X  { -1, -1, -1, -1, -1, -1, -1, -1 }  /* etat 10 */
  635. X};
  636. X
  637. X
  638. X/* the complete play */
  639. Xplay * theplay ;
  640. X
  641. X/* current game
  642. X   the name "tos" means "top of stack"
  643. X   */
  644. Xstatic game * tos = GULL ;
  645. X
  646. X/* variable holding current move */
  647. Xstatic depl * m = MULL ;
  648. X
  649. X
  650. Xint alternate_moves[10][2]; /* table of alternate moves, guessed by
  651. X                   the "move generator": guess depl
  652. X                   */
  653. X
  654. X
  655. X/* the output driver */
  656. Xstatic format * dr;
  657. X
  658. Xstatic int driver; /* driver type, ie gnu, ascii ... */
  659. X
  660. Xstatic int movecount;
  661. X
  662. X/* current move, used by the parser */
  663. Xstatic int curpiece,  curcol,  curlig ;
  664. Xstatic int curdigit, curmove;
  665. X
  666. X/* booleen d'erreur */
  667. Xint error_flag = FALSE;
  668. X
  669. X/* move to display board */
  670. Xstatic int count = 0 ;
  671. X
  672. Xstatic int move_to_display[NB_MOVE_TO_DISP] ;
  673. Xstatic int nb_move_to_dsp = 0;
  674. Xstatic int stop_at_display = FALSE;
  675. X
  676. X/* short and long form comment table */
  677. Xchar * com_short[] = {
  678. X#define CHESSSYMB(LET,LASC,SASC,TEX,PS,ENG,FRA) SASC,
  679. X#include "chesssymb.def"
  680. X ""
  681. X };
  682. X#undef CHESSSYMB
  683. X
  684. Xchar * com_long[] = {
  685. X#define CHESSSYMB(LET,LASC,SASC,TEX,PS,ENG,FRA) LASC,
  686. X#include "chesssymb.def"
  687. X ""
  688. X };
  689. X#undef CHESSSYMB
  690. X
  691. X
  692. X
  693. X#define setboard(A,I,J,P,C)  { (A)->board[(I)][(J)] = (P) ; \
  694. X                 (A)->color[(I)][(J)] = (C); }
  695. X#define clsboard(A,I,J)   { (A)->board[(I)][(J)] = VOID ; \
  696. X                (A)->color[(I)][(J)] = VOID ;}
  697. X
  698. X/* --------------------------- code part --------------------- */
  699. X
  700. X
  701. X#ifdef __STDC__
  702. Xstatic int ispiece(char c)
  703. X#else
  704. Xstatic int ispiece(c)
  705. X     char c;
  706. X#endif
  707. X{
  708. X  register int i;
  709. X  
  710. X  for ( i = 0 ; (i < NUMPIECES) && (c != in_table[i]) ; i++ ) ;
  711. X  /*(void) fprintf(stdout, "piece %d %c\n" , i , c);*/
  712. X  return(i<NUMPIECES);
  713. X}
  714. X
  715. X
  716. X#ifdef __STDC__
  717. Xstatic int piece(char c)
  718. X#else
  719. Xstatic int piece(c)
  720. X     char c ;
  721. X#endif
  722. X{
  723. X  register int i;
  724. X  
  725. X  for ( i = 0 ; (i < NUMPIECES) && (c != in_table[i]) ; i++ ) ;
  726. X  if ( i== NUMPIECES)
  727. X    i = PAWN ;
  728. X  return(i);
  729. X}
  730. X
  731. X/* this function returns the rank of a keyword in a given table.
  732. X   if key is not present, it returns the default value
  733. X   */
  734. X#ifdef __STDC__
  735. Xstatic int find_keyword(char *tab[], int nbentry,int defaut,
  736. X            char *key,int warning)
  737. X#else
  738. Xstatic int find_keyword(tab, nbentry,defaut,key,warning)
  739. X     char * tab[]; /* the table to look in */
  740. X     int nbentry;  /* number of entries */
  741. X     int defaut;  /* the default value to return if search failed */
  742. X     char *key;    /* the key to find */
  743. X     int warning;  /* do we display a warning ? */
  744. X#endif
  745. X{
  746. X  int i ;
  747. X
  748. X  for(i=0; (i< nbentry) ;i++)
  749. X    if (strcmp(tab[i],key)==0)
  750. X      return(i);
  751. X
  752. X  /* we failed to find the keyword */
  753. X  if (warning)
  754. X    (void) fprintf (stderr, "unknow keyword %s in this context\n",key);
  755. X  return(defaut);
  756. X}
  757. X
  758. X/* ---------- board management function ------------- */
  759. X
  760. X#ifdef __STDC__
  761. Xvoid clear_board(game *g)
  762. X#else
  763. Xvoid clear_board(g)
  764. X     game *g;
  765. X#endif
  766. X{
  767. X  register int i,j;
  768. X
  769. X  for (i=0; i < 10; i++ )
  770. X    for (j=0 ; j< 10 ; j++) {
  771. X      g->board[i][j] = VOID;
  772. X      g->color[i][j] = VOID;
  773. X    }
  774. X}
  775. X
  776. X#ifdef __STDC__
  777. Xgame * new_board(void)
  778. X#else
  779. Xgame * new_board()
  780. X#endif
  781. X{
  782. X  game * tmp;
  783. X  int i; 
  784. X
  785. X  tmp = (game *) malloc (sizeof(game));
  786. X  ALLOCP(tmp);
  787. X  for (i=0; i < ((sizeof (game))/ sizeof (int)) ; i++)
  788. X    ((int *) tmp)[i] = 0;
  789. X  return(tmp);
  790. X}
  791. X
  792. X#ifdef __STDC__
  793. Xgame * copy_board(game *from, game *to)
  794. X#else
  795. Xgame * copy_board(from, to)
  796. X     game * from;
  797. X     game * to;
  798. X#endif
  799. X{
  800. X  int i; 
  801. X
  802. X  for (i=0; i < ((sizeof (game))/ sizeof (int)) ; i++)
  803. X    ((int *) to)[i] =  ((int *) from)[i] ;
  804. X  return(to);
  805. X}
  806. X
  807. X#ifdef __STDC__
  808. Xvoid init_board(game *tgm)
  809. X#else
  810. Xvoid init_board(tgm)
  811. X  game * tgm;
  812. X#endif
  813. X{
  814. X  register int i,j;
  815. X
  816. X  clear_board(tgm);
  817. X
  818. X  for (i=1; i< 9 ; i=i+7) {
  819. X    tgm->board[i][1]= tgm->board[i][8] = ROOK ;
  820. X    tgm->board[i][2]= tgm->board[i][7] = KNIGHT ;
  821. X    tgm->board[i][3]= tgm->board[i][6] = BISHOP ;
  822. X    tgm->board[i][4]= QUEEN;
  823. X    tgm->board[i][5]= KING;
  824. X  }
  825. X  for (i=2; i< 8 ; i=i+5) 
  826. X    for (j=1; j <=8 ; j++)
  827. X      tgm->board[i][j] = PAWN;
  828. X
  829. X  for (i=1; i <=2; i++)
  830. X    for (j=1; j <=8 ; j++) {
  831. X      tgm->color[i][j] = WHITE;
  832. X      tgm->color[i+6][j] = BLACK ;
  833. X    }
  834. X}
  835. X
  836. X#ifdef __STDC__
  837. Xdepl * new_move(void)
  838. X#else
  839. Xdepl * new_move()
  840. X#endif
  841. X{
  842. X  depl * tmp;
  843. X  int i; 
  844. X  static int counter = 0;
  845. X
  846. X  tmp = (depl *) malloc (sizeof(depl));
  847. X  ALLOCP(tmp);
  848. X  for (i=0; i < ((sizeof (depl))/ sizeof (int)) ; i++)
  849. X    ((int *) tmp)[i] = 0;
  850. X  tmp->uid = ++counter;
  851. X  tmp->whiteturn = FALSE;
  852. X  tmp->move = 0;
  853. X  return(tmp);
  854. X}
  855. X
  856. X
  857. X#ifdef __STDC__
  858. Xvoid init_move(depl *m)
  859. X#else
  860. Xvoid init_move(m)
  861. X     depl *m;
  862. X#endif
  863. X{
  864. X  m->move= 1 ;
  865. X  m->whiteturn = TRUE ;
  866. X}
  867. X
  868. X#ifdef __STDC__
  869. Xdepl * copy_move(depl *from,depl *to)
  870. X#else
  871. Xdepl * copy_move(from,to)
  872. X     depl * from;
  873. X     depl * to ;
  874. X#endif
  875. X{
  876. X  int i; 
  877. X
  878. X  for (i=0; i < ((sizeof (depl))/ sizeof (int)) ; i++)
  879. X    ((int *) to)[i] = ((int *) from)[i];
  880. X
  881. X  return(to);
  882. X}
  883. X
  884. X/* add a new move as successor to the move m */
  885. X#ifdef __STDC__
  886. Xdepl * add_trailing_move(depl *mo)
  887. X#else
  888. Xdepl * add_trailing_move(mo)
  889. X     depl * mo;
  890. X#endif
  891. X{
  892. X  mo->next = new_move();
  893. X
  894. X  mo->next->prev = mo;
  895. X  mo->next->next = (depl *) NULL;
  896. X  mo->next->sub  = (depl *) NULL;
  897. X
  898. X  mo->next->whiteturn = !( m->whiteturn ) ;
  899. X  mo->next->move = mo->move;
  900. X  if ( mo->next->whiteturn) {
  901. X    mo->next->move++;
  902. X  }
  903. X
  904. X  return(mo->next);
  905. X}
  906. X
  907. X#ifdef __STDC__
  908. Xstatic depl * add_variation(depl *mo)
  909. X#else
  910. Xstatic depl * add_variation(mo)
  911. X     depl * mo;
  912. X#endif
  913. X{
  914. X  depl *ip ; /* insertion point */
  915. X
  916. X  ip = mo ;
  917. X  while (ip->sub != (depl *) NULL )
  918. X    ip = ip->sub ;
  919. X  
  920. X  ip->sub = new_move();
  921. X
  922. X  ip->sub->prev = mo;
  923. X  ip->sub->next = (depl *) NULL;
  924. X  ip->sub->sub  = (depl *) NULL;
  925. X  
  926. X  /* as we have a fictif element heading our list, 
  927. X     ( generated by add_trailing_move() )
  928. X     we have to go back in the numbering */
  929. X  ip->sub->whiteturn =  mo->prev->whiteturn  ;
  930. X  ip->sub->move = mo->prev->move ;
  931. X
  932. X  return(ip->sub);
  933. X}
  934. X
  935. X
  936. X#ifdef __STDC__
  937. Xstatic void free_move_list(depl *d)
  938. X#else
  939. Xstatic void free_move_list(d)
  940. X     depl * d;
  941. X#endif
  942. X{  
  943. X
  944. X  if (d->next != (depl *) NULL) {
  945. X    free_move_list(d->next);
  946. X    free(d->next);
  947. X    d->next = (depl *) NULL;
  948. X  }
  949. X  if (d->sub != (depl *) NULL) {
  950. X    free_move_list(d->sub);
  951. X    free(d->sub);
  952. X    d->sub = (depl *) NULL;
  953. X  }
  954. X}
  955. X  
  956. X/* procedure upadate borad g with move m */
  957. X#ifdef __STDC__
  958. Xvoid do_move(game *g,depl *m)
  959. X#else
  960. Xvoid do_move(g,m)
  961. X     game *g;
  962. X     depl *m;
  963. X#endif
  964. X{
  965. X  switch (m->type) {
  966. X  case MOVE:
  967. X    setboard(g,m->tolig,m->tocol,m->piece,CURCOLOR(m)) ;
  968. X    clsboard(g,m->fromlig,m->fromcol) ;
  969. X    break;
  970. X  case PRISE:
  971. X    setboard(g,m->tolig,m->tocol,m->piece,CURCOLOR(m)) ;
  972. X    clsboard(g,m->fromlig,m->fromcol);
  973. X    break;
  974. X  case GRANDROQUE:
  975. X    if (m->whiteturn)
  976. X      m->fromlig = 1;
  977. X    else 
  978. X      m->fromlig = 8;
  979. X    setboard(g,m->fromlig,3,KING,CURCOLOR(m)) ;
  980. X    setboard(g,m->fromlig,4,ROOK,CURCOLOR(m)) ;
  981. X    clsboard(g,m->fromlig,1) ;
  982. X    clsboard(g,m->fromlig,5) ;
  983. X    break;
  984. X  case PETITROQUE:
  985. X    if (m->whiteturn)
  986. X      m->fromlig = 1;
  987. X    else 
  988. X      m->fromlig = 8;
  989. X    setboard(g,m->fromlig,7,KING,CURCOLOR(m)) ;
  990. X    setboard(g,m->fromlig,6,ROOK,CURCOLOR(m)) ;
  991. X    clsboard(g,m->fromlig,5) ;
  992. X    clsboard(g,m->fromlig,8) ;
  993. X    break;
  994. X  case EN_PASSANT:
  995. X    setboard(g,m->tolig,m->tocol,m->piece,CURCOLOR(m)) ;
  996. X    clsboard(g,m->tolig,m->fromcol) ;
  997. X    clsboard(g,m->fromlig,m->fromcol) ;
  998. X    break;
  999. X  case PROMOTION:
  1000. X    setboard(g,m->tolig,m->tocol,m->piece,CURCOLOR(m)) ;
  1001. X    clsboard(g,m->fromlig,m->fromcol);
  1002. X    break;
  1003. X  case PROM_ET_PRISE:
  1004. X    setboard(g,m->tolig,m->tocol,m->piece,CURCOLOR(m)) ;
  1005. X    clsboard(g,m->fromlig,m->fromcol);
  1006. X    break;
  1007. X  default:
  1008. X    fprintf(stderr,"\nUnable to do move: unknown move type\n");
  1009. X    break;
  1010. X  }
  1011. X}
  1012. X
  1013. X
  1014. X
  1015. X/* this procedure undo the effect of move m on the board g */
  1016. X#ifdef __STDC__
  1017. Xvoid undo_move(game *g,depl *m)
  1018. X#else
  1019. Xvoid undo_move(g,m)
  1020. X     game *g;
  1021. X     depl *m;
  1022. X#endif
  1023. X{
  1024. X  switch (m->type) {
  1025. X  case MOVE:
  1026. X    clsboard(g,m->tolig,m->tocol) ;
  1027. X    setboard(g,m->fromlig,m->fromcol,m->piece,CURCOLOR(m)) ;
  1028. X    break;
  1029. X  case PRISE:
  1030. X    setboard(g,m->tolig,m->tocol,m->prise,OPPCOLOR(m)) ;
  1031. X    setboard(g,m->fromlig,m->fromcol,m->piece,CURCOLOR(m)) ;
  1032. X    break;
  1033. X  case GRANDROQUE:
  1034. X    if (m->whiteturn)
  1035. X      m->fromlig = 1;
  1036. X    else 
  1037. X      m->fromlig = 8;
  1038. X    clsboard(g,m->fromlig,3) ;
  1039. X    clsboard(g,m->fromlig,4) ;
  1040. X    setboard(g,m->fromlig,5,KING,CURCOLOR(m)) ;
  1041. X    setboard(g,m->fromlig,1,ROOK,CURCOLOR(m)) ;
  1042. X    break;
  1043. X  case PETITROQUE:
  1044. X    if (m->whiteturn)
  1045. X      m->fromlig = 1;
  1046. X    else 
  1047. X      m->fromlig = 8;
  1048. X    clsboard(g,m->fromlig,6) ;
  1049. X    clsboard(g,m->fromlig,7) ;
  1050. X    setboard(g,m->fromlig,5,KING,CURCOLOR(m)) ;
  1051. X    setboard(g,m->fromlig,8,ROOK,CURCOLOR(m)) ;
  1052. X    break;
  1053. X  case EN_PASSANT:
  1054. X    clsboard(g,m->tolig,m->tocol) ;
  1055. X    setboard(g,m->tolig,m->fromcol,PAWN,OPPCOLOR(m)) ;
  1056. X    setboard(g,m->fromlig,m->fromcol,m->piece,CURCOLOR(m)) ;
  1057. X    break;
  1058. X  case PROMOTION:
  1059. X    clsboard(g,m->tolig,m->tocol);
  1060. X    setboard(g,m->fromlig,m->fromcol,PAWN,CURCOLOR(m)) ;
  1061. X    break;
  1062. X  case PROM_ET_PRISE:
  1063. X    setboard(g,m->tolig,m->tocol,m->prise,OPPCOLOR(m)) ;
  1064. X    setboard(g,m->fromlig,m->fromcol,PAWN,CURCOLOR(m)) ;
  1065. X    break;
  1066. X  default:
  1067. X    fprintf(stderr,"\nUnable to undo move: unknown move type\n");
  1068. X    break;
  1069. X  }
  1070. X}
  1071. X
  1072. X/* variation procedures == stack manipulation */
  1073. X
  1074. X#ifdef __STDC__
  1075. Xvoid enter_variation(void)
  1076. X#else
  1077. Xvoid enter_variation()
  1078. X#endif
  1079. X{
  1080. X  int l;
  1081. X
  1082. X  l = dr->variation ;
  1083. X  
  1084. X  if (l >= VARIATION_MAX) {
  1085. X    error((stderr,"\nMaximum imbricated variation is %d\n",VARIATION_MAX));
  1086. X  } else {
  1087. X    /* save current line/variation */
  1088. X    stack[l].d = m;
  1089. X    stack[l].b = tos;
  1090. X    stack[l].d1 = dr->iswhiteturn;
  1091. X    stack[l].d2 = dr->interrupt = TRUE ;    
  1092. X    /* create new */
  1093. X    tos = new_board();
  1094. X    (void) copy_board(stack[l].b, tos);
  1095. X
  1096. X    /* A variation FOLLOWS the main line 
  1097. X       so we need to backtrack one move
  1098. X       */
  1099. X    m = add_variation(stack[l].d);
  1100. X    undo_move(tos,stack[l].d);
  1101. X
  1102. X    /* set variables */
  1103. X    l++;
  1104. X    dr->variation = l;
  1105. X
  1106. X    output_variation(dr,VARIATION_IN);
  1107. X  }
  1108. X}
  1109. X
  1110. X#ifdef __STDC__
  1111. Xvoid exit_variation(void)
  1112. X#else
  1113. Xvoid exit_variation()
  1114. X#endif
  1115. X{
  1116. X  int l ;
  1117. X
  1118. X  l = dr->variation ;
  1119. X  
  1120. X  if (l == 0) {
  1121. X    error((stderr,"\nYou cannot exit from the main line (a variation level error?)\n"));
  1122. X  } else {
  1123. X    output_variation(dr,VARIATION_OUT);
  1124. X
  1125. X    l--;
  1126. X    free(tos);
  1127. X    free(m);
  1128. X    m = stack[l].d ;
  1129. X    tos = stack[l].b ;
  1130. X
  1131. X    dr->iswhiteturn = stack[l].d1 ;
  1132. X    dr->interrupt = stack[l].d2 ;
  1133. X    dr->variation = l;
  1134. X  }
  1135. X}
  1136. X
  1137. X/* ----------- semantic evaluation of move ----------- */
  1138. X/* check if  position lies within the board
  1139. X   */
  1140. X#ifdef __STDC__
  1141. Xint in_board(int l,int c)
  1142. X#else
  1143. Xint in_board(l,c)
  1144. X     int l,c;
  1145. X#endif
  1146. X{
  1147. X  return ((c >= 1) && (c <= 8) && (l >= 1) && (l <= 8));
  1148. X}
  1149. X
  1150. X/* check that the path from pos1 to pos2 is free
  1151. X   */
  1152. X#ifdef __STDC__
  1153. Xint path_free(int l1,int c1,int l2,int c2)
  1154. X#else
  1155. Xint path_free(l1, c1, l2, c2)
  1156. Xint l1,c1, l2, c2;
  1157. X#endif
  1158. X{
  1159. X  int li = 1 ;
  1160. X  int ci = 1 ;
  1161. X  int lig, col;
  1162. X
  1163. X
  1164. X  li = SIGN(l2-l1);
  1165. X  ci = SIGN(c2-c1);
  1166. X
  1167. X
  1168. X  if ( c1 == c2 ) {    
  1169. X    col = c1;
  1170. X    for (lig = l1 +li; lig != l2 ; lig +=li)
  1171. X      if (tos->board[lig][col] != VOID)
  1172. X    return (FALSE);
  1173. X    return(TRUE);
  1174. X  }
  1175. X
  1176. X  if ( l1 == l2) {
  1177. X    lig = l1 ;
  1178. X    for (col = c1 + ci; col != c2 ; col +=ci)
  1179. X      if (tos->board[lig][col] != VOID)
  1180. X    return (FALSE);
  1181. X    return(TRUE);
  1182. X  }
  1183. X
  1184. X  for (lig = l1+li,col =c1+ci; (lig!=l2) && (col!=c2); lig+=li, col+= ci)
  1185. X    if (tos->board[lig][col] != VOID) {
  1186. X      return (FALSE);
  1187. X    }
  1188. X  return(TRUE);
  1189. X}
  1190. X
  1191. X/* check roque is possible */
  1192. X#ifdef __STDC__
  1193. Xint check_roque(void)
  1194. X#else
  1195. Xint check_roque()
  1196. X#endif
  1197. X{
  1198. X  int lig, col ;
  1199. X
  1200. X  if (m->whiteturn)
  1201. X    lig = 1 ;
  1202. X  else
  1203. X    lig =8;
  1204. X  if (m->type == GRANDROQUE)
  1205. X    for (col = 2; col < 5 ; col++)
  1206. X      if (tos->board[lig][col] != VOID)
  1207. X    return(FALSE);
  1208. X  if (m->type == PETITROQUE)
  1209. X    for (col = 6; col < 7 ; col++)
  1210. X      if (tos->board[lig][col] != VOID)
  1211. X    return(FALSE);
  1212. X  return(TRUE);
  1213. X}
  1214. X  
  1215. X/* check -- or guess -- where a given piece come */
  1216. X#ifdef __STDC__
  1217. Xint guess_piece(void) 
  1218. X#else
  1219. Xint guess_piece() 
  1220. X#endif
  1221. X{
  1222. X  return(tos->board[m->fromlig][m->fromcol]); 
  1223. X}
  1224. X
  1225. X/* try to guess the move -- low-level function 
  1226. X   it returns -- in the parms -- the coordinates of a possible move
  1227. X   it returns -- as value -- the number of possible move
  1228. X */
  1229. X#ifdef __STDC__
  1230. Xint guess_depl(int nb, int tab[][2],
  1231. X           int * pl1, int * pc1, int l2, int c2, int path)
  1232. X#else
  1233. Xint guess_depl(nb, tab, pl1, pc1, l2,c2,path)
  1234. X     int nb;
  1235. X     int tab[10][2];
  1236. X     int *pl1, *pc1;
  1237. X     int l2,c2;
  1238. X     int path; /* tell if we have to check for a free path 
  1239. X          used for en passant */
  1240. X#endif
  1241. X{
  1242. X  int i, c, l;
  1243. X  int count = 0;
  1244. X
  1245. X  for (i=0; i< nb; i++ ) {
  1246. X    l = l2 - tab[i][0];
  1247. X    c = c2 - tab[i][1];
  1248. X    if (in_board(l,c))
  1249. X      if ((tos->board[l][c] == m->piece) &&
  1250. X      (tos->color[l][c] == CURCOLOR(m)) &&
  1251. X      ( !path || (path && path_free(l,c, l2, c2))) &&
  1252. X      ( ((*pl1) == 0) || ((*pl1) == l) ) &&
  1253. X      ( ((*pc1) == 0) || ((*pc1) == c) ) )
  1254. X    {
  1255. X      alternate_moves[count][0] = l;
  1256. X      alternate_moves[count][1] = c;
  1257. X      count++;
  1258. X    }
  1259. X  }
  1260. X  alternate_moves[count][0] = alternate_moves[count][1] = 0;
  1261. X  if (count > 0) {
  1262. X    /* we return the first entry because the last entry, in the case of pawn,
  1263. X       movement, might be a catching move, even it a non-catching, more 
  1264. X       probable, is present
  1265. X       */
  1266. X    *pl1 = alternate_moves[0][0];
  1267. X    *pc1 = alternate_moves[0][1];
  1268. X  }
  1269. X  return(count);
  1270. X}
  1271. X
  1272. X/* check for ambiguity in a move
  1273. X   used in output function: the piece had been already moved and
  1274. X   if we guess another move, there is an ambiguity
  1275. X   */
  1276. X#ifdef __STDC__
  1277. Xint ambiguity(depl *d, int *amline, int *amcols)
  1278. X#else
  1279. Xint ambiguity(d, amline, amcols )
  1280. X     depl *d ;
  1281. X     int * amline;
  1282. X     int *amcols;
  1283. X#endif
  1284. X{
  1285. X  int l1 = 0 ;
  1286. X  int c1 = 0 ;
  1287. X  int r = 0;
  1288. X  int frompiece = d->piece;
  1289. X  int l2 = d->tolig;
  1290. X  int c2 = d->tocol ;
  1291. X  int i;
  1292. X
  1293. X  undo_move(tos,m);
  1294. X
  1295. X
  1296. X  switch(frompiece) {
  1297. X  case PAWN:
  1298. X    if (m->type == PRISE) {
  1299. X      if (m->whiteturn)
  1300. X    r = guess_depl(NB_M_PAWN_WX, m_pawn_wx, &l1,&c1, l2,c2, FALSE);
  1301. X      else
  1302. X    r = guess_depl(NB_M_PAWN_BX, m_pawn_bx, &l1,&c1, l2,c2, FALSE);
  1303. X    } else {
  1304. X      if (m->whiteturn)
  1305. X    r = guess_depl(NB_M_PAWN_MOVE_WD,m_pawn_move_wd,&l1,&c1, l2,c2, FALSE);
  1306. X      else
  1307. X    r = guess_depl(NB_M_PAWN_MOVE_BD,m_pawn_move_bd,&l1,&c1,l2,c2, FALSE);
  1308. X    }
  1309. X    break;
  1310. X  case KNIGHT:
  1311. X    r = guess_depl(NB_M_KNIGHT, m_knight, &l1,&c1, l2,c2, FALSE);
  1312. X    break;
  1313. X  case BISHOP:
  1314. X    r = guess_depl(NB_M_BISHOP, m_bishop, &l1,&c1, l2,c2, TRUE);
  1315. X    break;
  1316. X  case ROOK:
  1317. X    r = guess_depl(NB_M_ROOK,   m_rook,   &l1,&c1, l2,c2, TRUE);
  1318. X    break;
  1319. X  case QUEEN:
  1320. X    r = guess_depl(NB_M_QUEEN,  m_queen,  &l1,&c1, l2,c2, TRUE);
  1321. X    break;
  1322. X  case KING:
  1323. X    r = guess_depl(NB_M_KING,   m_king,   &l1,&c1, l2,c2, TRUE);
  1324. X    break;
  1325. X  default:
  1326. X    break;
  1327. X  }
  1328. X  do_move(tos,m);
  1329. X
  1330. X  if (r > 1) {
  1331. X    /* we have an ambiguity, we use alternate_moves to resolve it:
  1332. X       we look through that table to find identical lines: if so, 
  1333. X       we signal that the column determines move; 
  1334. X       we then do the same with columns
  1335. X       */
  1336. X    *amline = TRUE ;
  1337. X    *amcols = TRUE ;
  1338. X    for (i= 1; i < r ; i++) {
  1339. X      if (alternate_moves[i][0] != alternate_moves[0][0])
  1340. X    *amline = FALSE;
  1341. X      if (alternate_moves[i][1] != alternate_moves[0][1])
  1342. X    *amcols = FALSE;
  1343. X    }
  1344. X  }
  1345. X  return( (r > 1) );
  1346. X}
  1347. X
  1348. X#ifdef __STDC__
  1349. Xint check_move(depl *m)
  1350. X#else
  1351. Xint check_move(m)
  1352. X     depl * m;
  1353. X#endif
  1354. X{
  1355. X  int l1,c1,l2,c2;
  1356. X  int tmp; /* tmp boolean */
  1357. X 
  1358. X  l1 = m->fromlig;
  1359. X  c1 = m->fromcol;
  1360. X  l2 = m->tolig;
  1361. X  c2 = m->tocol;
  1362. X
  1363. X  if ((m->type == GRANDROQUE) || (m->type == PETITROQUE))
  1364. X    return(check_roque());
  1365. X
  1366. X  if ((tos->board[l1][c1] != m->piece)||
  1367. X      (tos->color[l1][c1] != CURCOLOR(m))){
  1368. X    fprintf(stderr,"Problem: piece should be %c\n",in_table[tos->board[l1][c1]]);
  1369. X    if (m->whiteturn)
  1370. X      error ((stderr,"\nOriginating position and piece not coherent for White move %d\n",m->move));
  1371. X    else
  1372. X      error ((stderr,"\nOriginating position and piece not coherent for Black move %d\n",m->move));
  1373. X    return(FALSE);
  1374. X  }
  1375. X
  1376. X  /* if prise === FALSE, we must not take a piece */
  1377. X  if (tos->board[l2][c2] != VOID 
  1378. X      && (m->type != PRISE) && (m->type != PROM_ET_PRISE)) {
  1379. X    (void) fprintf(stderr,"catching not indicated at move %d.\n",m->move);
  1380. X    return(FALSE);
  1381. X  }
  1382. X
  1383. X  /* prendre une de ses propres pieces */
  1384. X  if (tos->color[l2][c2] == tos->color[l1][c1] && m->prise) {
  1385. X    (void) fprintf(stderr,"attempt to catch same color piece at move %d.\n",
  1386. X           m->move);
  1387. X    return(FALSE);
  1388. X  }
  1389. X
  1390. X  /* we check if the move is a possible one for the piece
  1391. X     */
  1392. X
  1393. X  switch(m->piece) {
  1394. X  case PAWN:
  1395. X    if (m->prise) {
  1396. X      if (m->whiteturn)
  1397. X    tmp = guess_depl(NB_M_PAWN_WX, m_pawn_wx, &l1,&c1, l2,c2, FALSE);
  1398. X      else
  1399. X    tmp = guess_depl(NB_M_PAWN_BX, m_pawn_bx, &l1,&c1, l2,c2, FALSE);
  1400. X    } else {
  1401. X      if (m->whiteturn)
  1402. X    tmp = guess_depl(NB_M_PAWN_WD, m_pawn_wd, &l1,&c1, l2,c2, FALSE);
  1403. X      else
  1404. X    tmp = guess_depl(NB_M_PAWN_BD, m_pawn_bd, &l1,&c1, l2,c2, FALSE);
  1405. X    }
  1406. X    /* is it a "prise en passant " */
  1407. X    if ((c1 != c2) && (tos->board[l2][c2] == VOID)
  1408. X    && (tos->board[l1][c2] == PAWN)) {
  1409. X      m->type = EN_PASSANT ;
  1410. X      /* we must perform here the "en passant" test */
  1411. X      tos->board[l1][c2] = VOID ;
  1412. X      tos->color[l1][c2] = VOID ;
  1413. X      tmp = TRUE;
  1414. X    }
  1415. X    return(tmp);
  1416. X    break;
  1417. X  case KNIGHT:
  1418. X    return(guess_depl(NB_M_KNIGHT, m_knight, &l1,&c1, l2,c2, FALSE));
  1419. X    break;
  1420. X  case BISHOP:
  1421. X    return(guess_depl(NB_M_BISHOP, m_bishop, &l1,&c1, l2,c2, TRUE));
  1422. X    break;
  1423. X  case ROOK:
  1424. X    return(guess_depl(NB_M_ROOK,   m_rook,   &l1,&c1, l2,c2, TRUE));
  1425. X    break;
  1426. X  case QUEEN:
  1427. X    return(guess_depl(NB_M_QUEEN,  m_queen,  &l1,&c1, l2,c2, TRUE));
  1428. X    break;
  1429. X  case KING:
  1430. X    return(guess_depl(NB_M_KING,   m_king,   &l1,&c1, l2,c2, TRUE));
  1431. X    break;
  1432. X  default:
  1433. X    break;
  1434. X  }
  1435. X
  1436. X  return(TRUE);
  1437. X}
  1438. X
  1439. X/* try to guess the move -- used for shortened notation
  1440. X   */
  1441. X#ifdef __STDC__
  1442. Xint guess_move(void)
  1443. X#else
  1444. Xint guess_move()
  1445. X#endif
  1446. X{
  1447. X  int l1,c1,l2,c2;
  1448. X
  1449. X  if ((m->type == GRANDROQUE) || (m->type == PETITROQUE))
  1450. X    return(TRUE);
  1451. X
  1452. X  l1 = m->fromlig ;
  1453. X  c1 = m->fromcol ;
  1454. X  l2 = m->tolig;
  1455. X  c2 = m->tocol;
  1456. X
  1457. X  switch(m->piece) {
  1458. X  case PAWN:
  1459. X    if (m->prise) {
  1460. X      if (m->whiteturn)
  1461. X    (void) guess_depl(NB_M_PAWN_WX, m_pawn_wx, &l1,&c1, l2,c2, FALSE);
  1462. X      else
  1463. X    (void) guess_depl(NB_M_PAWN_BX, m_pawn_bx, &l1,&c1, l2,c2, FALSE);
  1464. X    } else {
  1465. X      if (m->whiteturn)
  1466. X    (void) guess_depl(NB_M_PAWN_WD, m_pawn_wd, &l1,&c1, l2,c2, FALSE); 
  1467. X      else
  1468. X    (void) guess_depl(NB_M_PAWN_BD, m_pawn_bd, &l1,&c1, l2,c2, FALSE); 
  1469. X    }
  1470. X    break;
  1471. X  case KNIGHT:
  1472. X    (void) guess_depl(NB_M_KNIGHT, m_knight, &l1,&c1, l2,c2, FALSE);
  1473. X    break;
  1474. X  case BISHOP:
  1475. X    (void) guess_depl(NB_M_BISHOP, m_bishop, &l1,&c1, l2,c2, TRUE);
  1476. X    break;
  1477. X  case ROOK:
  1478. X    (void) guess_depl(NB_M_ROOK, m_rook, &l1,&c1, l2,c2, TRUE);
  1479. X    break;
  1480. X  case QUEEN:
  1481. X    (void) guess_depl(NB_M_QUEEN, m_queen, &l1,&c1, l2,c2, TRUE);
  1482. X    break;
  1483. X  case KING:
  1484. X    (void) guess_depl(NB_M_KING, m_king, &l1,&c1, l2,c2, TRUE);
  1485. X    break;
  1486. X  default:
  1487. X    break;
  1488. X  }
  1489. X
  1490. X  if ((l1 == 0) || (c1 == 0)) {
  1491. X    if (m->whiteturn)
  1492. X      error((stderr,"\nUnable to guess white move %d, with piece %c\n",
  1493. X         m->move,in_table[m->piece]));
  1494. X    else
  1495. X      error((stderr,"\nUnable to guess black move %d, with piece %c\n",
  1496. X         m->move,in_table[m->piece]));
  1497. X    return(FALSE);
  1498. X  } else {
  1499. X    m->fromcol = c1;
  1500. X    m->fromlig = l1;
  1501. X    return(TRUE);
  1502. X  }
  1503. X}
  1504. X
  1505. X/* --------------- execution of move ----------------- */
  1506. X
  1507. X/* clear a position */
  1508. X#ifdef __STDC__
  1509. Xint clear_pos(int lig, int col)
  1510. X#else
  1511. Xint clear_pos(lig,col)
  1512. X     int lig;
  1513. X     int col;
  1514. X#endif
  1515. X{
  1516. X  tos->board[lig][col] = VOID ;
  1517. X  tos->color[lig][col] = VOID ;
  1518. X  return(TRUE);
  1519. X}
  1520. X
  1521. X/* configure the board */
  1522. X#ifdef __STDC__
  1523. Xint configure(void)
  1524. X#else
  1525. Xint configure()
  1526. X#endif
  1527. X{
  1528. X  if (configuring) {
  1529. X    if (m->piece == VOID)
  1530. X      m->piece = PAWN ;
  1531. X    tos->board[m->tolig][m->tocol] = m->piece ;
  1532. X    tos->color[m->tolig][m->tocol] = configside ;
  1533. X  }
  1534. X  return(TRUE);
  1535. X}
  1536. X
  1537. X/* execute a move, no checking */
  1538. X#ifdef __STDC__
  1539. Xint execute_move(void)
  1540. X#else
  1541. Xint execute_move()
  1542. X#endif
  1543. X{
  1544. X  register int i;
  1545. X
  1546. X  if (m->piece == VOID )
  1547. X    m->piece = PAWN;
  1548. X
  1549. X  if ((m->fromlig == 0) || (m->fromcol == 0))
  1550. X    (void) guess_move();
  1551. X  
  1552. X  /* supply to the -- maybe -- deficiency of input notation
  1553. X     */
  1554. X  if ((m->fromlig !=0) || (m->fromcol != 0))
  1555. X    m->piece = tos->board[m->fromlig][m->fromcol];
  1556. X
  1557. X  if (tos->board[m->tolig][m->tocol] != VOID) {
  1558. X    m->type = PRISE;
  1559. X    m->prise = tos->board[m->tolig][m->tocol] ;
  1560. X  }
  1561. X
  1562. X  if (!check_move(m)) {
  1563. X    if (m->whiteturn)
  1564. X      error((stderr,"\nWhite move %d illegal\n",m->move));
  1565. X    else
  1566. X      error((stderr,"\nBlack move %d illegal\n",m->move));
  1567. X  }
  1568. X
  1569. X  do_move(tos, m);
  1570. X
  1571. X  output_move(dr,m);
  1572. X
  1573. X  if (error_flag) {
  1574. X    (void) fprintf(dr->outfile, "\nLast position encountered:\n");
  1575. X    output_board(dr,tos);
  1576. X    close_files();
  1577. X    exit(0);
  1578. X  }
  1579. X
  1580. X  /* do we need to display the move ? */
  1581. X  if (nb_move_to_dsp > 0) {
  1582. X    for (i=0; i < nb_move_to_dsp; i++)
  1583. X      if (m->move == (move_to_display[i] ) && !m->whiteturn ) {
  1584. X    output_board(dr,tos);
  1585. X    if (stop_at_display) {
  1586. X      output_end(dr);
  1587. X      close_files();
  1588. X      exit(0);
  1589. X    }
  1590. X      }
  1591. X  }
  1592. X
  1593. X  return(TRUE);
  1594. X}
  1595. X
  1596. X/* ------------------ automata ----------------------- */
  1597. X
  1598. X/* categorise the input for the automata */
  1599. X#ifdef __STDC__
  1600. Xint typechar(char c)
  1601. X#else
  1602. Xint typechar(c)
  1603. X     char c;
  1604. X#endif
  1605. X{
  1606. X  if (ispiece(c))
  1607. X    return(0);
  1608. X  if ((c >=  'a') && ( c <= 'h'))
  1609. X    return(1);
  1610. X  if ((c >=  '1') && ( c <= '8'))
  1611. X    return(2);
  1612. X  if ( c== '-' )
  1613. X    return(3);
  1614. X  if ((c == 'x') || (c == 'X' ))
  1615. X    return(4);
  1616. X  if (c == '=' )
  1617. X    return(5);
  1618. X  if (c == '\0' )
  1619. X    return(6);
  1620. X  return(7);
  1621. X}
  1622. X
  1623. X
  1624. X/* execute the actions decided by the automata */
  1625. X#ifdef __STDC__
  1626. Xint execute(int num,char c)
  1627. X#else
  1628. Xint execute(num,c)
  1629. X     int num;
  1630. X     char c;
  1631. X#endif
  1632. X{
  1633. X  switch (num) {
  1634. X  case 1: /* set cur piece */
  1635. X    curpiece = piece(c);
  1636. X    break;
  1637. X  case 2: /* set cur col */
  1638. X    curcol = lettertocol(c);
  1639. X    break;
  1640. X  case 3: /* set cur lig */
  1641. X    curlig = lettertolig(c);
  1642. X    break;
  1643. X  case 4: /* from = cur ; prise = false */
  1644. X    m->piece = curpiece ;
  1645. X    m->fromcol = curcol ;
  1646. X    m->fromlig = curlig;
  1647. X    /*m->topiece = curpiece;*/
  1648. X    break;
  1649. X  case 5: /* from = cur ; prise = true */
  1650. X    m->piece = curpiece ;
  1651. X    m->fromcol = curcol ;
  1652. X    m->fromlig = curlig;
  1653. X    m->type = PRISE ;
  1654. X    m->prise = curpiece;
  1655. X    break;
  1656. X  case 6: /* to = cur ; guess from */
  1657. X  case 7: /* to = cur ; guess from ; parse remaining token */
  1658. X    m->piece = curpiece ;
  1659. X    m->tocol = curcol;
  1660. X    m->tolig = curlig ;
  1661. X
  1662. X    /*m->topiece = curpiece ; /* ? */
  1663. X
  1664. X    if (configuring)
  1665. X      (void) configure();
  1666. X    else {
  1667. X      (void) execute_move();
  1668. X    }
  1669. X    break;
  1670. X  case 8: /* to = cur */
  1671. X  case 9: /* to = cur */
  1672. X    m->tocol = curcol;
  1673. X    m->tolig = curlig ;
  1674. X
  1675. X    if (configuring)
  1676. X      (void) configure();
  1677. X    else {
  1678. X      (void) execute_move();
  1679. X    }
  1680. X    break;
  1681. X  case 10: /* piece = cur piece ; prise = true */
  1682. X    /* later : guess from position */
  1683. X    m->piece = curpiece ;
  1684. X    m->type = PRISE ;
  1685. X    break;
  1686. X  case 11: /* grand roque */
  1687. X  case 12: /* petit roque */
  1688. X    (void) execute_move();
  1689. X    break;
  1690. X  case 13: /* case of simpliest algebraic notation ;
  1691. X          only e2e4 : this is the transition from e2 to e4
  1692. X          also the case of move such as Nge2
  1693. X          from =cur; prise = FALSE;
  1694. X          also:
  1695. X          curcol = ...
  1696. X          */
  1697. X    m->piece = curpiece ;
  1698. X    m->fromcol = curcol ;
  1699. X    m->fromlig = curlig;
  1700. X
  1701. X    m->type = MOVE;
  1702. X    curcol = lettertocol(c);
  1703. X    break;
  1704. X  case 14: /* promotion, the "=" */
  1705. X    /* NB: actions need some clean up here */
  1706. X    /* to = cur */
  1707. X
  1708. X    m->tocol = curcol;
  1709. X    m->tolig = curlig ;
  1710. X    /*m->topiece = curpiece ;*/
  1711. X
  1712. X    if (m->type == PRISE )
  1713. X      m->type = PROM_ET_PRISE ;
  1714. X    else
  1715. X      m->type = PROMOTION ;
  1716. X    /* by default, we promote to queen 
  1717. X       this can be overwritten by explicit naming
  1718. X       */
  1719. X    m->promotion = curpiece = QUEEN ;
  1720. X    break;
  1721. X  case 15: /* promotion, the piece name */
  1722. X    m->promotion = curpiece = piece(c) ;
  1723. X    break;
  1724. X  case 16: /* not used */ 
  1725. X    break;
  1726. X  case 17: /* execute move for promotion */
  1727. X    (void) execute_move();
  1728. X    break;
  1729. X  case -1:
  1730. X    break;
  1731. X  default:
  1732. X    break;
  1733. X  }
  1734. X  return(TRUE);
  1735. X}
  1736. X
  1737. X#ifdef __STDC__
  1738. Xint parse_number(char *token)
  1739. X#else
  1740. Xint parse_number(token)
  1741. X     char *token;
  1742. X#endif
  1743. X{
  1744. X  int curmove = 0 ;
  1745. X  int i;
  1746. X
  1747. X  /* check coherency with internal numbering */
  1748. X  i = 0;
  1749. X  while (isdigit(token[i])) {
  1750. X   curmove = curmove * 10 +  ((int) token[i++] - (int) '0' );
  1751. X  }
  1752. X  movecount = curmove ;
  1753. X  return(TRUE);
  1754. X}
  1755. X
  1756. X#ifdef __STDC__
  1757. Xint parse_text(char *text)
  1758. X#else
  1759. Xint parse_text(text)
  1760. X     char *text;
  1761. X#endif
  1762. X{
  1763. X  output_text(dr,T_TEXT, text, 0);
  1764. X  return(TRUE);
  1765. X}
  1766. X
  1767. X#ifdef __STDC__
  1768. Xint parse_comment(char *com)
  1769. X#else
  1770. Xint parse_comment(com)
  1771. X     char *com;
  1772. X#endif
  1773. X{
  1774. X  int t;
  1775. X
  1776. X  if (com[0] == '$')
  1777. X    /* we look in the long ascii table */
  1778. X    t = find_keyword(com_long, NUM_COM_CODE, NUM_COM_CODE, com, TRUE);
  1779. X  else {
  1780. X    /* we look for the comment in the short ascii table */
  1781. X    t = find_keyword(com_short, NUM_COM_CODE, NUM_COM_CODE, com,FALSE);
  1782. X    if (t == NUM_COM_CODE)
  1783. X      fprintf (stderr,"\nWhat is \"%s\" ?\n",com);   
  1784. X  }
  1785. X  if (t != NUM_COM_CODE)
  1786. X    output_text(dr,T_COMMENT, com, t);
  1787. X  return(TRUE);
  1788. X}
  1789. X
  1790. X#ifdef __STDC__
  1791. Xint parse_keyword(char *token, char *text)
  1792. X#else
  1793. Xint parse_keyword(token,text)
  1794. X     char *token;
  1795. X     char *text;
  1796. X#endif
  1797. X{
  1798. X  char c;
  1799. X
  1800. X  switch (find_keyword(keywords, NBKEYWORD, KNULL, token, TRUE)) {
  1801. X  case START:
  1802. X    /* don't forget we are configuring the previous move */
  1803. X    /* -> move 0, black */
  1804. X    configuring = FALSE;
  1805. X    m->move = 0;
  1806. X    m->whiteturn = FALSE;
  1807. X    break;
  1808. X  case CLEAR:
  1809. X    clear_board(tos);
  1810. X    m= theplay->chain;
  1811. X    free_move_list(m);
  1812. X    break;
  1813. X  case SHOWBOARD:
  1814. X    output_board(dr,tos);
  1815. X    break;
  1816. X  case TOWHITE:
  1817. X    /* don't forget we are configuring the previous move */
  1818. X    /* reset to 0,black --> 1,white */
  1819. X    m->move = 0;
  1820. X    m->whiteturn = FALSE;
  1821. X    break;
  1822. X  case TOBLACK:
  1823. X    /* reset to 1,white -> 1 black */
  1824. X    m->move = 1;
  1825. X    m->whiteturn = TRUE;
  1826. X    break;
  1827. X  case CONFIGWH:
  1828. X    configuring = TRUE ;
  1829. X    configside = WHITE;
  1830. X    m= theplay->chain;
  1831. X    free_move_list(m);
  1832. X    break;
  1833. X  case CONFIGBL:
  1834. X    configuring = TRUE ;
  1835. X    configside = BLACK;
  1836. X    m= theplay->chain;
  1837. X    free_move_list(m);
  1838. X    break;
  1839. X  case DEFAULTP:
  1840. X    init_board(tos);
  1841. X    m= theplay->chain;
  1842. X    free_move_list(m);
  1843. X    break;
  1844. X  case TITLE:
  1845. X    output_text(dr, T_TITLE, text, NULL);
  1846. X    break;
  1847. X  case SUBTITLE:
  1848. X    output_text(dr, T_SUBTITLE, text, NULL);
  1849. X    break;
  1850. X  case SCORE:
  1851. X    output_text(dr, T_SCORE, text, NULL);
  1852. X    break;
  1853. X  case LANGUE:
  1854. X    in_language = find_keyword (t_language, NBLANGUAGES, in_language,
  1855. X                   text,TRUE);
  1856. X    associe_traduction( &in_table, in_language);           
  1857. X    break;
  1858. X  case SPECIAL: /* all input, up to \n is copied to output */
  1859. X    while ((( c = getc(infile)) != EOF) && (c != '\n'))
  1860. X      (void) putc (c,dr->outfile);
  1861. X    putc ('\n', dr->outfile);
  1862. X    break;
  1863. X  case KNULL:
  1864. X  default:
  1865. X    fprintf(stderr,"unknown keyword %s\n",token);
  1866. X    break;
  1867. X  }
  1868. X  return(TRUE);
  1869. X}
  1870. X
  1871. X#ifdef __STDC__
  1872. Xint parse_roque(char *token)
  1873. X#else
  1874. Xint parse_roque(token)
  1875. X     char * token;
  1876. X#endif
  1877. X{ 
  1878. X  int i;
  1879. X
  1880. X  for (i=0; i < NBROQUE && (strcmp(c_roque[i],token)!=0); i++) ;
  1881. X  if ( i < NBROQUE ) {
  1882. X    
  1883. X    m = add_trailing_move(m);
  1884. X    init_parse(m);
  1885. X
  1886. X    if (strlen(token) == 3) {
  1887. X      m->type = PETITROQUE ;
  1888. X      (void) execute(12,DUMMYCHAR);
  1889. X    } else {
  1890. X      m->type = GRANDROQUE ;
  1891. X      (void) execute(11,DUMMYCHAR);
  1892. X    }
  1893. X    /*(void) fprintf(stderr,"ROQUE\n");*/
  1894. X    return(TRUE);
  1895. X  }
  1896. X
  1897. X  return(FALSE);
  1898. X}
  1899. X
  1900. X#ifdef __STDC__
  1901. Xint  parse_move(char *token)
  1902. X#else
  1903. Xint  parse_move(token)
  1904. X     char *token;
  1905. X#endif
  1906. X{
  1907. X  register int i;
  1908. X  int correcte = FALSE ;
  1909. X  int erreursyntaxe = FALSE ;
  1910. X  int etat =0;
  1911. X  int code;
  1912. X  
  1913. X  m = add_trailing_move(m);
  1914. X  init_parse(m);
  1915. X  m->type = MOVE;
  1916. X
  1917. X  i=0;
  1918. X  while ( !correcte && !erreursyntaxe ) {
  1919. X    code = typechar(token[i]);
  1920. X    (void) execute(action[etat][code],token[i]);
  1921. X    etat = transit[etat][code] ;
  1922. X    if (etat == -1) 
  1923. X      erreursyntaxe = TRUE;
  1924. X    if (etat == FINAL)
  1925. X      correcte = TRUE ;
  1926. X    i++;
  1927. X  }
  1928. X  if (erreursyntaxe) {
  1929. X    (void) fprintf(stderr, "no comprende, senor: %s\n",token);
  1930. X    return(FALSE);
  1931. X  }
  1932. X  if (correcte) {
  1933. X    /*(void) fprintf(stderr, "ia panimaiou, davai\n");*/
  1934. X  }
  1935. X  /*init_parse(m);*/
  1936. X  return(TRUE);
  1937. X}
  1938. X
  1939. X#ifdef __STDC__
  1940. Xvoid init_parse(depl *m)
  1941. X#else
  1942. Xvoid init_parse(m)
  1943. X     depl * m ;
  1944. X#endif
  1945. X{
  1946. X
  1947. X  /* global position and piece variable initialised to 0
  1948. X     */
  1949. X  /* move and whiteturn unchanged */ 
  1950. X
  1951. X  m->type = MOVE ;
  1952. X
  1953. X  curpiece = m->piece = VOID ;
  1954. X  curcol = m->tocol = m->fromcol = 0;
  1955. X  curlig = m->tolig = m->fromlig = 0;
  1956. X
  1957. X  m->promotion = VOID;
  1958. X  m->prise = VOID;
  1959. X  m->is_check = FALSE ;
  1960. X
  1961. X  curdigit = curmove = 0;
  1962. X
  1963. X  /*if (movecount != m->move)
  1964. X    (void) fprintf(stderr,"problem in move numbering: %d vs %d\n",
  1965. X           m->move, movecount);*/
  1966. X
  1967. X}
  1968. X
  1969. X/* ------------------- top routines -------------------- */
  1970. X
  1971. X/* cette fonction analyse les arguments de la ligne de commande
  1972. X   */
  1973. X#ifdef __STDC__
  1974. Xint parse_options(int argc,char *argv[])
  1975. X#else
  1976. Xint parse_options(argc,argv)
  1977. X     int argc;
  1978. X     char * argv[];
  1979. X#endif
  1980. X{
  1981. X  int narg =1 ;
  1982. X  int i;
  1983. X  register int c;
  1984. X  char cp[132];
  1985. X  char chaine[MAXTOKLEN];
  1986. X
  1987. X  infile = stdin;
  1988. X  dr->outfile = stdout;
  1989. X  nb_move_to_dsp = 0;
  1990. X
  1991. X  while (narg < argc ) {
  1992. X    (void) strcpy (cp,argv[narg]);
  1993. X    switch (cp[0]) {
  1994. X    case '-' :
  1995. X      switch (cp[1]) {
  1996. X      case 'f' : /* from langage */
  1997. X    if  ((narg+1) >= argc )
  1998. X      fatal((stderr,"missing argument to %s option",cp));
  1999. X    narg++ ;
  2000. X    in_language = find_keyword (t_language, NBLANGUAGES,
  2001. X                    DEFAULT_INPUT_LANGUAGE,
  2002. X                    argv[narg],TRUE);
  2003. X    break;
  2004. X      case 't' : /* to langage */
  2005. X    if  ((narg+1) >= argc )
  2006. X      fatal((stderr,"missing argument to %s option",cp));
  2007. X    narg++ ;
  2008. X    out_language = find_keyword (t_language, NBLANGUAGES,
  2009. X                     DEFAULT_OUTPUT_LANGUAGE,
  2010. X                     argv[narg],TRUE);
  2011. X    break;
  2012. X      case 'o' : /* next arg is output file */
  2013. X    narg++ ;
  2014. X    if ((dr->outfile = fopen (argv[narg],"w+")) == NULL) {
  2015. X      (void) fprintf (stderr,"can't open %s output file\n",argv[narg]);
  2016. X      (void) fprintf (stderr,"assume stdout for output\n");
  2017. X    }
  2018. X    break;
  2019. X      case 'e':
  2020. X    if  ((narg+1) >= argc )
  2021. X      fatal((stderr,"missing argument to %s option",cp));
  2022. X    narg++ ;
  2023. X
  2024. X    i=0;
  2025. X    nb_move_to_dsp = 0;
  2026. X    move_to_display[nb_move_to_dsp] = 0;
  2027. X    while (isdigit(argv[narg][i])) {
  2028. X      move_to_display[nb_move_to_dsp] =
  2029. X        ((int) argv[narg][i] - (int) '0')
  2030. X          + move_to_display[nb_move_to_dsp] * 10;
  2031. X      i++;
  2032. X    }
  2033. X    nb_move_to_dsp++;
  2034. X    stop_at_display = TRUE;
  2035. X    break;
  2036. X      case 'c':
  2037. X    if  ((narg+1) >= argc )
  2038. X      fatal((stderr,"missing argument to %s option",cp));
  2039. X    narg++ ;
  2040. X
  2041. X    i=0;
  2042. X    while (isdigit(argv[narg][i])) {
  2043. X      move_to_display[nb_move_to_dsp] = 0;
  2044. X      while (isdigit(argv[narg][i])) {
  2045. X        move_to_display[nb_move_to_dsp] =
  2046. X          ((int) argv[narg][i] - (int) '0')
  2047. X          + move_to_display[nb_move_to_dsp] * 10;
  2048. X        i++;
  2049. X      }
  2050. X      nb_move_to_dsp++;
  2051. X
  2052. X      if (nb_move_to_dsp > NB_MOVE_TO_DISP)
  2053. X        fatal((stderr,"max. number of move to display exceeded"));
  2054. X
  2055. X      /* process next number */
  2056. X      if (argv[narg][i] == ',')
  2057. X        i++;
  2058. X    }
  2059. X    break;
  2060. X      case 'a': /* algebraic output */
  2061. X    dr->output_move_format = ALGEBRAIC;
  2062. X    break;
  2063. X      case 's':  /* shortened output */
  2064. X    dr->output_move_format = SHORTENED;
  2065. X    break;
  2066. X      case 'b': /* display only the board, no move */
  2067. X    dr->only_board = TRUE;
  2068. X    break;
  2069. X      case 'd': /* output driver */
  2070. X    if  ((narg+1) >= argc )
  2071. X      fatal((stderr,"missing argument to %s option",cp));
  2072. X    narg++ ;
  2073. X    driver = find_keyword(t_output, NB_DRIVER, DEFAULT_DRIVER,
  2074. X                  argv[narg],TRUE);
  2075. X    break;
  2076. X      case 'i': /* no headers */
  2077. X    dr->print_headers = FALSE;
  2078. X    break;
  2079. X      case 'v': /* print version */
  2080. X    /* this already done, so exit() */
  2081. X    exit(0);
  2082. X    break;
  2083. X      case 'h': /* help file */
  2084. X    (void) strcpy(chaine,LIB_DIR);
  2085. X        if ((fhelp = fopen(strcat(chaine,HELP_FILE),"r")) == NULL)
  2086. X          fatal((stderr,"Can't find help file.\n"));
  2087. X        else {
  2088. X          while ((c = getc(fhelp)) != EOF)
  2089. X            (void) fputc(c,stderr);
  2090. X          (void) fclose(fhelp);
  2091. X      exit(0);
  2092. X        }
  2093. X         break;
  2094. X      default:
  2095. X    error((stderr,"\nUnknown command line options %s\n",cp));
  2096. X    break;
  2097. X      }
  2098. X      break;
  2099. X    default: /* assume this is the input file */
  2100. X      if ((infile = fopen (cp,"r")) == NULL)
  2101. X    fatal((stderr,"can't open %s input file\n",cp));
  2102. X    }
  2103. X    narg++;
  2104. X  } /* process next arg */
  2105. X  return(argc);
  2106. X}
  2107. X
  2108. X#ifdef __STDC__
  2109. Xvoid close_files(void)
  2110. X#else
  2111. Xvoid close_files()
  2112. X#endif
  2113. X{
  2114. X  if (!((infile == stdin)||(infile == NULL)))
  2115. X    (void) fclose(infile);
  2116. X  if (dr->outfile != stdout )
  2117. X    (void) fclose(dr->outfile);
  2118. X}
  2119. X
  2120. X#ifdef __STDC__
  2121. Xint associe_traduction (char **table, int language)
  2122. X#else
  2123. Xint associe_traduction (table, language)
  2124. Xchar ** table;
  2125. Xint language ;
  2126. X#endif
  2127. X{
  2128. X  if (language < 0 || (language >= NBLANGUAGES))
  2129. X    error((stderr,"\nUnknown language\n"));
  2130. X  else
  2131. X    *table = c_language[language];
  2132. X  return(language);
  2133. X}
  2134. X
  2135. X#ifdef __STDC__
  2136. Xstatic void print_all_play(play *p)
  2137. X#else
  2138. Xstatic void print_all_play(p)
  2139. Xplay *p;
  2140. X#endif
  2141. X{ 
  2142. X  depl *d;
  2143. X  d = p->chain;
  2144. X  while (d->next != NULL){
  2145. X    d = d->next;
  2146. X    output_move(dr,d);
  2147. X  }
  2148. X}
  2149. X
  2150. X/* ------------- main --------------------- */
  2151. X
  2152. X#ifdef __STDC__
  2153. Xvoid main(int argc,char *argv[])
  2154. X#else
  2155. Xint main(argc,argv)
  2156. X     int argc;
  2157. X     char * argv[];
  2158. X#endif
  2159. X{
  2160. X  (void) fprintf(stderr,"%s\n",version_string);
  2161. X  
  2162. X  /* allocation of driver descriptor */
  2163. X  dr = new_driver();
  2164. X
  2165. X  /* default configuration */
  2166. X  init_driver(dr,DEFAULT_DRIVER);
  2167. X  (void) associe_traduction(&in_table,  DEFAULT_INPUT_LANGUAGE );
  2168. X  (void) associe_traduction(&(dr->out_table), DEFAULT_OUTPUT_LANGUAGE);
  2169. X
  2170. X  (void) parse_options(argc,argv);
  2171. X
  2172. X  (void) associe_traduction (&in_table, in_language);
  2173. X  (void) associe_traduction (&(dr->out_table), out_language);
  2174. X
  2175. X  /* assoc driver */
  2176. X  init_driver(dr,driver);
  2177. X
  2178. X  configuring = FALSE;
  2179. X  configside = VOID;
  2180. X
  2181. X  /* initialise output file */
  2182. X  output_init(dr);
  2183. X
  2184. X  if (error_flag)
  2185. X    fatal((stderr,"\nToo many errors"));
  2186. X
  2187. X  /* allocation of board descriptor */
  2188. X  tos = new_board();
  2189. X  init_board(tos);
  2190. X
  2191. X  /* allocation of move descriptor */
  2192. X  m = new_move();
  2193. X  m->type = VOID ;
  2194. X  /*init_move(m);*/
  2195. X  
  2196. X  /* allocation of the play descriptor */
  2197. X  theplay = (play *) malloc (sizeof(play)) ;
  2198. X  theplay->initial = tos ;
  2199. X  theplay->chain   = m ;
  2200. X  movecount = 1;
  2201. X
  2202. X  /* main analysis routine */
  2203. X  yyin = infile ;
  2204. X  yyout = stderr ;
  2205. X
  2206. X  /*init_parse(m); */
  2207. X  yylex();
  2208. X
  2209. X  if ((count == 0) && !error_flag)
  2210. X    output_board(dr,tos);
  2211. X
  2212. X  if (error_flag) {
  2213. X    error((stderr,"\nLast valid position:\n"));
  2214. X    output_board(dr,tos);
  2215. X    fatal((stderr,"\nToo many errors"));
  2216. X  }
  2217. X      
  2218. X  /* terminates output files */
  2219. X  output_end(dr);
  2220. X
  2221. X  /* close files */
  2222. X  close_files();
  2223. X
  2224. X  /* exit properly */
  2225. X#ifdef __STDC__
  2226. X#else
  2227. X  exit(0);
  2228. X#endif
  2229. X}
  2230. END_OF_FILE
  2231.   if test 42748 -ne `wc -c <'notation.c'`; then
  2232.     echo shar: \"'notation.c'\" unpacked with wrong size!
  2233.   fi
  2234.   # end of 'notation.c'
  2235. fi
  2236. echo shar: End of archive 1 \(of 4\).
  2237. cp /dev/null ark1isdone
  2238. MISSING=""
  2239. for I in 1 2 3 4 ; do
  2240.     if test ! -f ark${I}isdone ; then
  2241.     MISSING="${MISSING} ${I}"
  2242.     fi
  2243. done
  2244. if test "${MISSING}" = "" ; then
  2245.     echo You have unpacked all 4 archives.
  2246.     rm -f ark[1-9]isdone
  2247. else
  2248.     echo You still must unpack the following archives:
  2249.     echo "        " ${MISSING}
  2250. fi
  2251. exit 0
  2252. exit 0 # Just in case...
  2253.