G4UIterminal.cc

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
//
//
// ====================================================================
//   G4UIterminal.cc
//
// ====================================================================
#include "G4UIterminal.hh"
 
#include "G4StateManager.hh"
#include "G4Types.hh"
#include "G4UIcommand.hh"
#include "G4UIcommandStatus.hh"
#include "G4UIcommandTree.hh"
#include "G4UIcsh.hh"
 
#include <sstream>
 
#ifndef WIN32
#  include <csignal>
#endif
 
// ====================================================================
// signal handler for soft-abort
// ====================================================================
 
static G4ThreadLocal G4VUIshell* theshell = nullptr;
 
#ifndef WIN32
 
extern "C"
{
  ////////////////////////////////
  static void SignalHandler(G4int)
  ////////////////////////////////
  {
    G4StateManager* stateManager = G4StateManager::GetStateManager();
    G4ApplicationState state = stateManager->GetCurrentState();
 
    if (state == G4State_GeomClosed || state == G4State_EventProc) {
      G4cout << "aborting Run ...";
      G4UImanager::GetUIpointer()->ApplyCommand("/run/abort");
      G4cout << G4endl;
    }
    else {
      G4cout << G4endl << "Session terminated." << G4endl;
      theshell->ResetTerminal();
      G4Exception(
        "G4UIterminal::SignalHandler()", "UI0001", FatalException, "KeyboardInterrput with Ctrl-C");
    }
 
    // for original Unix / System V
    signal(SIGINT, SignalHandler);
  }
}
#endif
 
// ====================================================================
//
// class description
//
// ====================================================================
 
///////////////////////////////////////////////////////////
G4UIterminal::G4UIterminal(G4VUIshell* aShell, G4bool qsig)
///////////////////////////////////////////////////////////
{
  UI = G4UImanager::GetUIpointer();
  UI->SetSession(this);
  UI->SetCoutDestination(this);
 
  iExit = false;
  iCont = false;
 
  if (aShell != nullptr)
    shell = aShell;
  else
    shell = new G4UIcsh;
  theshell = shell;  // locally stored for the signal handler
 
  // add signal handler
  if (qsig) {
#ifndef WIN32
    signal(SIGINT, SignalHandler);
#endif
  }
}
 
/////////////////////////////
G4UIterminal::~G4UIterminal()
/////////////////////////////
{
  delete shell;
 
  if (G4UImanager::GetUIpointer() != nullptr) {
    UI->SetSession(nullptr);
    UI->SetCoutDestination(nullptr);
  }
}
 
////////////////////////////////////////////////////
void G4UIterminal::SetPrompt(const G4String& prompt)
////////////////////////////////////////////////////
{
  shell->SetPrompt(prompt);
}
 
/////////////////////////////////////////
G4UIsession* G4UIterminal::SessionStart()
/////////////////////////////////////////
{
  iExit = true;
 
  G4String newCommand = GetCommand();
  while (iExit) {
    ExecuteCommand(newCommand);
    newCommand = GetCommand();
  }
  return nullptr;
}
 
/////////////////////////////////////////////////////////
void G4UIterminal::PauseSessionStart(const G4String& msg)
/////////////////////////////////////////////////////////
{
  iCont = true;
 
  G4String newCommand = GetCommand(msg);
  while (iCont) {
    ExecuteCommand(newCommand);
    newCommand = GetCommand(msg);
  }
}
 
///////////////////////////////////////////////////////////
void G4UIterminal::ExecuteCommand(const G4String& aCommand)
///////////////////////////////////////////////////////////
{
  if (aCommand.length() < 2) return;
 
  G4int returnVal = UI->ApplyCommand(aCommand);
 
  G4int paramIndex = returnVal % 100;
  // 0 - 98 : paramIndex-th parameter is invalid
  // 99     : convination of parameters is invalid
  G4int commandStatus = returnVal - paramIndex;
 
  G4UIcommand* cmd = nullptr;
  if (commandStatus != fCommandSucceeded) {
    cmd = FindCommand(aCommand);
  }
 
  switch (commandStatus) {
    case fCommandSucceeded:
      break;
    case fCommandNotFound:
      G4cerr << "command <" << UI->SolveAlias(aCommand) << "> not found" << G4endl;
      if (aCommand.find("@@") != G4String::npos) {
        G4cout << "@@G4UIterminal" << G4endl;
      }
      break;
    case fIllegalApplicationState:
      G4cerr << "illegal application state -- command refused" << G4endl;
      break;
    case fParameterOutOfRange:
      // if(paramIndex<99) {
      //   G4cerr << "Parameter is out of range (index " << paramIndex << ")" << G4endl;
      //   G4cerr << "Allowed range : " << cmd->GetParameter(paramIndex)->GetParameterRange() <<
      //   G4endl;
      // } else {
      //   G4cerr << "Parameter is out of range" << G4endl;
      //   G4cerr << "Allowed range : " << cmd->GetRange() << G4endl;
      // }
      break;
    case fParameterOutOfCandidates:
      G4cerr << "Parameter is out of candidate list (index " << paramIndex << ")" << G4endl;
      G4cerr << "Candidates : " << cmd->GetParameter(paramIndex)->GetParameterCandidates()
             << G4endl;
      break;
    case fParameterUnreadable:
      G4cerr << "Parameter is wrong type and/or is not omittable (index " << paramIndex << ")"
             << G4endl;
      break;
    case fAliasNotFound:
    default:
      G4cerr << "command refused (" << commandStatus << ")" << G4endl;
  }
}
 
//////////////////////////////////////////////////
G4String G4UIterminal::GetCommand(const char* msg)
//////////////////////////////////////////////////
{
  G4String newCommand = shell->GetCommandLineString(msg);
  G4String nullString = "";
 
  G4String nC = G4StrUtil::lstrip_copy(newCommand);
 
  if (nC.length() == 0) {
    newCommand = nullString;
  }
  else if (nC[0] == '#') {
    G4cout << nC << G4endl;
    newCommand = nullString;
  }
  else if (nC == "ls" || nC.substr(0, 3) == "ls ") {  // list commands
    ListDirectory(nC);
    newCommand = nullString;
  }
  else if (nC == "lc" || nC.substr(0, 3) == "lc ") {  // ... by shell
    shell->ListCommand(nC.erase(0, 2));
    newCommand = nullString;
  }
  else if (nC == "pwd") {  // show current directory
    G4cout << "Current Command Directory : " << GetCurrentWorkingDirectory() << G4endl;
    newCommand = nullString;
  }
  else if (nC == "cwd") {  // ... by shell
    shell->ShowCurrentDirectory();
    newCommand = nullString;
  }
  else if (nC == "cd" || nC.substr(0, 3) == "cd ") {  // "cd"
    ChangeDirectoryCommand(nC);
    shell->SetCurrentDirectory(GetCurrentWorkingDirectory());
    newCommand = nullString;
  }
  else if (nC == "help" || nC.substr(0, 5) == "help ") {  // "help"
    TerminalHelp(nC);
    newCommand = nullString;
  }
  else if (nC[0] == '?') {  // "show current value of a parameter"
    ShowCurrent(nC);
    newCommand = nullString;
  }
  else if (nC == "hist" || nC == "history") {  // "hist/history"
    G4int nh = UI->GetNumberOfHistory();
    for (G4int i = 0; i < nh; i++) {
      G4cout << i << ": " << UI->GetPreviousCommand(i) << G4endl;
    }
    newCommand = nullString;
  }
  else if (nC[0] == '!') {  // "!"
    G4String ss = nC.substr(1, nC.length() - 1);
    G4int vl;
    const char* tt = ss;
    std::istringstream is(tt);
    is >> vl;
    G4int nh = UI->GetNumberOfHistory();
    if (vl >= 0 && vl < nh) {
      newCommand = UI->GetPreviousCommand(vl);
      G4cout << newCommand << G4endl;
    }
    else {
      G4cerr << "history " << vl << " is not found." << G4endl;
      newCommand = nullString;
    }
  }
  else if (nC == "exit") {  // "exit"
    if (iCont) {
      G4cout << "You are now processing RUN." << G4endl;
      G4cout << "Please abort it using \"/run/abort\" command first" << G4endl;
      G4cout << " and use \"continue\" command until the application" << G4endl;
      G4cout << " becomes to Idle." << G4endl;
    }
    else {
      iExit = false;
      newCommand = nullString;
    }
  }
  else if (nC == "cont" || nC == "continue") {  // "cont/continu"
    iCont = false;
    newCommand = nullString;
  }
  else if (nC.empty()) {  // NULL command
    newCommand = nullString;
  }
  else {
  }
 
  return ModifyToFullPathCommand(newCommand);
}
 
/////////////////////////////////////////////////////////////
G4int G4UIterminal::ReceiveG4debug(const G4String& debugString)
/////////////////////////////////////////////////////////////
{
  std::cout << debugString << std::flush;
  return 0;
}
 
/////////////////////////////////////////////////////////////
G4int G4UIterminal::ReceiveG4cout(const G4String& coutString)
/////////////////////////////////////////////////////////////
{
  std::cout << coutString << std::flush;
  return 0;
}
 
/////////////////////////////////////////////////////////////
G4int G4UIterminal::ReceiveG4cerr(const G4String& cerrString)
/////////////////////////////////////////////////////////////
{
  std::cerr << cerrString << std::flush;
  return 0;
}
 
///////////////////////////////////////////////
G4bool G4UIterminal::GetHelpChoice(G4int& aInt)
///////////////////////////////////////////////
{
  G4cin >> aInt;
  if (! G4cin.good()) {
    G4cin.clear();
    G4cin.ignore(30, '\n');
    return false;
  }
  return true;
}
 
///////////////////////////////////
void G4UIterminal::ExitHelp() const
///////////////////////////////////
{
  char temp[100];
  G4cin.getline(temp, 100);
}