all-up-in-your-elo 0.0.2

data/ext/bayeselo/consolui.h

@@ -0,0 +1,154 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// consolui.h
+//
+// CConsoleUI class declaration
+//
+// This class is an abstract class, used to define console user interfaces.
+// It is typically used by adding a pointer to a class, and overriding the
+// ProcessCommand member function to process commands on this class.
+// See classes that inherit from CConsoleUI to find examples demonstrating
+// how to do so.
+//
+// Remi Coulom
+//
+// june 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef CONSOLUI_H
+#define CONSOLUI_H
+
+#include <iosfwd>
+
+#include "list.h" // CList<>
+
+class CConsoleUI //cui
+{
+ private: //////////////////////////////////////////////////////////////////
+  //
+  // private data
+  //
+  static const int BufferSize;
+  static const char * const tszCommands[];
+
+  CList<CConsoleUI *> lpcuiChildren;
+  CConsoleUI *pcuiParent;
+  int fPrompt;
+  const int openmode;
+
+  //
+  // private functions
+  //
+  void Parse(char *pszCommand,
+             const char *&pszCommand2,
+             const char *&pszParameters,
+             const char *&pszInput,
+             const char *&pszOutput) const;
+
+  void OpenChild(int Parameter, std::istream &in, std::ostream &out);
+
+  //
+  // Copy constructor and assignment operator do not work
+  //
+  // CConsoleUI(const CConsoleUI &cui): openmode(0)
+  //  {const CConsoleUI *pcui = &cui; pcui = pcui;}
+  // CConsoleUI &operator=(const CConsoleUI &cui): openmode(0)
+  //  {const CConsoleUI *pcui = &cui; pcui = pcui; return *this;}
+
+ protected: ////////////////////////////////////////////////////////////////
+  //
+  // Prompt functions
+  //
+  virtual void PrintLocalPrompt(std::ostream &out) = 0;
+  void PrintPrompt(std::ostream &out);
+
+  //
+  // Useful fonctions to help processing commands
+  // ??? (should not be a member function)
+  //
+  const char *SetFlag(int &f, const char *psz);
+  int ArrayLookup(const char * const psz,
+                  const char * const * const ppsz);
+
+  //
+  // This function is called repeatedly by EnterParseAndProcess
+  //
+  virtual int ProcessCommand(const char *pszCommand,
+                             const char *pszParameters,
+                             std::istream &in,
+                             std::ostream &out);
+
+  //
+  // Opening modes
+  //
+  enum // openmode
+  {
+   OpenModal,
+   OpenModeless,
+   OpenPermanent
+  };
+
+  //
+  // Function to print an error message
+  //
+  virtual void PrintErrorMessage(std::ostream &out, const char *pszCommand);
+  
+  //
+  // Function used to add a CConsoleCUI to the list of modeless children
+  // These user interfaces are deleted when they are closed (they must have
+  // been allocated dynamically by new ...)
+  //
+  void AddChild(CConsoleUI *pcui, std::istream &in, std::ostream &out);
+
+  //
+  // Utility function to get[set] variables
+  //
+  template<class T>
+  static void GetSet(T &x, const char *psz, std::ostream &out);
+
+ public: ///////////////////////////////////////////////////////////////////
+  //
+  // Constructor
+  //
+  CConsoleUI(CConsoleUI *pcui = 0, int openmodeInit = OpenModal);
+
+  //
+  // ProcessCommand return values
+  //
+  enum
+  {
+   PC_Continue, // The command loop should go on
+   PC_Close,    // The command loop should stop and return PC_Close
+   PC_Parent    // The command loop should stop and return PC_Parent
+  };
+
+  //
+  // Functions to set/get the prompt flag
+  //
+  void SetFPrompt(int i) {fPrompt = !!i;};
+  int GetFPrompt() const {return fPrompt;};
+
+  //
+  // set parent
+  //
+  void SetParent(CConsoleUI *pcui);
+ 
+  //
+  // Function to process a single command
+  //
+  int EnterParseAndProcess(std::istream &in,
+                           std::ostream &out,
+                           std::ostream *pofsLog = 0);
+
+  //
+  // Main command loop of calls to EnterParseAndProcess
+  //
+  int MainLoop(std::istream &in, std::ostream &out);
+
+  //
+  // This class has virtual functions, so we provide a virtual destructor
+  //
+  virtual ~CConsoleUI();
+};
+
+#endif

data/ext/bayeselo/const.cpp

@@ -0,0 +1,79 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// const.cpp
+//
+// CConst class
+//
+// Remi Coulom
+//
+// July 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#include "const.h"
+#include "square.h"     // CSquare class
+
+//
+// Table indicating distances to the edge of the board
+//
+const int CConst::tcEdge[64] =
+{
+ Left|Down ,Left2|Down ,Down ,Down ,Down ,Down ,Right2|Down ,Right|Down,
+ Left|Down2,Left2|Down2,Down2,Down2,Down2,Down2,Right2|Down2,Right|Down2,
+ Left      ,Left2      ,0    ,0    ,0    ,0    ,Right2      ,Right,
+ Left      ,Left2      ,0    ,0    ,0    ,0    ,Right2      ,Right,
+ Left      ,Left2      ,0    ,0    ,0    ,0    ,Right2      ,Right,
+ Left      ,Left2      ,0    ,0    ,0    ,0    ,Right2      ,Right,
+ Left|Up2  ,Left2|Up2  ,Up2  ,Up2  ,Up2  ,Up2  ,Right2|Up2  ,Right|Up2,
+ Left|Up   ,Left2|Up   ,Up   ,Up   ,Up   ,Up   ,Right2|Up   ,Right|Up
+};
+
+//
+// Table of Knight moves
+//
+const struct CConst::st CConst::TKnightMove[8] =
+{
+ {Up           | Left  | Left2  , CSquare::a5 - CSquare::c4},
+ {Up   | Up2   | Left           , CSquare::b6 - CSquare::c4},
+ {Up   | Up2   | Right          , CSquare::d6 - CSquare::c4},
+ {Up           | Right | Right2 , CSquare::e5 - CSquare::c4},
+ {Down         | Right | Right2 , CSquare::e3 - CSquare::c4},
+ {Down | Down2 | Right          , CSquare::d2 - CSquare::c4},
+ {Down | Down2 | Left           , CSquare::b2 - CSquare::c4},
+ {Down         | Left  | Left2  , CSquare::a3 - CSquare::c4}
+};
+
+//
+// Table of King moves
+//
+const struct CConst::st CConst::TKingMove[8] =
+{
+ {Down | Right, CSquare::c1 - CSquare::b2},
+ {Down        , CSquare::b1 - CSquare::b2},
+ {Down | Left , CSquare::a1 - CSquare::b2},
+ {       Left , CSquare::a2 - CSquare::b2},
+ {Up   | Left , CSquare::a3 - CSquare::b2},
+ {Up          , CSquare::b3 - CSquare::b2},
+ {Up   | Right, CSquare::c3 - CSquare::b2},
+ {       Right, CSquare::c2 - CSquare::b2}
+};
+
+//
+// Array of directions
+//
+const int CConst::tDirection[13] =
+{
+ 0,
+ CSquare::Left,
+                 CSquare::Up,
+ CSquare::Left + CSquare::Up,
+                               CSquare::Right,
+ CSquare::Left +               CSquare::Right,
+                 CSquare::Up + CSquare::Right,
+ CSquare::Left + CSquare::Up + CSquare::Right,
+                                                CSquare::Down,
+ CSquare::Left +                                CSquare::Down,
+                 CSquare::Up +                  CSquare::Down,
+ CSquare::Left + CSquare::Up +                  CSquare::Down,
+                               CSquare::Right + CSquare::Down
+};
+

data/ext/bayeselo/const.h

@@ -0,0 +1,42 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// const.h
+//
+// CConst class definition
+//
+// Remi Coulom
+//
+// July 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef CONST_H
+#define CONST_H
+
+class CConst
+{
+ public: ///////////////////////////////////////////////////////////////////
+
+ //
+ // Flags indicating direction and distance from the edge for each square
+ //
+ enum
+ {
+  Left   = 0x01,
+  Up     = 0x02,
+  Right  = 0x04,
+  Down   = 0x08,
+  Left2  = 0x10,
+  Up2    = 0x20,
+  Right2 = 0x40,
+  Down2  = 0x80
+ };
+
+ static const int tcEdge[64];
+ struct st {int cDirection; int Direction;};
+ static const struct st TKnightMove[8];
+ static const struct st TKingMove[8];
+ static const int tDirection[13];
+};
+
+
+#endif

data/ext/bayeselo/date.cpp

@@ -0,0 +1,96 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// date.cpp
+//
+// CDate class
+//
+// Remi Coulom
+//
+// june 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#include <ctime>
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+#include <cstring>
+
+#include "date.h"
+
+using namespace std;
+
+////////////////////////////////////////////////////////////////////////////
+// Function to retrieve the current date
+////////////////////////////////////////////////////////////////////////////
+CDate CDate::Today()
+{
+ time_t now;
+ time(&now);
+ struct tm *ptm = localtime(&now);
+ return CDate(ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday);
+}
+
+
+////////////////////////////////////////////////////////////////////////////
+// Constructor to convert a string to a date
+// Format : YYYY?MM?DD (filled with zeroes)
+////////////////////////////////////////////////////////////////////////////
+CDate::CDate(const char *psz)
+{
+ int Length = strlen(psz);
+
+ Year = 0;
+ Month = 0;
+ Day = 0;
+
+ char szBuffer[5];
+
+ szBuffer[0] = psz[0];
+ szBuffer[1] = psz[1];
+ szBuffer[2] = psz[2];
+ szBuffer[3] = psz[3];
+ szBuffer[4] = 0;
+ istringstream(szBuffer) >> dec >> Year;
+
+ if (Length > 5)
+ {
+  szBuffer[0] = psz[5];
+  szBuffer[1] = psz[6];
+  szBuffer[2] = 0;
+  istringstream(szBuffer) >> dec >> Month;
+
+  if (Length > 8)
+  {
+   szBuffer[0] = psz[8];
+   szBuffer[1] = psz[9];
+   szBuffer[2] = 0;
+   istringstream(szBuffer) >> dec >> Day;
+  }
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////
+// output operator
+////////////////////////////////////////////////////////////////////////////
+ostream &operator<<(ostream &ostr, const CDate &date)
+{
+ char cOldFill = ostr.fill('0');
+
+ if (date.GetYear())
+  ostr << setw(4) << date.GetYear() << '.';
+ else
+  ostr << "??" << "??.";
+
+ if (date.GetMonth())
+  ostr << setw(2) << date.GetMonth() << '.';
+ else
+  ostr << "??.";
+
+ if (date.GetDay())
+  ostr << setw(2) << date.GetDay();
+ else
+  ostr << "??";
+
+ ostr.fill(cOldFill);
+ return ostr;
+}

data/ext/bayeselo/date.h

@@ -0,0 +1,44 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// date.h
+//
+// CDate class definition
+//
+// Remi Coulom
+//
+// June 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef DATE_H
+#define DATE_H
+
+#include <iostream>
+
+class CDate;
+
+std::ostream &operator<<(std::ostream &ostr, const CDate &date);
+
+class CDate // date
+{
+ private: //////////////////////////////////////////////////////////////////
+  int Day;
+  int Month;
+  int Year;
+
+ public: ///////////////////////////////////////////////////////////////////
+  CDate() : Day(0), Month(0), Year(0) {}
+  CDate(int y, int m, int d) : Day(d), Month(m), Year(y) {}
+  CDate(const char *psz);
+
+  void SetDay(int NewDay) {Day = NewDay;}
+  void SetMonth(int NewMonth) {Month = NewMonth;}
+  void SetYear(int NewYear) {Year = NewYear;}
+
+  int GetDay() const {return Day;}
+  int GetMonth() const {return Month;}
+  int GetYear() const {return Year;}
+
+  static CDate Today();
+};
+
+#endif

data/ext/bayeselo/debug.h

@@ -0,0 +1,58 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// debug.h
+//
+// debug macros
+//
+// Macros for conditionnal compilation :
+// INLINE, MY_ERROR, ASSERT, FATAL, CHECKPOINT, TRACE
+// (see the following code for details)
+//
+// Remi Coulom
+//
+// April, 1996
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef DEBUG_H
+#define DEBUG_H
+
+#include <iostream>
+#include <cstdlib>
+
+//
+// MY_ERROR
+//
+#define MY_ERROR(s) do {                                                   \
+ std::cout << '\n' << s << '\n';                                           \
+ std::cout << "File: " << __FILE__ << '\n';                                \
+ std::cout << "Line: " << __LINE__ << '\n';                                \
+ exit(1);} while(0)
+
+//
+// FATAL(x)
+//
+#define FATAL(x) do if ((x)) MY_ERROR("Fatal error: " << #x); while(0)
+
+//
+// INLINE, ASSERT(x), CHECKPOINT()
+//
+
+#ifdef DEBUG
+#define INLINE
+#define TRACE(s) do {std::cout << s << '\n';} while(0)
+#define ASSERT(x) do if (!(x)) MY_ERROR("Assertion failed: "<<#x); while(0)
+#define CHECKPOINT() do {                                                  \
+ std::cout << '?';                                                         \
+ std::cout.flush();                                                        \
+ int x = cin.get();                                                        \
+ if (x != '\n')                                                            \
+  exit(1);                                                                 \
+} while(0);
+#else
+#define INLINE inline
+#define TRACE(s)
+#define ASSERT(x)
+#define CHECKPOINT()
+#endif
+
+#endif