dynashell.cxx

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
//
// Package:   Dynamixel
//
// Program:   dynashell
//
// File:      dynashell.cxx
//
/*! \file
 *
 * $LastChangedDate: 2015-01-12 10:56:06 -0700 (Mon, 12 Jan 2015) $
 * $Rev: 3845 $
 *
 * \brief The Dynamixel Shell Class Execution Control and Support Functions.
 *
 * \author Robin Knight (robin.knight@roadnarrows.com)
 *
 * \copyright
 *   \h_copy 2011-2017. RoadNarrows LLC.\n
 *   http://www.roadnarrows.com\n
 *   All Rights Reserved
 */
/*
 * @EulaBegin@
 * 
 * Unless otherwise stated explicitly, all materials contained are copyrighted
 * and may not be used without RoadNarrows LLC's written consent,
 * except as provided in these terms and conditions or in the copyright
 * notice (documents and software) or other proprietary notice provided with
 * the relevant materials.
 * 
 * IN NO EVENT SHALL THE AUTHOR, ROADNARROWS LLC, OR ANY 
 * MEMBERS/EMPLOYEES/CONTRACTORS OF ROADNARROWS OR DISTRIBUTORS OF THIS SOFTWARE
 * BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR
 * CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
 * DOCUMENTATION, EVEN IF THE AUTHORS OR ANY OF THE ABOVE PARTIES HAVE BEEN
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 * THE AUTHORS AND  ROADNARROWS LLC SPECIFICALLY DISCLAIM ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN
 * "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 * 
 * @EulaEnd@
 */
////////////////////////////////////////////////////////////////////////////////


#include <stdio.h>
#include <stdarg.h>

#include <cstring>
#include <iostream>
#include <fstream>
#include <map>
#include <string>
#include <vector>

#include "rnr/rnrconfig.h"
#include "rnr/log.h"

#include "Dynamixel/Dynamixel.h"
#include "Dynamixel/DynaComm.h"
#include "Dynamixel/DynaCommBotSense.h"
#include "Dynamixel/DynaCommSerial.h"
#include "Dynamixel/DynaServo.h"

#include "dynashell.h"
#include "dynashell_cmd.h"
#include "dynashell_readline.h"
#include "dynashell_util.h"

using namespace std;


// ----------------------------------------------------------------------------
// Private Inteface
// ----------------------------------------------------------------------------

#define SH_RC_OK            0   ///< shell input ok
#define SH_RC_OK_NOEXEC     1   ///< shell input ok, but don't execute command
#define SH_RC_EOF           2   ///< end of file
#define SH_RC_SYS_ERROR     3   ///< system error on shell input
#define SH_RC_INTR          4   ///< shell interrupt


// ----------------------------------------------------------------------------
// DynaShell Class
// ----------------------------------------------------------------------------

/*!
 * \breif DynaShell default constructor.
 */
DynaShell::DynaShell()
    : m_sShellName("dynashell"),
      m_sPS1("dynashell> "),
      m_sPS2(": "),
      m_ReadLine(m_sShellName)
{
  m_bIsInteractive  = true;
  m_bXTrace         = false;
  m_bRun            = true;
  m_bNoExec         = false;
  m_bSilent         = false;
  m_pDynaComm       = NULL;
  m_pDynaChain      = NULL;
  m_pDynaBgThread   = NULL;
  m_pRecording      = NULL;
  m_rc              = DYNA_OK;

  InputInit();
};

/*!
 * \breif DynaShell destructor.
 */
DynaShell::~DynaShell()
{
  if( m_pDynaBgThread != NULL )
  {
    m_pDynaBgThread->Stop();
    delete m_pDynaBgThread;
  }

  if( m_pDynaChain != NULL )
  {
    delete m_pDynaChain;
  }

  if( m_pDynaComm != NULL )
  {
    delete m_pDynaComm;
  }

  if( m_pRecording != NULL )
  {
    delete m_pRecording;
  }

  ScriptFlush();

  DeleteCommands(m_mapCmds);
}

/*!
 * \brief Publish new command map to shell.
 *
 * The new map is inserted into the map of root commands. The map is kept
 * in lexicogrphahical increasing order.
 *
 * \note Published commands currently only support two levels. However,
 *       this can be readily extended given some command separator convention.
 *
 * \param sParent   Parent command. Set to NULL or "" to publish the command at
 *                  the root(0) level.
 * \param strBrief  Map brief description.
 */
void DynaShell::PublishMap(const char *sParent, const string &strBrief)
{
  string                strRegEx;
  int                   nUid;

  // publish only if map does not exist
  if( m_mapCmds.find(sParent) == m_mapCmds.end() )
  {
    m_mapCmds[sParent] = new ShCmdMap;
    m_mapCmds[sParent].SetMapBrief(strBrief);

    strRegEx = "^";
    strRegEx += sParent;
    strRegEx += "$";

    nUid = m_ReadLine.RegisterGenerator(strRegEx, CmdListGeneratorWrap, this);
  }
}

/*!
 * \brief Publish new command to shell.
 *
 * The new command is inserted into the map of commands. The map is kept
 * in lexicogrphahical increasing order.
 *
 * \note Published commands currently only support two levels. However,
 *       this can be readily extended given some command separator convention.
 *
 * \param sParent   Parent command. Set to NULL or "" to publish the command at
 *                  the root(0) level.
 * \param pNewCmd   Allocated new command. The shell owns the command and will
 *                  delete it when the shell is destroyed.
 */
void DynaShell::PublishCommand(const char *sParent, DynaShellCmd *pNewCmd)
{
  const char           *sCmdName = pNewCmd->GetCmdName();
  string                strRegEx;
  int                   nUid;

  // new root command
  if( (sParent == NULL) || (*sParent == 0) )
  {
    pNewCmd->SetPublishedInfo(0);
    m_mapCmds[sCmdName] = pNewCmd;
    m_mapCmds[sCmdName].SetMapBrief(pNewCmd->GetCmdHelpBrief());
  }

  // new command published to existing root group
  else if( m_mapCmds.find(sParent) != m_mapCmds.end() )
  {
    pNewCmd->SetPublishedInfo(1, sParent);

    (*m_mapCmds[sParent].GetMap())[sCmdName] = pNewCmd;
    (*m_mapCmds[sParent].GetMap())[sCmdName].SetMapBrief(
                                                pNewCmd->GetCmdHelpBrief());
  }

  // new command published to new root group
  else
  {
    pNewCmd->SetPublishedInfo(1, sParent);

    m_mapCmds[sParent] = new ShCmdMap;

    (*m_mapCmds[sParent].GetMap())[sCmdName] = pNewCmd;

    strRegEx = "^";
    strRegEx += sParent;
    strRegEx += "$";

    nUid = m_ReadLine.RegisterGenerator(strRegEx, CmdListGeneratorWrap, this);
  }

  // register new command for readline tab-completion
  strRegEx = pNewCmd->GetPublishedName();
  strRegEx += ".*";

  nUid = m_ReadLine.RegisterGenerator(strRegEx, CmdSpecGeneratorWrap, this);

  if( nUid != ReadLine::NOT_REG )
  {
    m_mapTabGen[nUid] = pNewCmd; 
  }
}

/*!
 * \brief Delete all published commands in map.
 *
 * \param cmdMap    Map of published commands.
 */
void DynaShell::DeleteCommands(ShCmdMap &cmdMap)
{
  ShCmdMap::iterator  iter;

  m_mapTabGen.clear();

  for(iter=cmdMap.begin(); iter!=cmdMap.end(); iter++)
  {
    if( iter->second.IsCmd() )
    {
      delete iter->second.GetCmd();
    }
    else if( iter->second.IsMap() )
    {
      DeleteCommands(*iter->second.GetMap());
    }
  }
}

/*! 
 *  \brief Initialize input. 
 */
void DynaShell::InputInit()
{
  m_ReadLine.RegisterGenerator("^$", CmdListGeneratorWrap, this);
}

/*! 
 * \brief Command list generator wrapper function.
 *
 * \param nUid      ReadLine registered unique id.
 * \param sText     Text string to complete as a command.
 * \param uTextLen  Length of text.
 * \param nState    Generator state. State lets us know whether to start from
 *                  scratch. If state == START(0), then we start at the top of
 *                  the command list.
 * \param sContext  Parent command path.
 * \param pArg      Pointer to this shell instance.
 *
 * \return 
 * On command partial matching, returns allocated full command name string.\n
 * If no matches found, return NULL.
 */
char *DynaShell::CmdListGeneratorWrap(int         nUid,
                                      const char *sText,
                                      size_t      uTextLen,
                                      int         nState,
                                      const char *sContext,
                                      void       *pArg)
{
  DynaShell *pShell = (DynaShell *)pArg;

  return pShell->CmdListGenerator(nUid, sText, uTextLen, nState, sContext);
}

/*! 
 * \brief Command list generator function.
 *
 * \param nUid      ReadLine registered unique id.
 * \param sText     Text string to complete as a command.
 * \param uTextLen  Length of text.
 * \param nState    Generator state. State lets us know whether to start from
 *                  scratch. If state == START(0), then we start at the top of
 *                  the command list.
 * \param sContext  Parent command path.
 *
 * \return 
 * On command partial matching, returns allocated full command name string.\n
 * If no matches found, return NULL.
 */
char *DynaShell::CmdListGenerator(int         nUid,
                                  const char *sText,
                                  size_t      uTextLen,
                                  int         nState,
                                  const char *sContext)
{
  static ShCmdMap           *pMap;      // command map
  static ShCmdMap::iterator  iterCmd;   // command map iterator

  const char                *sCmdName;  // command name

  //
  // New command to complete - initialize.
  //
  if( nState == ReadLine::FIRST )
  {
    pMap    = NULL;
    iterCmd = m_mapCmds.end();

    // root commands
    if( (sContext == NULL) || (*sContext == 0) )
    {
      pMap = &m_mapCmds;
      iterCmd = pMap->begin();
    }

    // level 1 commands
    else
    {
      iterCmd = m_mapCmds.find(sContext);
      if( iterCmd != m_mapCmds.end() )
      {
        pMap = iterCmd->second.GetMap();
        if( pMap != NULL )
        {
          iterCmd = pMap->begin();
        }
      }
    }
  }

  // return the next command which partially matches text
  while( (pMap != NULL) && (iterCmd != pMap->end()) )
  {
    sCmdName = iterCmd->first;
    iterCmd++;
    if( !strncmp(sCmdName, sText, uTextLen) )
    {
      return ReadLine::dupstr(sCmdName);
    }
  }

  // no matches
  return NULL;
}

/*! 
 * \brief Command spec generator wrapper function.
 *
 * \param nUid      ReadLine registered unique id.
 * \param sText     Text string to complete as a command.
 * \param uTextLen  Length of text.
 * \param nState    Generator state. State lets us know whether to start from
 *                  scratch. If state == START(0), then we start at the top of
 *                  the command list.
 * \param sContext  Parent command path.
 * \param pArg      Pointer to this shell instance.
 *
 * \return 
 * On command partial matching, returns allocated full command name string.\n
 * If no matches found, return NULL.
 */
char *DynaShell::CmdSpecGeneratorWrap(int         nUid,
                                      const char *sText,
                                      size_t      uTextLen,
                                      int         nState,
                                      const char *sContext,
                                      void       *pArg)
{
  DynaShell *pShell = (DynaShell *)pArg;

  return pShell->CmdSpecGenerator(nUid, sText, uTextLen, nState, sContext);
}

/*! 
 * \brief Command spec generator function.
 *
 * \param nUid      ReadLine registered unique id.
 * \param sText     Text string to complete as a command.
 * \param uTextLen  Length of text.
 * \param nState    Generator state. State lets us know whether to start from
 *                  scratch. If state == START(0), then we start at the top of
 *                  the command list.
 * \param sContext  Parent command path.
 *
 * \return 
 * On command partial matching, returns allocated full command name string.\n
 * If no matches found, return NULL.
 */
char *DynaShell::CmdSpecGenerator(int         nUid,
                                  const char *sText,
                                  size_t      uTextLen,
                                  int         nState,
                                  const char *sContext)
{
  MapTabCompleteGen::iterator pos;

  if( (pos = m_mapTabGen.find(nUid)) != m_mapTabGen.end() )
  {
    return pos->second->TabCompletion(*this, sText, uTextLen, nState, sContext);
  }

  // no matches
  else
  {
    return NULL;
  }
}

/*! 
 *  \brief Add command line to history.
 *
 *  \param sLine  Null-terminated line string.
 */
void DynaShell::AddToHistory(char *sLine)
{
  if( IsExecStmt(sLine) && m_bIsInteractive && isatty(fileno(InputFp())) )
  {
    m_ReadLine.AddToHistory(sLine);
  }
}

/*! 
 * \brief Get one input line from file stream.
 *
 * Characters will be read from the input of the given file pointer using the
 * prompt string to prompt the user. If the prompt is NULL or an empty string
 * then no prompt is issued. The line returned is allocated, so the caller must
 * free it when finished.
 *
 * If the readline free library is available, then command line editing is
 * supported for terminal input.
 *
 * \todo TODO add '\\' parsing for line continuation.
 *
 * \return If no errors occurred and EOF is not encountered, an allocated,
 * null-terminated line buffer is return. If the input only contained 
 * non-executable characters (white-space and comments), then the line buffer
 * will be empty. On EOF or errors, NULL is returned. 
 */
char *DynaShell::GetInputLine()
{
  static const char *sPrompt = m_sPS1;

  char   *sLine = NULL;

  //
  // Get malloc'd line of input (fragment)
  //
  if( isatty(fileno(InputFp())) )
  {
    sLine = m_ReadLine.iReadLine(sPrompt);
  }
  else
  {
    sLine = m_ReadLine.fReadLine(InputFp(), NULL);
    ScriptBumpLineNum();
  }

  // EOF or I/O error
  if( sLine == NULL )
  {
    return NULL;
  }

  return sLine;
}

/*!
 * \brief Get one, non-empty input line.
 *
 * \return
 * On success, returns SH_RC_OK).\n
 * On end of file, returns SH_RC_EOF.\n
 * On system error, returns SH_RC_SYS_ERROR.
 */
int DynaShell::GetInput()
{
  char *sLine;

  m_sInputLine = NULL;

  while( true )
  {
    // get one logical line of input
    sLine = GetInputLine();

    // eof or system error
    if( sLine == NULL ) 
    {
      if( IsEOF() )
      {
        return SH_RC_EOF;
      }
      else
      {
        Error("%s.", strerror(errno));
        return SH_RC_SYS_ERROR;
      }
    }

    // skip leading whitespace
    while(*sLine && isspace(*sLine))
    {
      sLine++;
    }

    if( IsExecStmt(sLine) )
    {
      // add non-blnak input line to command history
      AddToHistory(sLine);

      // trace script
      if( IsExecStmt(sLine) && (m_bIsInteractive || m_bXTrace) )
      {
        ScriptTrace(sLine);
      }

      m_sInputLine = sLine;

      return m_bNoExec? SH_RC_OK_NOEXEC: SH_RC_OK;
    }
    else
    {
      return SH_RC_OK_NOEXEC;
    }
  }
}

/*!
 * \brief Match command.
 *
 * \param argc    Command argument count.
 * \param argv    Array of arguments.
 * \param cmdMap  Command map to search.
 *
 * \return Returns pointer to matched command on success. NULL otherwise.
 */
DynaShellCmd *DynaShell::MatchCmd(int argc, char *argv[], ShCmdMap &cmdMap)
{
  ShCmdMap::iterator  iter1, iter2;
  char               *sPattern;
  const char         *sCmdName1, *sCmdName2;
  size_t              n;
  bool_t              bIsUnique = true;
  int                 cnt;
  
  if( argc == 0 )
  {
    Error("No Command.");
    return NULL;
  }

  sPattern = argv[0];

  n = strlen(sPattern);

  // find command
  for(iter1=cmdMap.begin(); iter1!=cmdMap.end(); iter1++)
  {
    sCmdName1 = iter1->first;
    if( !strncmp(sPattern, sCmdName1, n) )
    {
      break;
    }
  }

  // no matching command found
  if( iter1 == cmdMap.end() )
  {
    Error("%s: Command not found.\n", sPattern);
    return NULL;
  }

  // verify uniqueness
  for(iter2=cmdMap.begin(); iter2!=cmdMap.end(); iter2++)
  {
    if( iter2 == iter1 )
    {
      continue;
    }

    sCmdName2 = iter2->first;

    // another match 
    if( !strncmp(sPattern, sCmdName2, n) )
    {
      cnt++;

      // first non-unique
      if( bIsUnique )
      {
        fprintf(stderr, "%s: Command not unique: Matches %s %s",
            sPattern, sCmdName1, sCmdName2);
        bIsUnique = false;
      }

      // subsequent non-uniques
      else if( cnt < 8 )
      {
        fprintf(stderr, " %s", sCmdName2);
      }

      // too many to print
      else
      {
        fprintf(stderr, " ...");
        break;
      }
    }
  }

  if( !bIsUnique )
  {
    fprintf(stderr, "\n");
    return NULL;
  }

  if( iter1->second.IsCmd() )
  {
    return iter1->second.GetCmd();
  }
  else if( iter1->second.IsMap() )
  {
    return MatchCmd(argc-1, argv+1, *iter1->second.GetMap());
  }
  else
  {
    return NULL;
  }
}

/*!
 * \brief Push new script on the stack.
 *
 * The new script becomes the point of execution.
 *
 * \param sScriptFile   Script file path name.
 * \param fp            Script file opened file pointer.
 */
void DynaShell::ScriptPush(const char *sScriptFile, FILE *fp)
{
  ShScript  *pScript;

  if( (int)m_vecScripts.size() >= m_nMaxScriptDepth )
  {
    Error("Cannot execute script %s: At maximum script depth of %d",
        sScriptFile, m_nMaxScriptDepth);
  }
  else
  {
    pScript = new ShScript(sScriptFile, fp);
    m_vecScripts.push_back(pScript);
  }
}

/*!
 * \brief Pop the current script from stack.
 *
 * The new top-of-stack script resumes execution. If there are no more scripts
 * on the stack and this shell is not user interactive, then the shell will
 * marked for termination. Otherwise, if the stack is empty, standard input
 * becomes the point of execution.
 */
void DynaShell::ScriptPop()
{
  ShScript  *pScript;

  if( (int)m_vecScripts.size() > 0 )
  {
    pScript = m_vecScripts.back();
    m_vecScripts.pop_back();
    delete pScript;
  }

  if( !m_bIsInteractive && m_vecScripts.empty() )
  {
    m_bRun = false;
  }
}

/*!
 * \brief Flush all scripts from stack.
 *
 * If this shell is not user interactive, the shell will marked for termination.
 * Otherwise, standard input becomes the point of execution.
 */
void DynaShell::ScriptFlush()
{
  ShScript *pScript;
  int       i;

  for(i=0; i<(int)m_vecScripts.size(); ++i)
  {
    pScript = m_vecScripts.back();
    m_vecScripts.pop_back();
    delete pScript;
  }

  if( !m_bIsInteractive )
  {
    m_bRun = false;
  }
}

/*!
 * \brief Trace script execution.
 *
 * \param sLine   Executable script statement.
 */
void DynaShell::ScriptTrace(const char *sLine)
{
  if( IsRunningScript() )
  {
    if( m_bIsInteractive )
    {
      printf(": %s\n", sLine);
    }
    else
    {
      printf("%s[%d]: %s\n",
        m_vecScripts.back()->GetScriptName(),
        m_vecScripts.back()->GetLineNum(),
        sLine);
    }
  }
}

/*!
 * \brief Print formatted success response.
 *
 * \param sFmt  Format string.
 * \param ...   Variable argument list.
 */
void DynaShell::Response(const char *sFmt, ...)
{
  va_list ap;

  if( !m_bSilent )
  {
    va_start(ap, sFmt);
    vprintf(sFmt, ap);
    va_end(ap);
  }
}

/*!
 * \brief Issue warning.
 *
 * \param sFmt  Format string.
 * \param ...   Optional format string arguments.
 */
void DynaShell::Warning(const char *sFmt, ...)
{
  va_list ap;

  if( !m_vecScripts.empty() )
  {
    fprintf(stderr, "%s[%d]: ",
        m_vecScripts.back()->GetScriptName(),
        m_vecScripts.back()->GetLineNum());
  }

  fprintf(stderr, "Warning: ");
  
  va_start(ap, sFmt);
  vfprintf(stderr, sFmt, ap);
  va_end(ap);

  fprintf(stderr, "\n");
}

/*!
 * \brief Raise error on dynamixel error code.
 *
 * \param rc    \ref dyna_ecodes.
 * \param sFmt  Format string.
 * \param ...   Optional format string arguments.
 */
void DynaShell::Error(int rc, const char *sFmt, ...)
{
  char    buf[256];
  va_list ap;

  va_start(ap, sFmt);

  vsnprintf(buf, sizeof(buf), sFmt, ap);
  buf[sizeof(buf)-1] = 0;

  va_end(ap);
    
  Error("%s: %s", DynaStrError(rc), buf);
}

/*!
 * \brief Raise error on alarmed servo.
 *
 * \param nServoId  Servo id.
 * \param uAlarms   \ref dyna_memmap_gen_alarm_shutdown.
 */
void DynaShell::Error(int nServoId, uint_t uAlarms)
{
  string  strAlarms;

  strAlarms = DynaComm::GetAlarmsString(uAlarms);

  Error("Servo %d: Alarms: %s.", nServoId, strAlarms.c_str());
}

/*!
 * \brief Raise error.
 *
 * If the error occurred while running a script, the script is aborted.
 * If the shell is non-interactive, the shell is terminated.
 *
 * \param sFmt  Format string.
 * \param ...   Optional format string arguments.
 */
void DynaShell::Error(const char *sFmt, ...)
{
  va_list ap;

  if( !m_vecScripts.empty() )
  {
    fprintf(stderr, "%s[%d]: ",
        m_vecScripts.back()->GetScriptName(),
        m_vecScripts.back()->GetLineNum());
  }

  fprintf(stderr, "Error: ");
  
  va_start(ap, sFmt);
  vfprintf(stderr, sFmt, ap);
  va_end(ap);

  fprintf(stderr, "\n");

  m_rc = -DYNA_ECODE_RUNTIME;

  ScriptFlush();

  if( !m_bIsInteractive )
  {
    m_bRun = false;
  }
}

/*!
 * \brief Command execution loop.
 *
 * Loop through all commands from input intil EOF, error, or user commanded
 * termination.
 *
 * \return DYNA_OK on successful execution, \h_lt 0 on failure.
 */
int DynaShell::Run()
{
  int           tokc;
  char         *tokv[1024];
  DynaShellCmd *pCmd;
  int           nOffset;    // command-line arguments start offset
  int           rc;

  if( m_bIsInteractive )
  {
    printf("  Dynamixel Simple Shell\n");
    printf("(enter 'help' for list of commands; "
         "partial command matching supported)\n\n");
  }

  while( m_bRun )
  {
    // clear any old shell command return code
    m_rc = DYNA_OK;

    // parse [compound] statement
    rc = GetInput();

    //
    // test terminating conditions
    //
    switch( rc )
    {
      // parse and execute
      case SH_RC_OK:
        // tokenize input
        tokc = ReadLine::tokenize(m_sInputLine, tokv, arraysize(tokv));

        if( tokc <= 0 )
        {
          continue;
        }

        // find command
        pCmd = MatchCmd(tokc, tokv, m_mapCmds);

        if( pCmd != NULL )
        {
          nOffset = pCmd->GetPublishedLevel() + 1;

          // execute command
          pCmd->Exec(*this, tokc-nOffset, tokv+nOffset);
        }
        break;

      // parse but don't execute
      case SH_RC_OK_NOEXEC:
        break;

      // end-of-file
      case SH_RC_EOF:
        ScriptPop();
        break;

      // system or other error
      case SH_RC_SYS_ERROR:
      default:
        // if not interactive terminate loop
        if( !m_bIsInteractive )
        {
          m_rc   = -DYNA_ECODE_SYS;
          m_bRun = false;
        }
        break;
    }
  }

  return m_rc;
}