belofte.cpp

Go to the documentation of this file.

/**
 * @file belofte.cpp
 * @brief main entry point, user interface
 * @copyright This program is distributed under the GNU GPL Version 2,
 * June 1991 General Public License. See COPYING.md for more
 * information. SPDX-License-Identifier: GPL-2.0-only
 * Part of belofte - A Promising Chess Program
 * @author Yves De Billoez
 * @date 01/10/2004 initial version: 0.1
 * @date 12/05/2020 start of version 2.0
 * @date 23/07/2024 latest version: 2.1.8
 */
 
/**
 * The main program
 */
 
#include "belofte.h"
 
//-----------------------------------------------------------------------
 
static void platform_ctor();
static void platform_dtor();
 
/**
 * Main entry point
 * @param argc The number of parameters
 * @param argv The strings pointing to each parameter
 */
 
int main(int argc, char *argv[])
{
  // initialize appInstance and normalised name of application
  App().setName(argv[0]);
  App().setConfig("enginename", MYFULLNAME " (" MYOS "/" MYPLATFORM ")" );
  App().setConfig("about", MYFULLNAME " by " MYAUTHOR " " DEVDATES ", " MYLICENSE);
  App().setConfig("author", "by " MYAUTHOR " " DEVDATES ", " MYLICENSE);
 
  platform_ctor();
 
  // initialize speedy structures
  // even if norandom selected, required for hash init
  std::srand(static_cast<unsigned int> (std::time(nullptr)));
  bPiece_ctor();
 
  // initialize appInstance
#if defined(BELOFTE_UCIMODE)
  App().setMode("uci");
#else
  App();
#endif
 
  // during initialisation, no interactive commands are read
  App().m_reader.setBatchMode();
 
  // initialize static structures taking time
  App().m_hashEngine.delayed_ctor();
 
  // avoid crash by initialising (not in spec!)
  Game()->newGame();
  Game()->setFENInitialPos();
  Game()->getLevel().setDepthCommand(DEFAULT_DEPTH);
 
  if (argc > 1) {
    for (int i = 1; i < argc; i++) {
      std::string arg = argv[i];
      if (arg == "--help") {
        /// @todo allow aliases on commands
        AppEI()->execute("usage", argv[0]);
        goto belofte_exit;
      } else if (arg == "--version") {
        /// @todo allow aliases on commands
        AppEI()->execute("about", "");
        goto belofte_exit;
      } else if (arg == "-xboard") {
        // Arena default parameter for belofte is -xboard instead of --xboard
        AppEI()->execute("xboard", "");
      } else if ((arg == "bench") || (arg == "--bench")) {
        AppEI()->execute("bench", "");
        goto belofte_exit;
      } else if (arg.substr(0, 1) == "@") {
        if (arg.length() > 1) {
          AppEI()->execute("@", arg);
        } else {
          // space in between @ and filename
          if (i + 1 >= argc) {
            App().bout << "Use filename with @" << std::endl;
            goto belofte_exit;
          }
          arg = argv[++i];
          AppEI()->execute("@", arg);
        }
      } else if (arg.substr(0, 2) == "--") {
        try {
          /// @todo parse all next argument(s) before those preceeded by --
          AppEI()->execute(arg.substr(2), "");
        } catch (const quitCommandException&) {
          goto belofte_exit;
        } catch (const std::logic_error& e) {
          std::cout << "Logic Error: " << e.what() << std::endl;
        } catch (...) {
          std::cout << "Error: Uncatched exception" << std::endl;
        }
      } else {
        // no -- or @, so filename expected
        AppEI()->execute("exec", arg);
      }
    }
  }
 
  // default operation, used passed file or look for .rc file
  if (!App().m_reader.isFileAttached()) {
    App().m_reader.clearBatchMode();
    // execute belofte-version-x.rc if present
    AppEI()->execute("exec", App().getName() + ".rc");
  }
 
  try {
    App().m_reader.runner();
  } catch (const std::logic_error& e) {
    std::cout << "Logic Error: " << e.what() << std::endl;
  } catch (...) {
    std::cout << "Error: Uncatched exception" << std::endl;
  }
 
belofte_exit:
  // during program exit, no interactive commands are read
  App().m_reader.setBatchMode();
 
  // call some dtor's
  bPiece_dtor();
  platform_dtor();
 
  return 0;
}
 
//-----------------------------------------------------------------------
 
engineCommands_t engineInterface::m_engineCommands
        = decltype(engineInterface::m_engineCommands){};
 
//-----------------------------------------------------------------------
// global verbs valid in all cases
 
void engineInterface::execute(std::string const& command, std::string const& params)
{
  if (command != "") {
    if (engineInterface::m_engineCommands.find(command)
            != engineInterface::m_engineCommands.end()) {
      engineUserCommand *v = engineInterface::m_engineCommands[command];
      v->execute(params);
    } else if (params != "") {
      sendError("unknown command", command + " " + params);
    } else {
      sendError("unknown command", command);
    }
  }
}
 
void engineInterface::initCommand(std::vector<engineUserCommand *> cmds)
{
  for (size_t i = 0; i < cmds.size(); i++) {
    if (engineInterface::m_engineCommands.find(cmds[i]->m_name)
            == engineInterface::m_engineCommands.end()) {
      // do not initialize twice
      engineInterface::m_engineCommands[cmds[i]->m_name] = cmds[i];
    }
  }
}
 
void engineInterface::attachCommand(belofte::stringList const& sCommands,
        bool const published)
{
  if (published) {
    // TOFIX: if not published, add command to list anyway
    for (size_t i = 0; i < sCommands.size(); i++) {
      m_allowedCommands[sCommands[i]] = published;
    }
  }
}
 
//-----------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#endif
 
commandReader::commandReader()
  : m_filename{""}
{
}
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
commandReader::~commandReader()
{
  if (isFileAttached())
    detach();
}
 
void commandReader::runner()
{
  while (true) {
    if (!isFileAttached()) AppEI()->sendPrompt();
    try {
      cmdParam cmd = App().m_reader.getCommand();
      AppEI()->execute(cmd.m_command, cmd.m_args);
    } catch (const quitCommandException&) {
      // quit requested
      break;
    } catch (const noCommandException&) {
      // skip comments and empty lines
    } catch (...) { throw; // push other exceptions down
    }
  }
}
 
std::string commandReader::readLine()
{
  std::string line;
 
  while (line.empty()) {
    if (!isFileAttached()) {
      if (!std::getline(std::cin, line)) throw noCommandException();
    } else {
      if (!std::getline(m_inputfile, line)) {
        detach();
        throw noCommandException();
      }
    }
    if (!line.empty()) {
      AppEI()->sendDebug(2, line);
      if ((line[0] == '#')
          || (line[0] == '=')
          || (line[0] == ';')) line = "";
    }
  }
 
  return line;
}
 
cmdParam commandReader::getCommand()
{
  std::string line = readLine();
 
  if (line == "__END__") {
    detach();
    throw noCommandException();
  }
  if (line.empty()) throw noCommandException();
 
  cmdParam cmd;
  std::stringstream ss(line);
  std::getline(ss, cmd.m_command, ' ');
  std::getline(ss, cmd.m_args);
 
  /// @attention Bughouse moves use @ character as well
  if ((cmd.m_command.substr(0,1) == "@") && (cmd.m_command.length() > 1)) {
    // @file passed, move file to arg and truncate command
    cmd.m_args = cmd.m_command.substr(1);
    cmd.m_command = "@";
  }
 
  return cmd;
}
 
bool commandReader::attach(std::string const& ifile)
{
  m_filename = ifile;
  m_inputfile.open(m_filename.c_str(), std::ios_base::in);
  return isFileAttached();
}
 
bool commandReader::isFileAttached()
{
  if (m_filename == "") return false;
  if (!m_inputfile) return false;
  if (m_inputfile.eof()) detach();
  return m_inputfile.is_open();
}
 
void commandReader::detach()
{
  m_inputfile.close();
  m_filename = "";
}
 
/** no interactive input, mainly during start and '@' execute
 */
bool commandReader::isBatchMode()
{
  if (isFileAttached()) return true;
  return m_isBatch;
}
 
void commandReader::setBatchMode()
{
  m_isBatch = true;
}
 
void commandReader::clearBatchMode()
{
  m_isBatch = false;
}
 
//-----------------------------------------------------------------------
 
/** Common commands to all modes
 */
engineInterface::engineInterface(std::string const& n, std::string const& h)
  : m_name{n}
  , m_hint{h}
  , m_allowedCommands{}
{
  initCommand({new cmd_about(), new cmd_accepted(), new cmd_again(),
          new cmd_alg(), new cmd_bd(), new cmd_belofte(), new cmd_black(),
          new cmd_bench(), new cmd_computer(),
          new cmd_debug(), new cmd_dot(), new cmd_easy(),
          new cmd_echo(), new cmd_epd(), new cmd_epdpos(), new cmd_eval(),
          new cmd_evaltype(), new cmd_exec(), new cmd_execat(), new cmd_exit(),
          new cmd_expect(), new cmd_export(), new cmd_fd(),
          new cmd_force(), new cmd_game(),
          new cmd_go(), new cmd_hard(), new cmd_help(), new cmd_info(),
          new cmd_playother(), new cmd_isready(), new cmd_level(), new cmd_ls(),
          new cmd_new(), new cmd_nopost(),
          new cmd_option(), new cmd_otim(), new cmd_perft(),
          new cmd_ping(), new cmd_ponderhit(), new cmd_position(),
          new cmd_post(), new cmd_protover(),
          new cmd_questionmark(), new cmd_quit(), new cmd_rejected(),
          new cmd_random(), new cmd_remove(),
          new cmd_result(), new cmd_save(), new cmd_sd(), new cmd_st(),
          new cmd_setboard(), new cmd_setoption(), new cmd_stop(),
          new cmd_time(), new cmd_uci(), new cmd_ucinewgame(), new cmd_undo(),
          new cmd_usage(), new cmd_usermove(), new cmd_white(),
          new cmd_UCI_Opponent(), new cmd_name(),
          new cmd_UCI_EngineAbout(),
          new cmd_xboard()});
}
 
engineInterface::~engineInterface()
{
  m_allowedCommands.clear();
  engineCommands_t::iterator itr = engineInterface::m_engineCommands.begin();
  while (itr != engineInterface::m_engineCommands.end()) {
    delete itr->second;
    itr = engineInterface::m_engineCommands.erase(itr);
  }
  engineInterface::m_engineCommands.clear();
}
 
//-----------------------------------------------------------------------
 
BelofteMode::BelofteMode()
  : engineInterface("belofte", "Swith to xboard or UCI protocol")
{
  attachCommand({"usage", "version", "exec", "ls"}, false);
  attachCommand({"about", "xboard", "uci", "help", "bench", "perft"});
}
 
BelofteMode::~BelofteMode()
{
}
 
UCIMode::UCIMode(std::string const& n)
  : engineInterface(n)
{
  attachCommand({"belofte"}, false);
  attachCommand({"uci", "setoption", "isready", "position", "go",
          "stop", "ucinewgame", "ponderhit"});
}
 
UCIMode::~UCIMode()
{
}
 
XboardMode::XboardMode(std::string const& n)
  : engineInterface(n, "No xboard prompt")
{
  attachCommand({"accepted", "belofte", "black", "option", "otim", "ping",
          "time", "rejected", "white"}, false);
  attachCommand({"bd", "undo", "new", "setboard", "usermove", "game",
          "remove", "force", "level", "post", "nopost", "random",
          "easy", "hard", "go", "?", "result", "sd", "st", "protover"});
}
 
XboardMode::~XboardMode()
{
}
 
//-----------------------------------------------------------------------
 
appInstance::appInstance()
  : bout{std::cout}
  , sout{std::cout}
  , m_reader{}
  , m_hashEngine{}
  , m_debuginterface{}
  , m_ui{nullptr}
  , m_game{new bGame()}
  , m_settings{{}}
  , m_stringsettings{{}}
  , m_engineInterfaces{{}}
  , m_interfaceName{""}
{
  m_engineInterfaces["belofte"] = new BelofteMode();
  m_engineInterfaces["xboard"] = new XboardMode();
  m_engineInterfaces["uci"] = new UCIMode();
  // set default startup mode
  setMode("belofte");
}
 
appInstance::~appInstance()
{
  engineInterfaces_t::iterator itr = m_engineInterfaces.begin();
  while (itr != m_engineInterfaces.end()) {
    delete itr->second;
    itr = m_engineInterfaces.erase(itr);
  }
  m_engineInterfaces.clear();
}
 
std::string const appInstance::setMode(std::string const& iName)
{
  std::string sOldName = m_interfaceName;
  m_interfaceName = iName;
  m_ui = m_engineInterfaces[m_interfaceName];
  return sOldName;
}
 
void appInstance::setConfig(std::string const& s, int64_t v)
{
  m_settings[s] = v;
}
 
int64_t appInstance::getConfig(std::string const& s, int64_t v)
{
  if (m_settings.find(s) != m_settings.end()) return m_settings[s];
  return v;
}
 
void appInstance::setConfig(std::string const& s, std::string const& v)
{
  m_stringsettings[s] = v;
}
 
std::string appInstance::getConfig(std::string const& s, std::string const& v)
{
  if (m_stringsettings.find(s) != m_stringsettings.end()) return m_stringsettings[s];
  return v;
}
 
/** @brief set name of executable based on argv[0]
 *  Remove leading / and \ characters
 *  Remove trailing .exe if present
 */
void appInstance::setName(char *sName)
{
  std::string sExename;
 
  std::string sFile(sName);
  sExename = sFile.substr(sFile.find_last_of("/\\") + 1);
 
  // remove .exe
  if (sExename.find(".exe") != std::string::npos)
    sExename.erase(sExename.find(".exe"));
 
  App().setConfig("exename", sExename);
}
 
std::string appInstance::getName() const
{
  return App().getConfig("exename", MYLCNAME "-" MYVERSION);
}
 
// --------------------------------------------------------------------
 
appInstance& App()
{
  static appInstance& instance = *new appInstance();
  return instance;
}
 
engineInterface* AppEI()
{
  return App().m_ui;
}
 
bGame* Game()
{
  return App().m_game;
}
 
// --------------------------------------------------------------------
 
static void platform_ctor()
{
#if defined(BELOFTE_NOSIGNALS)
  // disable signals
  signal(SIGTERM, SIG_IGN);
  signal(SIGINT, SIG_IGN);
#endif
  // #if defined(_WIN32) || defined(WIN32)
  // setlocale(LC_ALL, ".UTF8");
  /// @todo remove following line ASAP, this violates all C++ standards
  // SetConsoleOutputCP(CP_UTF8); // select unicode compatiblity
  // call system("chcp 65001")
  // #endif
}
 
static void platform_dtor()
{
}
 
// eof