
***** auto.c *****
 auto_startup                       called by auto command to initiate autoplay 
 auto_readmove                      called to check on an incoming move 
 auto_makemove                      called to communicate an outgoing move 

***** main.c *****
 main                               test driver main program for SAN standalone test 

***** sanatk.c *****
 siT SANAttack(cT c, sqT sq);       determine if a color attacks a square 
 siT SANWhiteAttacks(sqT sq);       check if White attacks a square 
 siT SANBlackAttacks(sqT sq);       check if White attacks a square 
 siT SANWhiteInCheck();             test for White in check 
 siT SANBlackInCheck();             test for Black in check 
 SANSetAttackersHalf                do contents of half of attackers vector 
 SANSetAttackers();                 set both halves of the attackers vector 

***** sanbap.c *****
 execmove_auto                      execute an incoming move 
 error_auto                         issue error message 
 SANBAPAuto(cT c);                  handle autoplay for the given color 
 mptrT SANBAPConvSI(siT msi);       convert a short int move represenation to a move 
 siT SANBAPConvM(mptrT mptr);       convert a move to a short int move represenation 

***** sancmd.c *****
 siT SANCMDOpen(charptrT s);        open a new command input file 
 SANCMDClose();                     close the current command input file 
 SANCMDLoad                         load the command input buffer 
 SANCommand();                      read and process a command 
 SANCMDInitCI1                      initialize a command infomation record (part one) 
 SANCMDInitCI2                      initialize a command infomation record (part two) 
 SANCMDInitTable                    command table initialization 
 SANCMDInit();                      one time command initialization 
 SANCMDTerm();                      one time command termination 

***** sandci.c *****
 SANDcAUTO();                       do command: performa automatic competition 
 SANDcAFDO();                       do command: append file: dribble output 
 SANDcBEEP();                       do command: emit ASCII BEL 
 SANDcCALL();                       do command: call command subfile 
 SANDcCFDO();                       do command: close file: dribble output 
 SANDcCVCA();                       do command: clear value: castling availability 
 SANDcCVCB();                       do command: clear value: chessboard 
 SANDcCVEP();                       do command: clear value: en passant target square 
 SANDcCVGT();                       do command: clear value: game termination 
 SANDcCVOP();                       do command: clear value: option 
 SANDcCVSQ();                       do command: clear value: square 
 SANDcCVTF();                       do command: clear value: tag field 
 SANDcDVAS();
 SANDcDVAS();         do command: display value: hash address and signature 
 SANDcDVCB();                       do command: display value: chess board 
 SANDcDVCR();                       do command: display value: correspondence report 
 SANDcDVER();                       do command: display value: event report 
 SANDcDVFE();                       do command: display value: Forsyth-Edwards notation 
 SANDcDVHG();                       do command: display value: hash generation tables 
 SANDcDVSS();                       do command: display value: search strategies 
 SANDcDVTE();                       do command: display value: tag environment 
 SANDcDVTF();                       do command: display value: tag field 
 SANDcDVTS();                       do command: display value: timestamp 
 SANDcECHO();                       do command: echo arguments 
 SANDcENUM();                       do command: enumerate descendents 
 SANDcEXIT();                       do command: exit program 
 SANDcEXSM();                       do command: execute supplied move 
 SANDcGAME();                       do command: autoplay to end of game 
 SANDcHELP();                       do command: display help 
 SANDcLFER();                       do command: load file: event report 
 SANDcNEWG();                       do command: new game 
 SANDcNOOP();                       do command: no operation 
 SANDcOFDO();                       do command: open file: dribble output 
 SANDcPLAY();                       do command: select and play N moves 
 SANDcRTMV();                       do command: retract N played moves 
 SANDcRTRN();                       do command: return from command subfile 
 SANDcSFCR();                       do command: save file: correspondence report 
 SANDcSFER();                       do command: save file: event report 
 SANDcSRCH();                       do command: search for target move(s) 
 SANDcSTAT();                       do command: status report 
 SANDcSVAC();                       do command: set value: active color 
 SANDcSVCA();                       do command: set value: castling availability 
 SANDcSVEP();                       do command: set value: en passant target square 
 SANDcSVFE();                       do command: set value: Forsyth-Edwards notation 
 SANDcSVFN();                       do command: set value: fullmove number 
 SANDcSVHC();                       do command: set value: halfmove clock 
 SANDcSVOP();                       do command: set value: option 
 SANDcSVPL();                       do command: set value: playing level 
 SANDcSVRT();                       do command: set value: average response time 
 SANDcSVSQ();                       do command: set value: square 
 SANDcSVSS();                       do command: set value: search strategies 
 SANDcSVTF();                       do command: set value: tag field 
 SANDcTEST();                       do command: developer test 
 SANDcTFGC();                       do command: translate file: games to code (PGC) 
 SANDcTFGE();                       do command: translate file: games to EPD 
 SANDcTFGG();                       do command: translate file: games to games (PGN) 
 SANDcTFGV();                       do command: translate file: games to variations 

***** sandrw.c *****
 siT SANDrawTestSmat();             test for stalemate draw 
 siT SANDrawTestIMat();             test for insufficient material draw 

***** sandsp.c *****
 SANDspChar(char ch);               display a character 
 SANDspStr(charptrT s);
 SANDspStrSI(charptrT s, siT si);
 SANDspStrLI(charptrT s, liT li);
 SANDspStrSINL(charptrT s, siT si);
 SANDspStrLINL(charptrT s, liT li);  display a string 
 SANDspNL();                        display a newline 
 SANDspLine(charptrT s);            display a string and a newline 
 SANDspSTV();
 SANDspSTVNL();       display the scratch text vector 
 SANDspSTVNL();                     display the scratch text vector and a newline 
 SANDspNote(charptrT s);            display a notification 
 SANDspError(charptrT s);
 SANDspErrorSTV();  display an error 
 SANDspErrorSTV();                  display an error from the STV 
 SANDspSI(siT si);                  display a short integer 
 SANDspLI(liT li);                  display a long integer 
 SANDspStrSI(charptrT s, siT si);
 SANDspStrSINL(charptrT s, siT si);  display a string and a short integer 
 SANDspStrLI(charptrT s, liT li);
 SANDspStrLINL(charptrT s, liT li);  display a string and a long integer 
 SANDspStrSINL(charptrT s, siT si);  display a string, a short int, and a newline 
 SANDspStrLINL(charptrT s, liT li);  display a string, a long integer and a newline 
 SANDspTimestamp();                 display the current timestamp 
 SANDspSq(sqT sq);                  display a square 
 SANDspColor(cT c);
 SANDspColorPiece(cpT cp);  display color character 
 SANDspPiece(pT p);                 display piece character 
 SANDspColorPiece(cpT cp);          display color+piece characters 
 SANDspSAN(mptrT mptr);
 SANDspSANTB(mptrT mptr);
 SANDspSANNL(mptrT mptr);  SAN display 
 SANDspSANTB(mptrT mptr);           display SAN with trailing blanks 
 SANDspSANNL(mptrT mptr);           SAN display with newline 
 SANDspFullMove(siT n, mptrT mptr);  display full move 
 SANDspPath();                      display the current path 
 SANDspBoard();                     quick board display 
 SANDspOptions();                   active options display 
 SANDspStatus();                    quick status display 
 SANGateChar(FILEptrT fptr, char ch);  gate a character output to a file 
 SANGateStr(FILEptrT fptr, charptrT s);  gate a string output to a file 
 SANBadParmForm(siT n);             issue "bad parameter form" diagnostic 
 SANBadParmValue(siT n);            issue "bad parameter value" diagnostic 

***** sanenu.c *****
 liT SANEnumerate(siT depth);       enumerate subtree nodes 

***** sanepd.c *****
 charptrT SANEPDGenBasic(bptrT bptr, cT actc, castT cast, sqT epsq);
charptrT SANEPDGenBasicCurrent();  generate basic EPD notation for the given position 
 charptrT SANEPDGenBasicCurrent();  generate basic EPD for current position 
 SANEPDInit();                      one time EPD initialization 
 SANEPDTerm();                      one time EPD termination 

***** sanfen.c *****
 charptrT SANFENGen();              generate Forsyth-Edwards notation for current position 
 SANFENParseBD                      FEN parse of board description 
 SANFENParseAC                      FEN parse of active color 
 SANFENParseCA                      FEN parse of castling availability 
 SANFENParseEP                      FEN parse of en passant target square 
 SANFENParseHC                      FEN parse of halfmove clock 
 SANFENParseFN                      FEN parse of fullmove number 
 siT SANFENSet(charptrT s);         set the current position from Forsyth-Edwards notation 

***** sangen.c *****
 SANGenCaptPL();                    generate psuedolegal capture moves 
 SANGenFullPL();                    generate psuedolegal moves 
 SANGenClean                        generate move list with first level processing 
 SANGenMoves();                     generate ordered legal moves 

***** sangtc.c *****
 gtcT SANGTCDetermine(gtimT gtim);  check if new gtc available from input gtim 
 siT SANGTCConsistent(gtcT new_gtc);  check if new gtc is consistent with environment 
 SANGTCSet(gtcT new_gtc);           set the new game termination code 
 SANGTCAutoSet();                   check and set a new game termination code 
 gtimT SANMatchGTIM(charptrT s);    match string as a game termination imput marker 

***** sanhsh.c *****
 SANHashColorPieceSq(cpT cp, sqT sq);
 SANHashColorPieceSqSq(cpT cp, sqT sq0, sqT sq1);  change single index/position signature pair 
 SANHashCastlingAvailability(caiT cai);  change castling availability signatures 
 SANHashEnPassantTargetFile();      change en passant file signatures 
 SANHashColorPieceSqSq(cpT cp, sqT sq0, sqT sq1);  change two index/position signatures 
 SANHashCreate();                   create main hash subsystem index/position signatures 
 SANHashDisplayGenerationTables();  display the hash generation table set 
 SANHashPSNonNegativeWord           psuedorandom positive 16 bit word 
 SANHashPSByte                      return psuedorandom 8 bit byte (in a word) 
 SANHashPSWord                      return psuedorandom 16 bit word (in a long word) 
 SANHashPSLongWord                  return psuedorandom 32 bit word 
 SANHashInit();                     initialize main hash table subsystem (called once) 
 SANHashTerm();                     terminate main hash table subsystem (called once) 

***** sanhst.c *****
 SANHistPush(siT ordinal);          push a history record on the history stack 
 SANHistPop();                      pop a history record off the history stack 
 SANHistClear();                    clear/resethistory information 
 SANHistInit();                     one time call to initialize history 
 SANHistTerm();                     one time call to terminate history 

***** sanint.c *****
 SANInitPosition                    set up starting board position 
 SANInitGround();                   ground state initialize/reset 
 SANInitGround();
 SANInit();       one time call initialization 

***** sanmer.c *****
 SANExecute();                      execute the current move 
 SANRetract();                      retract the previous move 

***** sanmlm.c *****
 SANMLExec();                       execute the current move list 
 SANMLPolice();                     remove illegal moves the current move list 
 SANMLEnsurePolice();               ensure generation, then police 
 SANMLDisambiguate();               insert disambiguation flags in move list 
 SANMLScanMate();                   scan current move list for mating moves 

***** sanmnd.c *****
 SANDecodeBump                      increment a style vector and return overflow 
 SANDecodeFlex                      locate a move from SAN (flexible interpretation) 
 mptrT SANDecodeAux(sanT san);      locate a move from SAN (strict interpretation) 
 mptrT SANDecodeAux(sanT san);      locate a move from SAN 

***** sanmne.c *****
 SANEncodeChar                      encode SAN character 
 SANEncodeStr                       encode a SAN string 
 SANEncodeFile                      encode SAN file from square 
 SANEncodeRank                      encode SAN rank from square 
 SANEncodeSq                        encode SAN square 
 SANEncodeCI                        encode an appropriate capture indicator 
 SANEncodeAux(mptrT mptr, sanT san, ssavT ssav);  encode SAN format move with variants 
 SANEncodeAux(mptrT mptr, sanT san, ssavT ssav);
 SANEncode(mptrT mptr, sanT san);  encode a move into a SAN string 

***** sanmpu.c *****
 SANPlayMove(mptrT mptr);           play a move 
 SANUnplayMove();                   unplay the last played move 

***** sanmsc.c *****
 SANSetMaterial();                  calculate material components 
 SANSetPieceVector();               set the piece location and board index vectors 
 SANAddPiece(sqT sq);               add a piece (not king) to the piece vector 
 SANSubPiece(sqT sq);               subtract a piece (not king) from the piece vector 
 cenT SANCensus();                  census report 
 siT SANSameMove(mptrT mptr0, mptrT mptr1);  determine if two moves are the same 
 mptrT SANFindMove(mptrT mptr);     locate a move in the current move list 
 mptrT SANSingleMove();             retrun pointer to single move (if exists) 
 mptrT SANMatingMove();             retrun pointer to a mating move (if exists) 
 mptrT SANDrawingMove();            retrun pointer to a drawing move (if exists) 

***** sanopt.c *****
 SANOPTEntry                        initialize a program option 
 SANOPTInit();                      one time option initialization 

***** sanpce.c *****
 siT SANCheckShortInteger(charptrT s);  check if the input is a short integer 
 siT SANEvalShortInteger(charptrT s);  evaluate short integer 
 siT SANCheckLongInteger(charptrT s);  check if the input is a long integer 
 liT SANEvalLongInteger(charptrT s);  evaluate long integer 
 siT SANCheckOption(charptrT s);    check if the input is an option name 
 optnT SANEvalOption(charptrT s);   evaluate option name 
 siT SANCheckCommand(charptrT s);   check if the input is a command name 
 cmdT SANEvalCommand(charptrT s);   evaluate command name 
 siT SANCheckStrategy(charptrT s);  check if the input is a strategy name 
 ssT SANEvalStrategy(charptrT s);   evaluate strategy name 
 siT SANCheckFile(char ch);         check if the input is a file character 
 fileT SANEvalFile(char ch);        evaluate file character 
 siT SANCheckRank(char ch);         check if the input is a rank character 
 rankT SANEvalRank(char ch);        evaluate rank character 
 siT SANCheckSquare(charptrT s);    check if the input is a square name 
 sqT SANEvalSquare(charptrT s);     evaluate square name 
 siT SANCheckColor(char ch);        check if the input is a color character 
 rcT SANEvalColor(char ch);         evaluate color character 
 siT SANCheckPiece(char ch);        check if the input is a piece character 
 pT SANEvalPiece(char ch);          evaluate piece character 
 siT SANCheckCastling(charptrT s);  check if the input is a castling availability 
 caiT SANEvalCastling(charptrT s);  evaluate castling availability 

***** sanpgc.c *****
 SANPGNWriteInt1                    write an int-1 to a file 
 SANPGNWriteInt2                    write an int-2 to a file 
 SANPGNWriteInt4                    write an int-4 to a file 
 SANPGNWriteString1                 write a string-1 to a file 
 SANPGNWriteString2                 write a string-2 to a file 
 SANPGNWriteString4                 write a string-4 to a file 
 SANPGCWriteRPGC                    write the current game in (reduced) PGC to a file 
 SANPGCWriteCurrent(FILEptrT fptr);  write the current game in PGC to a file 

***** sanpgn.c *****
 SANPGNSetUp                        set up game move score processing 
 SANPGNNL                           produce newline 
 SANPGNResTag                       produce reserved tag output line 
 SANPGNWrapStr                      produce wrapped string w/possibly prepended space 
 SANPGNScore                        produce game score 
 SANPGNCorrespondenceReport(FILEptrT fptr);  produce correspondence report to file 
 SANPGNEventReport(FILEptrT fptr);  produce event report to file 

***** sanpos.c *****
 mpevT SANPosEval();                return positional factors evalutaion 
 SANPosInit();                      one time initialization for positional evalation 
 SANPosTerm();                      one time termination for positional evalation 

***** sanrdr.c *****
 SANRGSetGRTM(grtmT grtm);          set the game reader translation mode 
 SANRGInteger                       test string for integer status 
 SANRGClass0                        test character for class zero (digits) 
 SANRGClass1                        test character for class one (symbol characters) 
 SANRGClass2                        test character for class two (string characters) 
 SANRGChar                          read a character from the game score file 
 SANRGToken                         read a game score token from a file 
 SANRGFileStart                     start processing for an input file 
 SANRGFileFinish                    finish processing for an input file 
 SANRGError                         report a scanning error 
 SANRGParseSymbol                   parse a symbol 
 SANRGParseTag                      parse a tag directive 
 SANRGParseGTIM                     parse a game termination indicator marker 
 SANRGParseList                     parse a parenthesized move list 
 SANRGParseNAG                      parse a Numeric Annotation Glyph 
 SANRGParsePLine                    parse a percent line 
 SANRGParseForm                     parse a game form 
 SANRGParseGame                     parse a single game sequence from the current file 
 SANRGWriteEPD                      output the current game EPD 
 SANRGWriteVariation                output the current game variation 
 siT SANRGSingle(charptrT fn, siptrT gnptr);  read a single game score given a file name 
 siT SANRGMultiple(charptrT fn0, charptrT fn1, siptrT gnptr);  read multiple game scores and produce translation 

***** sanrst.c *****
 gsT SANStatus();                   return current status 

***** sansel.c *****
 SANSelect();                       select a move 

***** sanslm.c *****
 sleptrT SANSLMMember(slaptrT slaptr, charptrT s);  return string's member position, if any 
 SANSLMAppend(slaptrT slaptr, charptrT s);  append a string to the end of a list 
 SANSLMReleaseElement(slaptrT slaptr, sleptrT sleptr);  release storage for a string list element 
 SANSLMInitAnchor(slaptrT slaptr);  initialize a string list anchor 
 SANSLMReleaseAnchor(slaptrT slaptr);  release storage for a string list anchor 

***** sansrt.c *****
 int SANEvalComp(mptrT mptr0, mptrT mptr1);  comparison routine for move evaluations 
 SANSortEval();                     sort move list according to evaluation 
 SANSortSAN();                      ASCII SAN sort move list 
 siT SANLocateOrdinal(mptrT mptr);  locate the canonical move ordinal for a move 

***** sansss.c *****
 SANSSS(sepT sep);
 SANSSSSelect();
 SANSSSInit();
 SANSSSTerm();  issue indicated call to all strategy modules 
 SANSSSSelect();                    activate appropriate move selection 
 SANSSSInit();                      one time search strategy subsystem initialization 
 SANSSSTerm();                      one time search strategy subsystem termination 

***** santag.c *****
 charptrT SANTagFormat(tagptrT tagptr);
charptrT SANTagFormatReserved(rsvtagT rsvtag);  format an allocated tag value display 
 charptrT SANTagFormatReserved(rsvtagT rsvtag);  format a reserved tag value 
 tagptrT SANTagCreate(charptrT name, charptrT value, tagfT tagf);  create and assign storage for a new tag pair 
 tagptrT SANTagLocate(charptrT name);  locate the indicated tag record by name 
 SANTagDelete(tagptrT tagptr);      delete the indicated tag record 
 SANTagInsert(tagptrT tagptr);      insert the indicated tag record 
 SANTagUpdate(tagptrT tagptr, charptrT value);  update the indicated tag record 
 SANTagInitTag                      initialize a tag 
 SANTagClear(tagptrT tagptr);
 SANTagClearAll();  clear a single tag value 
 SANTagClearAll();                  clear all tag values 
 SANTagInit();                      one time initialization for tag subsystem 
 SANTagTerm();                      one time termination for tag subsystem 

***** santrm.c *****
 SANTerm();                         one time call termination 

***** sanutl.c *****
 Noop();                            do nothing 
 siT SANConvFrCSI(siT value);       convert from canonical two byte integer format 
 siT SANConvToCSI(siT value);       convert to canonical two byte integer format 
 liT SANConvToCLI(liT value);       convert to canonical four byte integer format 
 liT SANConvFrCLI(liT value);       convert from canonical four byte integer format 
 SANFatal(charptrT s);              report fatal error and exit 
 SANSwitchFault(charptrT s);        report fswitch fault atal error and exit 
 charptrT SANToken(charptrT s, siptrT siptr);  extract a token from a position in a string 
 FILEptrT SANTextFileOpen(charptrT fn, charptrT mode);  open a text file 
 SANTextFileClose(FILEptrT fptr);   close a text file 
 charptrT SANStrGrab(charptrT s);   allocate and copy string 
 ptrT SANMemGrab(allocT n);         allocate memory 
 SANMemFree(ptrT p);                deallocate memory 
 ptrT SANMemResize(ptrT p, allocT n);  shrink allocated block 
 siT SANCIEqChar(char c0, char c1);  test chars for case independent equlaity 
 siT SANCIEqStr(charptrT s0, charptrT s1);  compare two strings for case independent equality 
 SANTimestampAt(time_t tval, stampT stamp);  generate a timestamp for the given time 
 SANTimestampAt(time_t tval, stampT stamp);
 SANTimestamp(stampT stamp);  generate a current timestamp 

***** sanval.c *****
 SANUpdate();                       update the current environment 
 SANZapUp();                        clear history and then update database 
 SANClrBoard();                     clear the board 
 cpT SANGetSq(sqT sq);              get square value 
 SANGetBoard(bptrT bptr);           get the board 
 cT SANGetACTC();                   get active color 
 castT SANGetCAST();                get castling bits 
 sqT SANGetEPSQ();                  get en passant square 
 siT SANGetHMVC();                  get halfmove clock 
 siT SANGetFMVN();                  get fullmove number 
 SANPutSq(sqT sq, cpT cp);          put a square value 
 SANPutBoard(bptrT bptr);           set the board 
 SANPutACTC(cT c);                  put active (and passive) color 
 SANPutCAST(castT cast);            put castling bits 
 SANPutEPSQ(sqT epsq);              put en passant square 
 SANPutHMVC(siT hmvc);              put halfmove clock 
 SANPutFMVN(siT fmvn);              put fullmove number 

***** x_eat.c *****
 EATInit();                         one time call to initialize the EAT subsystem 
 EATTerm();                         one time call to terminate the EAT subsystem 
 EATNewGame();                      send "new game" request to the EAT subsystem 
 EATSelect();                       select a move 
 EATPlay();                         send "play move" request to the EAT subsystem 
 EATUnplay();                       send "unplay move" request to the EAT subsystem 
 EATSetPos();                       send "set position" request to the EAT subsystem 
 EATConfig();                       send "re-configuration" request to the EAT subsystem 

***** x_gtp.c *****
 GTPInit();                         one time call to initialize the GTP subsystem 
 GTPTerm();                         one time call to terminate the GTP subsystem 
 GTPNewGame();                      send "new game" request to the GTP subsystem 
 GTPSelectMove                      select a move 
 GTPPlay();                         send "play move" request to the GTP subsystem 
 GTPUnplay();                       send "unplay move" request to the GTP subsystem 
 GTPSetPos();                       send "set position" request to the GTP subsystem 
 GTPConfig();                       send "re-configuration" request to the GTP subsystem 

***** x_ran.c *****
 RANInit();                         one time call to initialize the RAN subsystem 
 RANTerm();                         one time call to terminate the RAN subsystem 
 RANNewGame();                      send "new game" request to the RAN subsystem 
 RANSelect();                       select a move 
 RANPlay();                         send "play move" request to the RAN subsystem 
 RANUnplay();                       send "unplay move" request to the RAN subsystem 
 RANSetPos();                       send "set position" request to the RAN subsystem 
 RANConfig();                       send "re-configuration" request to the RAN subsystem 

***** x_sc0.c *****
 SC0Init();                         one time call to initialize the SC0 subsystem 
 SC0Term();                         one time call to terminate the SC0 subsystem 
 SC0NewGame();                      send "new game" request to the SC0 subsystem 
 SC0SelectMove                      select a move 
 SC0Play();                         send "play move" request to the SC0 subsystem 
 SC0Unplay();                       send "unplay move" request to the SC0 subsystem 
 SC0SetPos();                       send "set position" request to the SC0 subsystem 
 SC0Config();                       send "re-configuration" request to the SC0 subsystem 

***** x_sc1.c *****
 SC1Init();
 SC1Term();
 SC1NewGame();
 SC1Select();
 SC1Play();
 SC1Unplay();
 SC1SetPos();
 SC1Config();  test 
 SC1Init();                         one time call to initialize the SC1 subsystem 
 SC1Term();                         one time call to terminate the SC1 subsystem 
 SC1NewGame();                      send "new game" request to the SC1 subsystem 
 SC1SelectMove                      select a move 
 SC1Play();                         send "play move" request to the SC1 subsystem 
 SC1Unplay();                       send "unplay move" request to the SC1 subsystem 
 SC1SetPos();                       send "set position" request to the SC1 subsystem 
 SC1Config();                       send "re-configuration" request to the SC1 subsystem 
