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 13/04/2026 latest released version: 2.2.0
 */
 
/**
 * 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);
  App().setConfig("UCIdebug", 0);
 
  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");
#elif defined(BELOFTE_XBOARDMODE)
  App().setMode("xboard");
#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;
#if !defined(BELOFTE_UCIMODE)
      } else if ((arg == "xboard") || (arg == "-xboard") || (arg == "--xboard")) {
        App().setMode("xboard");
        App().bout.endl();
#endif
      } 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 @";
            App().bout.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 preceded 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: Unmatched exception" << std::endl;
        }
      } else {
        /// @deprecated 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: Unmatched 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;
}
 
//-----------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#endif
 
appInstance::appInstance()
  : bout{std::cout}
  , sout{std::cout}
  , m_ui{nullptr}
  , m_game{new bGame()}
  // other members do not need to be initialised as they are auto-constructed
{
  m_engineInterfaces["belofte"] = new BelofteMode();
#if defined(BELOFTE_XBOARDMODE)
  m_engineInterfaces["xboard"] = new XboardMode();
  setMode("xboard");
#elif defined(BELOFTE_UCIMODE)
  m_engineInterfaces["uci"] = new UCIMode();
  setMode("uci");
#else
  m_engineInterfaces["xboard"] = new XboardMode();
  m_engineInterfaces["uci"] = new UCIMode();
  // set default startup mode
  setMode("belofte");
#endif
}
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
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()
{
  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 compatibility
  // call system("chcp 65001")
  // #endif
}
 
static void platform_dtor()
{
}
 
// eof