rnr::cmd::CommandLine Class Reference

CommandLine class. More...

#include <CommandLine.h>

Public Member Functions
	CommandLine (const std::string strName="cl", const std::string strPrompt="> ", bool bUseRlLib=true, bool bIgnoreCase=false)
	Default initialization constructor. More...
virtual	~CommandLine ()
	Destructor.
bool	isDefined () const
bool	ok () const
	Test if command-line interface is ok to continue. More...
void	quit ()
	Mark command-line interface to quit.
bool	getBtEnable () const
	Test if backtracing is enabled. More...
void	setBtEnable (bool bEnable)
	Enable/disable backtracing. More...
virtual int	addCommand (const CmdDesc &desc)
	Add a command to the command line interface. More...
virtual int	addCommand (const CmdDesc &desc, CmdExec1Func fnExec)
	Add a command to the command line interface. More...
virtual int	addCommand (const CmdDesc &desc, CmdExec2Func fnExec)
	Add a command to the command line interface. More...
virtual int	addCommand (const CmdDesc &desc, CmdExec3Func fnExec)
	Add a command to the command line interface. More...
virtual int	addCommand (const std::string strSyntax)
	Add a command to the command line interface. More...
virtual int	addCommand (const std::string strSyntax, CmdExec1Func fnExec)
	Add a command to the command line interface. More...
virtual int	addCommand (const std::string strSyntax, CmdExec2Func fnExec)
	Add a command to the command line interface. More...
virtual int	addCommand (const std::string strSyntax, CmdExec3Func fnExec)
	Add a command to the command line interface. More...
virtual int	removeCommand (const int uid)
	Remove command from command line interface. More...
virtual int	removeCommand (const std::string &strName)
	Remove command from command line interface. More...
virtual int	removeAllCommands ()
	Remove all commands from command line interface. More...
virtual int	compile ()
	Compile all added commands. More...
int	addDataSection (const std::string &ns, void *pData, DataSect::DeallocFunc fn=NULL)
	Add a data section to the command-line interface. More...
int	removeDataSection (const std::string &ns)
	Remove a data section from the command-line interface. More...
void *	getDataSection (const std::string &ns)
	Get the section data under the specified namespace. More...
bool	isReservedDataSection (const std::string &ns) const
	Test if the namespace is a command-line interface reserved name. More...
virtual int	readCommand (int &uid, int &iform, str::StringVec &argv)
	Read an input line from stdin and match to the best compiled command. More...
virtual int	readCommand (CmdExtArgVec &argv)
	Read an input line from stdin and match to the best compiled command. More...
virtual int	readCommand (FILE *fp, int &uid, int &iform, str::StringVec &argv)
	Read an input line from file fp and match to the best compiled command. More...
virtual int	readCommand (FILE *fp, CmdExtArgVec &argv)
	Read an input line from file fp and match to the best compiled command. More...
bool	kbhit ()
bool	kbhit (FILE *fp)
virtual int	execute (const str::StringVec &argv)
	Execute a comamnd with the given arguments. More...
virtual int	execute (const CmdExtArgVec &argv)
	Execute a comamnd with the given arguments. More...
virtual void	addToHistory (const str::StringVec &argv)
	Add command to history. More...
virtual void	addToHistory (const CmdExtArgVec &argv)
	Add command to history. More...
void	pushPrompt (const std::string &strPrompt)
	Push prompt string onto stack of prompts. More...
void	popPrompt ()
	Pop prompt string from stack of prompts. More...
const std::string &	getPrompt () const
	Get the current prompt string. More...
size_t	getLineNum () const
	Get the line number of the last read line. More...
void	setLineNum (const size_t uLineNum)
	Set the current line number. More...
void	resetLineNum ()
	Reset the line number to zero.
int	numOfArgs (int uid, int iform) const
	Get the total number of arguments. More...
int	numOfArgs (const CmdExtArg &arg) const
	Get the total number of arguments of matched command. More...
int	numOfRequiredArgs (int uid, int iform) const
	Get the total number of required arguments. More...
int	numOfRequiredArgs (const CmdExtArg &arg) const
	Get the total number of required arguments of matched command. More...
int	numOfOptionalArgs (int uid, int iform) const
	Get the total number of optional arguments. More...
int	numOfOptionalArgs (const CmdExtArg &arg) const
	Get the total number of arguments of matched command. More...
const std::string &	getArgName (const CmdExtArg &arg) const
	Get the argument name. More...
CmdArgDef::ArgType	getArgDefType (const CmdExtArg &arg) const
	Get the argument type. More...
virtual ssize_t	tokenizeInput (const std::string &strInput, TokenVec &tokens)
	Lexically analyze input string to generate a series of tokens. More...
virtual ssize_t	tokenizeInput (const std::string &strInput, str::StringVec &tokens)
	Lexically analyze input string to generate a series of string tokens. More...
const std::string &	getName () const
	Get command line interface's name. More...
bool	hasCmd (const int uid) const
	Test if command exists. More...
bool	hasCmd (const std::string &strName) const
	Test if command exists. More...
const CmdDef &	at (const int uid) const
	Get the command definition with the unique id. More...
const CmdDef &	at (const std::string &strName) const
	Get command definition with the argv0 name. More...
const CmdDef &	operator[] (const int uid) const
	Index operator. More...
const CmdDef &	operator[] (const std::string &strName) const
	Index operator. More...
int	numOfCmds () const
	Get the total number of added commands. More...
CmdDefCIter	begin () const
	Return a constant iterator pointing to the first element of the list of command definitions. More...
CmdDefCIter	end () const
	Return a constant iterator referring to the past-the-end element of the list of command definitions. More...
const std::string &	getErrorStr () const
	Get the most recent error. More...
std::ostream &	backtrace (std::ostream &os, const bool bAll=false) const
	Insert trace and error log backtrace into output stream. More...

Static Public Member Functions
static std::string	c14n (const TokenVec &tokens)
	Canonicalization of a string. More...

Protected Member Functions
CmdDef &	cmdAt (const int uid)
	Get modifiable command definition with the given unique id. More...
CmdDef &	cmdAt (const std::string &strName)
	Get modifiable command definition with the given argv0 name. More...
virtual ssize_t	tokenizeSyntax (const std::string &strSyntax, TokenVec &tokens)
	Lexically analyze extened usage syntax string to generate a series of tokens. More...
virtual ssize_t	lexSyntaxWord (const std::string &strSyntax, ssize_t cursor, TokenVec &tokens)
	Syntax word lexical analyzer. More...
virtual ssize_t	lexSyntaxParenExpr (const std::string &strSyntax, ssize_t cursor, TokenVec &tokens)
	Syntax parenthetical expression lexical analyzer. More...
virtual ssize_t	lexWord (const std::string &strInput, ssize_t cursor, TokenVec &tokens)
	Word lexical analyzer. More...
virtual ssize_t	lexQuotedString (const std::string &strInput, ssize_t cursor, TokenVec &tokens)
	Quoted string lexical analyzer. More...
virtual void	logLexToken (const std::string &strSource, const size_t start, const ssize_t cursor, TokenVec &tokens, const bool bLoc=false)
	Log lexigraphical token. More...
void	pushToken (const std::string &strSource, const size_t start, const ssize_t cursor, TokenVec &tokens)
	Push token to the end of the generated tokens. More...
virtual int	compile (CmdDef &cmddef)
	Compile a command. More...
int	finalize ()
	Finalize command compilation. More...
virtual int	parseSyntax (CmdDef &cmddef, CmdFormDef &form, const TokenVec &tokens)
	Parse command syntax. More...
bool	parseArgv0 (CmdDef &cmddef, CmdFormDef &form, const TokenVec &tokens, size_t &pos)
	Parse argument 0 (command name) syntax. More...
bool	parseRequiredArgList (CmdDef &cmddef, CmdFormDef &form, const TokenVec &tokens, size_t &pos)
	Parse required argument list syntax. More...
bool	parseOptionalArgList (CmdDef &cmddef, CmdFormDef &form, const TokenVec &tokens, size_t &pos)
	Parse optional argument list syntax. More...
bool	parseArg (CmdDef &cmddef, CmdFormDef &form, const TokenVec &tokens, size_t &pos)
	Parse argument syntax. More...
bool	parseXorListArg (CmdDef &cmddef, CmdFormDef &form, const TokenVec &tokens, size_t &pos)
	Parse mutually exclusive argument values syntax. More...
bool	parseVariableArg (CmdDef &cmddef, CmdFormDef &form, const TokenVec &tokens, size_t &pos)
	Parse variable argument syntax. More...
bool	parseLiteralArg (CmdDef &cmddef, CmdFormDef &form, const TokenVec &tokens, size_t &pos)
	Parse literal, fixed-valued argument syntax. More...
bool	parseXorList (CmdDef &cmddef, CmdFormDef &form, const TokenVec &tokens, size_t &pos, str::StringVec &literals)
	Parse mutually exclusive list. More...
bool	parseIdentifier (CmdDef &cmddef, CmdFormDef &form, const TokenVec &tokens, size_t &pos, std::string &strIdent)
	Parse identifier. More...
bool	parseVarMod (CmdDef &cmddef, CmdFormDef &form, const TokenVec &tokens, size_t &pos, CmdArgDef::ArgType &eType, CmdArgDef::RangeVec &ranges, RegEx &re)
	Parse variable modifier. More...
bool	parseVarType (CmdDef &cmddef, CmdFormDef &form, const TokenVec &tokens, size_t &pos, CmdArgDef::ArgType &eType)
	Parse variable type. More...
bool	parseVarRangeExpr (CmdDef &cmddef, CmdFormDef &form, const TokenVec &tokens, size_t &pos, CmdArgDef::RangeVec &ranges)
	Parse variable range expression. More...
bool	parseVarRegExpr (CmdDef &cmddef, CmdFormDef &form, const TokenVec &tokens, size_t &pos, RegEx &re)
	Parse variable regular expression. More...
bool	parseLiteralValue (CmdDef &cmddef, CmdFormDef &form, const TokenVec &tokens, size_t &pos, std::string &strValue)
	Parse literal value. More...
bool	tokEq (const std::string strCmp, const TokenVec &tokens, size_t &pos)
	Test if token at position is equal to string. More...
bool	peekEq (const std::string strCmp, const Token &token) const
	Peek if token is equal to string. More...
bool	tokIdentifier (const TokenVec &tokens, size_t &pos)
	Test if string has valid identifier syntax. More...
int	processInput (const std::string &strLine, CmdExtArgVec &argv)
	Process a line of input. More...
int	match (const TokenVec &tokens, CmdExtArgVec &argv)
	Match the input tokens to the compiled commands to find the best fit. More...
int	matchCommand (const CmdDef &cmddef, const TokenVec &tokens, CmdExtArgVec &argv, double &fFitness)
	Match best command form against input line argument list. More...
int	matchCommandForm (const CmdFormDef &form, const TokenVec &tokens, CmdExtArgVec &argv, double &fFitness)
	Match command form against input line argument list. More...
int	checkReadResult ()
	Check read input result. More...
void	toVec (const CmdExtArgVec &v1, str::StringVec &v2)
	Convert extended argument vector to string argument vector. More...
virtual int	rlBuildReadLineGenerator ()
	Perform any necessary pre-processing to prepare for command line TAB completion. More...
virtual const std::string	rlGenerator (const std::string &strText, int nIndex, const std::string &strContext, int nStart, int nEnd, unsigned &uFlags)
	TAB completion generator. More...
void	rlArgDefs (const std::string &strSubtext, std::vector< CmdArgDef * > &argdefs)
	Build list of all command argument definitions that match completed subtext. More...
void	rlTabList (const std::string &strText, std::vector< CmdArgDef * > &argdefs, str::StringVec &tabList, unsigned &uFlags)
	Build TAB completion list and set appropriate readline modifiers. More...
bool	rlPartialMatch (const std::string &strText, const std::string strLiteral, const size_t uLen)
	Match partial text agains literal string. More...

Static Protected Member Functions
static const std::string	rlGeneratorWrapper (void *pAppArg, const std::string &strText, int nIndex, const std::string &strContext, int nStart, int nEnd, unsigned &uFlags)
	Static TAB completion generator wrapper. More...

Protected Attributes
std::string	m_strName
	name of this command line
bool	m_bIgnoreCase
	do [not] ignore case on commands
int	m_nUidCnt
	unique id counter
bool	m_bIsCompiled
	has [not] been successfully compiled
CmdDefMap	m_cmdDefs
	map of added command definitions
CmdExecMap	m_cmdExecs
	map of added command executions
PromptStack	m_prompts
	stack of prompt strings
ReadLine	m_readline
	readline interface
LogBook	m_log
	trace and error log
DataSectMap	m_dataSects
	data sections

Friends
std::ostream &	operator<< (std::ostream &os, const CommandLine &cl)
	Insert object into output stream. More...

Detailed Description

CommandLine class.

Definition at line 444 of file CommandLine.h.

Constructor & Destructor Documentation

CommandLine::CommandLine	(	const std::string	strName = "cl",
		const std::string	strPrompt = "> ",
		bool	bUseRlLib = true,
		bool	bIgnoreCase = false
	)

Default initialization constructor.

Parameters

strName	Name of command set and entry into readline's conditional parsing of the ~/.inputrc file.
strPrompt	Command line primary prompt string. Prompting occurs only in interactive mode.
bUseRlLib	Use the readline library. Note that readline must be available and in interactive mode. Otherwise a simple command-line interface will be used.
bIgnoreCase	Ignore case on comands and arguments.

Definition at line 383 of file CommandLine.cxx.

References addDataSection(), rnr::cmd::DataSectNsCore, rnr::cmd::DataSectCore::dealloc(), m_bIsCompiled, m_nUidCnt, and pushPrompt().

                                                   :
    m_strName(strName),
    m_bIgnoreCase(bIgnoreCase),
    m_readline(strName, strPrompt, bUseRlLib),
    m_log("Command Line Log", 50)
{
  m_nUidCnt     = 0;
  m_bIsCompiled = false;

  addDataSection(DataSectNsCore, new DataSectCore(), DataSectCore::dealloc);

  pushPrompt(strPrompt);
}

Member Function Documentation

int CommandLine::addCommand ( const CmdDesc &  desc )

virtual

Add a command to the command line interface.

The command syntax may specify multiple command forms, each separated by a newline '\n' character. The command named in each form must be the identical.

This is a light-weight function. A call to compile() is necessary to finalized command syntax processing.

Parameters

desc	Command description (see CmdDesc).
strSyntax	One or more extended usage syntax separated by newline characters.
fnExec	Command execution function of variant 1, 2, or 3.

Returns

On success, returns command's assigned unique id. Otherwise NoUid is returned.

Definition at line 414 of file CommandLine.cxx.

References rnr::eoe(), getErrorStr(), LOGERROR_STREAM, rnr::cmd::CmdDesc::longdesc, m_cmdDefs, m_log, rnr::cmd::NoUid, rnr::cmd::CmdDesc::synopsis, and rnr::cmd::CmdDesc::syntax.

Referenced by addCommand(), rnr::cmd::addons::execBtEnable(), rnr::cmd::addons::execQuit(), execTAdd(), loadCommands(), and rnr::cmd::addons::printCmdHelp().

{
  int uid;

  // command syntax must be defined
  if( desc.syntax.empty() )
  {
    m_log << "No syntax forms specified." << eoe;
    LOGERROR_STREAM(getErrorStr());
    return NoUid;
  }

  // add command
  if( (uid = addCommand(desc.syntax)) != NoUid )
  {
    m_cmdDefs[uid].addHelp(desc.synopsis, desc.longdesc);
  }

  return uid;
}

int CommandLine::addCommand ( const CmdDesc &  desc, CmdExec1Func  fnExec  )

virtual

Add a command to the command line interface.

The command syntax may specify multiple command forms, each separated by a newline '\n' character. The command named in each form must be the identical.

This is a light-weight function. A call to compile() is necessary to finalized command syntax processing.

Parameters

desc	Command description (see CmdDesc).
strSyntax	One or more extended usage syntax separated by newline characters.
fnExec	Command execution function of variant 1, 2, or 3.

Returns

On success, returns command's assigned unique id. Otherwise NoUid is returned.

Definition at line 435 of file CommandLine.cxx.

References addCommand(), m_cmdExecs, and rnr::cmd::NoUid.

{
  int uid;

  // add command
  if( (uid = addCommand(desc)) != NoUid )
  {
    m_cmdExecs[uid] = CmdExec(uid, fnExec);
  }

  return uid;
}

int CommandLine::addCommand ( const CmdDesc &  desc, CmdExec2Func  fnExec  )

virtual

Add a command to the command line interface.

The command syntax may specify multiple command forms, each separated by a newline '\n' character. The command named in each form must be the identical.

This is a light-weight function. A call to compile() is necessary to finalized command syntax processing.

Parameters

desc	Command description (see CmdDesc).
strSyntax	One or more extended usage syntax separated by newline characters.
fnExec	Command execution function of variant 1, 2, or 3.

Returns

On success, returns command's assigned unique id. Otherwise NoUid is returned.

Definition at line 448 of file CommandLine.cxx.

References addCommand(), m_cmdExecs, and rnr::cmd::NoUid.

{
  int uid;

  // add command
  if( (uid = addCommand(desc)) != NoUid )
  {
    m_cmdExecs[uid] = CmdExec(uid, fnExec);
  }

  return uid;
}

int CommandLine::addCommand ( const CmdDesc &  desc, CmdExec3Func  fnExec  )

virtual

Add a command to the command line interface.

The command syntax may specify multiple command forms, each separated by a newline '\n' character. The command named in each form must be the identical.

This is a light-weight function. A call to compile() is necessary to finalized command syntax processing.

Parameters

desc	Command description (see CmdDesc).
strSyntax	One or more extended usage syntax separated by newline characters.
fnExec	Command execution function of variant 1, 2, or 3.

Returns

On success, returns command's assigned unique id. Otherwise NoUid is returned.

Definition at line 461 of file CommandLine.cxx.

References addCommand(), cmdAt(), rnr::eoe(), getErrorStr(), rnr::cmd::CmdDef::getUid(), LOGERROR_STREAM, m_bIsCompiled, m_cmdDefs, m_cmdExecs, m_log, m_nUidCnt, rnr::cmd::CmdDef::m_strSyntax, rnr::cmd::NoUid, rnr::cmd::CmdDef::pushForm(), rnr::cmd::CmdDef::setUid(), and rnr::str::split().

{
  int uid;

  // add command
  if( (uid = addCommand(desc)) != NoUid )
  {
    m_cmdExecs[uid] = CmdExec(uid, fnExec);
  }

  return uid;
}

virtual int rnr::cmd::CommandLine::addCommand ( const std::string  strSyntax )

virtual

Add a command to the command line interface.

The command syntax may specify multiple command forms, each separated by a newline '\n' character. The command named in each form must be the identical.

This is a light-weight function. A call to compile() is necessary to finalized command syntax processing.

Parameters

desc	Command description (see CmdDesc).
strSyntax	One or more extended usage syntax separated by newline characters.
fnExec	Command execution function of variant 1, 2, or 3.

Returns

On success, returns command's assigned unique id. Otherwise NoUid is returned.

virtual int rnr::cmd::CommandLine::addCommand ( const std::string  strSyntax, CmdExec1Func  fnExec  )

virtual

Add a command to the command line interface.

The command syntax may specify multiple command forms, each separated by a newline '\n' character. The command named in each form must be the identical.

This is a light-weight function. A call to compile() is necessary to finalized command syntax processing.

Parameters

desc	Command description (see CmdDesc).
strSyntax	One or more extended usage syntax separated by newline characters.
fnExec	Command execution function of variant 1, 2, or 3.

Returns

On success, returns command's assigned unique id. Otherwise NoUid is returned.

virtual int rnr::cmd::CommandLine::addCommand ( const std::string  strSyntax, CmdExec2Func  fnExec  )

virtual

Add a command to the command line interface.

The command syntax may specify multiple command forms, each separated by a newline '\n' character. The command named in each form must be the identical.

This is a light-weight function. A call to compile() is necessary to finalized command syntax processing.

Parameters

desc	Command description (see CmdDesc).
strSyntax	One or more extended usage syntax separated by newline characters.
fnExec	Command execution function of variant 1, 2, or 3.

Returns

On success, returns command's assigned unique id. Otherwise NoUid is returned.

virtual int rnr::cmd::CommandLine::addCommand ( const std::string  strSyntax, CmdExec3Func  fnExec  )

virtual

Add a command to the command line interface.

The command syntax may specify multiple command forms, each separated by a newline '\n' character. The command named in each form must be the identical.

This is a light-weight function. A call to compile() is necessary to finalized command syntax processing.

Parameters

desc	Command description (see CmdDesc).
strSyntax	One or more extended usage syntax separated by newline characters.
fnExec	Command execution function of variant 1, 2, or 3.

Returns

On success, returns command's assigned unique id. Otherwise NoUid is returned.

int CommandLine::addDataSection	(	const std::string &	ns,
		void *	pData,
		DataSect::DeallocFunc	fn = NULL
	)

Add a data section to the command-line interface.

When the section is removed or the interface is deleted, the section data is automatically deleted if a deallocation function is specified. Otherwise, the user has responsibility to delete any data.

Parameters

ns	Namespace of data section.
pData	Pointer to data.
fn	Deallocator function.

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 790 of file CommandLine.cxx.

References rnr::cmd::AOk, rnr::cmd::EBadVal, LOGERROR_STREAM, and m_dataSects.

Referenced by CommandLine().

{
  DataSectIter pos = m_dataSects.find(ns);

  if( pos == m_dataSects.end() )
  {
    m_dataSects[ns] = DataSect();       // avoid double deletes 
    m_dataSects[ns].set(ns, pData, fn); // now assign
    return AOk;
  }
  else
  {
    LOGERROR_STREAM("Data section '" << ns << "' already exist - cannot add.");
    return EBadVal;
  }
}

void CommandLine::addToHistory ( const str::StringVec &  argv )

virtual

Add command to history.

Simple string argument version.

Note

Only available if readline is available and enabled, and input is interactive.

Parameters

argv	Command in argv vector.

Definition at line 1039 of file CommandLine.cxx.

References rnr::str::c14n(), and m_readline.

Referenced by run().

{
  m_readline.addToHistory(str::c14n(argv));
}

void CommandLine::addToHistory ( const CmdExtArgVec &  argv )

virtual

Add command to history.

Extended argument version.

Note

Only available if readline is available and enabled, and input is interactive.

Parameters

argv	Command in argv vector.

Definition at line 1044 of file CommandLine.cxx.

References rnr::str::c14n(), m_readline, and toVec().

{
  StringVec v;

  toVec(argv, v);
  m_readline.addToHistory(str::c14n(v));
}

const CmdDef & CommandLine::at

(

const int

uid

)

const

Get the command definition with the unique id.

Parameters

uid	Command unique id.

Returns

Command definition reference.

Definition at line 1889 of file CommandLine.cxx.

References m_cmdDefs, and rnr::cmd::nocmddef.

Referenced by checkCmd(), rnr::cmd::addons::execHelp(), execTDump(), execTRemove(), getArgDefType(), getArgName(), hasCmd(), numOfArgs(), numOfOptionalArgs(), and numOfRequiredArgs().

{
  CmdDefCIter pos;

  if( (pos = m_cmdDefs.find(uid)) != m_cmdDefs.end() )
  {
    return pos->second;
  }
  else
  {
    return nocmddef;
  }
}

const CmdDef& rnr::cmd::CommandLine::at

(

const std::string &

strName

)

const

Get command definition with the argv0 name.

Parameters

strName

Command name.

Returns

Command definition reference.

ostream & CommandLine::backtrace	(	std::ostream &	os,
		const bool	bAll = false
	)		const

Insert trace and error log backtrace into output stream.

Parameters

os	Output stream.
bAll	If true, backtrace all of log. Otherwise backtrace to last major execution mark.

Returns

Reference to output stream.

Definition at line 1952 of file CommandLine.cxx.

References rnr::cmd::isdquote(), lexQuotedString(), lexWord(), m_log, rnr::LogBook::NEWEST, rnr::LogBook::printLog(), rnr::LogBook::printToMark(), and tokenizeInput().

Referenced by execTBt(), loadCommands(), and readCommand().

{
  if( bAll )
  {
    return m_log.printLog(os);
  }
  else
  {
    return m_log.printToMark(os, markExec, LogBook::NEWEST);
  }
}

CmdDefCIter rnr::cmd::CommandLine::begin ( ) const

inline

Return a constant iterator pointing to the first element of the list of command definitions.

Returns

Constant Iterator.

Definition at line 1119 of file CommandLine.h.

Referenced by rnr::cmd::addons::execHelp().

      {
        return m_cmdDefs.begin();
      }

string CommandLine::c14n ( const TokenVec &  tokens )

static

Canonicalization of a string.

Note

The name c14n is an cute abbreviation where 14 represents the number of letters between the 'c' and 'n' in the word "canonicalization".

Parameters

tokens

Tokens to canonicalize.

Returns

Return string holding canonical form.

Definition at line 3174 of file CommandLine.cxx.

References rnr::io::deltaindent(), getPrompt(), rnr::cmd::ReadLine::haveRlLib(), rnr::io::indent(), m_bIgnoreCase, m_cmdDefs, m_cmdExecs, m_dataSects, m_readline, m_strName, numOfCmds(), operator<<(), rnr::str::prettify(), rnr::io::setindent(), and rnr::cmd::ReadLine::useRlLib().

Referenced by match().

{
  stringstream  ss;
  string        sep;

  for(size_t i = 0; i < tokens.size(); ++i)
  {
    ss << sep << prettify(tokens[i].value());

    if( i == 0 )
    {
      sep = " ";
    }
  }

  return ss.str();
}

int CommandLine::checkReadResult ( )

protected

Check read input result.

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 1506 of file CommandLine.cxx.

References rnr::cmd::AOk, rnr::cmd::EEoF, rnr::eoe(), rnr::cmd::ERead, rnr::cmd::ReadLine::getErrorStr(), rnr::cmd::ReadLine::isEoF(), rnr::cmd::ReadLine::isFError(), m_log, and m_readline.

Referenced by processInput().

{
  // EOF
  if( m_readline.isEoF() )
  {
    m_log << "EOF" << eoe;
    return EEoF;
  }

  // file read error
  else if( m_readline.isFError() )
  {
    m_log << m_readline.getErrorStr() << eoe;
    return ERead;
  }

  // read successful
  else
  {
    return AOk;
  }
}

CmdDef & CommandLine::cmdAt ( const int  uid )

protected

Get modifiable command definition with the given unique id.

Protected version of at().

Parameters

uid	Command unique id.

Returns

Command definition reference.

Definition at line 1918 of file CommandLine.cxx.

References m_cmdDefs, and rnr::cmd::nocmddef.

Referenced by addCommand(), execute(), match(), and removeCommand().

{
  CmdDefIter  pos;

  if( (pos = m_cmdDefs.find(uid)) != m_cmdDefs.end() )
  {
    return pos->second;
  }
  else
  {
    return nocmddef;
  }
}

CmdDef& rnr::cmd::CommandLine::cmdAt ( const std::string &  strName )

protected

Get modifiable command definition with the given argv0 name.

Protected version of at().

Parameters

strName

Command name.

Returns

Command definition reference.

int CommandLine::compile ( )

virtual

Compile all added commands.

Compiling essentially parses the command extended usage syntax and sets the internal data for:

• readline tab completion
• input to command pattern matching
• first-level command validation

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 627 of file CommandLine.cxx.

References rnr::cmd::AOk, rnr::bookmark(), rnr::LogBook::clear(), rnr::cmd::EError, rnr::eoe(), finalize(), getErrorStr(), LOGERROR_STREAM, m_bIsCompiled, m_cmdDefs, m_log, m_nUidCnt, m_readline, numOfCmds(), rnr::cmd::ReadLine::registerAltGenerator(), rlBuildReadLineGenerator(), and rlGeneratorWrapper().

Referenced by execTAdd(), execTCompile(), and loadCommands().

{
  CmdDefIter  iter;
  int         rc = AOk;

  CL_DBG_CALL_IN("", endl);

  m_bIsCompiled = false;

  m_log.clear();
  m_log << bookmark(markExec) << labelExec << __func__ << eoe;

  //
  // No commands added.
  //
  if( m_nUidCnt == 0 )
  {
    m_log << labelFail << "No commands added." << eoe;
    LOGERROR_STREAM(getErrorStr());
    rc = EError;
  }

  //
  // Compile each command.
  //
  for(iter = m_cmdDefs.begin();
      (rc == AOk) && (iter != m_cmdDefs.end());
      ++iter)
  {
    CmdDef &cmddef = iter->second;

    if( !cmddef.isDefined() )
    {
      rc = compile(cmddef);
    }
  }

  //
  // Finalize compilation.
  //
  if( rc == AOk )
  {
    rc = finalize();
  }

  //
  // Build readline generator.
  //
  if( rc == AOk )
  {
    rc = rlBuildReadLineGenerator();
  }

  //
  // All good.
  //
  if( rc == AOk )
  {
    // register readline generator callback
    m_readline.registerAltGenerator(rlGeneratorWrapper, this);

    m_bIsCompiled = true;

    m_log.clear();
    m_log << bookmark(markExec) << labelExec << __func__ << eoe;
    m_log << labelCompile << "Compiled " << numOfCmds() << " commands." << eoe;
    m_log << labelExec << "Ok" << eoe;
  }

  CL_DBG_CALL_OUT_NL("rc=" << rc);

  return rc;
}

int CommandLine::compile ( CmdDef &  cmddef )

protectedvirtual

Compile a command.

See also

CommandLine::compile()

Parameters

cmddef

Command definition.

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 701 of file CommandLine.cxx.

References rnr::cmd::AOk, rnr::bookmark(), rnr::LogBook::clear(), rnr::cmd::EBadSyntax, rnr::eoe(), rnr::cmd::CmdDef::formAt(), getErrorStr(), rnr::cmd::CmdFormDef::getIndex(), rnr::cmd::CmdDef::getName(), rnr::cmd::CmdFormDef::getSyntax(), rnr::cmd::CmdDef::getUid(), LOGERROR_STREAM, m_log, rnr::cmd::CmdDef::m_nUid, rnr::cmd::CmdDef::numOfForms(), parseSyntax(), rnr::cmd::CmdDef::reset(), and tokenizeSyntax().

{
  TokenVec    tokens;
  ssize_t     tokcnt;
  int         i;
  int         rc;

  CL_DBG_CALL_IN("cmddef.uid=" << cmddef.getUid(), " ***" << endl);

  m_log.clear();
  m_log << bookmark(markExec) << labelExec << __func__ << eoe;
  m_log << labelCompile << "cmddef " << cmddef.getUid()
        << ": " << cmddef.getName() << eoe;

  // reset command definition to pre-compiled state
  cmddef.reset();

  for(i = 0, rc = AOk; (i < cmddef.numOfForms()) && (rc == AOk); ++i)
  {
    CmdFormDef &form = cmddef.formAt(i);

    if( (tokcnt = tokenizeSyntax(form.getSyntax(), tokens)) < 0 )
    {
      rc = tokcnt;
    }

    else if( tokcnt == 0 )
    {
      m_log << labelFail
            << "cmddef " << cmddef.m_nUid << ", "
            << "form " << form.getIndex() << ": No syntax specified." << eoe;
      LOGERROR_STREAM(getErrorStr());
      rc = EBadSyntax;
    }

    else
    {
      rc = parseSyntax(cmddef, form, tokens);
    }
  }

  if( rc == AOk )
  {
    m_log << labelExec << "Ok" << eoe;
  }
  else
  {
    m_log << labelFail << "Could not compile." << eoe;
  }

  CL_DBG_CALL_OUT_NL("rc=" << rc);
  CL_DBG(endl);

  return rc;
}

CmdDefCIter rnr::cmd::CommandLine::end ( ) const

inline

Return a constant iterator referring to the past-the-end element of the list of command definitions.

Returns

Constant Iterator.

Definition at line 1130 of file CommandLine.h.

References rnr::str::c14n(), and rnr::cmd::CmdExec::operator<<.

Referenced by rnr::cmd::addons::execHelp().

      {
        return m_cmdDefs.end();
      }

int CommandLine::execute ( const str::StringVec &  argv )

virtual

Execute a comamnd with the given arguments.

Parameters

argv	The list of string arguments.

Returns

Returns a Command Error Codes on failure to find the associated command or its execution function. Otherwise, returns the user-define execution function return value.

Definition at line 984 of file CommandLine.cxx.

References cmdAt(), rnr::cmd::EBadSyntax, rnr::cmd::EUnknownCmd, rnr::cmd::CmdDef::getUid(), m_cmdExecs, and rnr::cmd::NoUid.

Referenced by run().

{
  int         uid;
  CmdExecIter pos;

  // no command nor arguments
  if( argv.size() == 0 )
  {
    return EBadSyntax;
  }

  // find the added command by name (the first argument)
  CmdDef &cmd = cmdAt(argv[0]);

  // get the command's unique id
  uid = cmd.getUid();

  // no command added with this uid
  if( uid == NoUid )
  {
    return EUnknownCmd;
  }

  // find the uid associated command execution function
  if( (pos = m_cmdExecs.find(uid)) == m_cmdExecs.end() )
  {
    // no execution function
    return EUnknownCmd;
  }

  // execute
  return pos->second.execute(argv);
}

int CommandLine::execute ( const CmdExtArgVec &  argv )

virtual

Execute a comamnd with the given arguments.

Parameters

argv	The list of extended arguments.

Returns

Returns a Command Error Codes on failure to find the associated command or its execution function. Otherwise, returns the user-define execution function return value.

Definition at line 1018 of file CommandLine.cxx.

References rnr::cmd::EBadSyntax, rnr::cmd::EUnknownCmd, and m_cmdExecs.

{
  CmdExecIter pos;

  // no command nor arguments
  if( argv.size() == 0 )
  {
    return EBadSyntax;
  }

  // find the uid associated command execution function
  if( (pos = m_cmdExecs.find(argv[0].uid())) == m_cmdExecs.end() )
  {
    // no execution function
    return EUnknownCmd;
  }

  // execute
  return pos->second.execute(*this, argv);
}

int CommandLine::finalize ( )

protected

Finalize command compilation.

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 757 of file CommandLine.cxx.

References rnr::cmd::AOk, rnr::cmd::EAmbigCmd, rnr::eoe(), getErrorStr(), rnr::cmd::CmdDef::getName(), rnr::cmd::CmdDef::getUid(), LOGERROR_STREAM, m_cmdDefs, and m_log.

Referenced by compile().

{
  CmdDefIter  iter, jter; // command definition iterators

  for(iter = m_cmdDefs.begin(); iter != m_cmdDefs.end(); ++iter)
  {
    CmdDef &cmddef_i = iter->second;
    
    jter = iter;

    for(++jter; jter != m_cmdDefs.end(); ++jter)
    {
      CmdDef &cmddef_j = jter->second;

      if( cmddef_i.getName() == cmddef_j.getName() )
      {
        m_log << labelSyntax << "Duplicate command names found at uid's "
              << cmddef_i.getUid() << " and " << cmddef_j.getUid() << "."
              << eoe;
        LOGERROR_STREAM(getErrorStr());
        return EAmbigCmd;
      }
    }
  }

  return AOk;
}

CmdArgDef::ArgType CommandLine::getArgDefType

(

const CmdExtArg &

arg

)

const

Get the argument type.

The extended argument contains matched command context.

Note

Argument type differs from argument converted type. The former specifies the argument syntax, while the later specifies converted basic type such as string, int, etc.

Parameters

arg	Extended argument.

Returns

Returns argument type.

Definition at line 1580 of file CommandLine.cxx.

References rnr::cmd::CmdExtArg::argIndex(), at(), rnr::cmd::CmdExtArg::formIndex(), rnr::cmd::CmdArgDef::getType(), and rnr::cmd::CmdExtArg::uid().

{
  const CmdArgDef &argdef= at(arg.uid()).at(arg.formIndex()).at(arg.argIndex());

  return argdef.getType();
}

const string & CommandLine::getArgName

(

const CmdExtArg &

arg

)

const

Get the argument name.

The extended argument contains matched command context.

Parameters

arg	Extended argument.

Returns

Returns argument name on success, empty string on failure.

Definition at line 1572 of file CommandLine.cxx.

References rnr::cmd::CmdExtArg::argIndex(), at(), rnr::cmd::CmdExtArg::formIndex(), rnr::cmd::CmdArgDef::getName(), and rnr::cmd::CmdExtArg::uid().

{
  // all terrain armored transport, of course
  const CmdArgDef &argdef= at(arg.uid()).at(arg.formIndex()).at(arg.argIndex());

  return argdef.getName();
}

bool rnr::cmd::CommandLine::getBtEnable ( ) const

inline

Test if backtracing is enabled.

Returns

Returns true or false.

Definition at line 499 of file CommandLine.h.

References rnr::cmd::DataSectNsCore.

Referenced by readCommand().

      {
        return
          ((DataSectCore*)m_dataSects.at(DataSectNsCore).data())->m_bBacktrace;
      }

void * CommandLine::getDataSection

(

const std::string &

ns

)

Get the section data under the specified namespace.

Parameters

ns	Namespace of data section to retrieve.

Returns

Returns pointer to the data if it exist. NULL is returned if no namespace is found, or no data has been specified.

Definition at line 830 of file CommandLine.cxx.

References m_dataSects.

{
  DataSectIter pos = m_dataSects.find(ns);

  return pos != m_dataSects.end()? pos->second.data(): NULL;
}

const string & CommandLine::getErrorStr

(

)

const

Get the most recent error.

Returns

Error string.

Definition at line 1947 of file CommandLine.cxx.

References rnr::LogBook::lastText(), and m_log.

Referenced by addCommand(), compile(), execTAdd(), execTCompile(), execTPrint(), execTRemove(), finalize(), lexSyntaxParenExpr(), lexSyntaxWord(), parseArg(), parseArgv0(), parseIdentifier(), parseLiteralValue(), parseSyntax(), parseVarMod(), parseVarRangeExpr(), parseVarRegExpr(), parseVarType(), parseXorList(), readCommand(), removeCommand(), tokEq(), and tokIdentifier().

{
  return m_log.lastText();
}

size_t rnr::cmd::CommandLine::getLineNum ( ) const

inline

Get the line number of the last read line.

Returns

Line number.

Definition at line 853 of file CommandLine.h.

Referenced by pushToken(), and readCommand().

      {
        return m_readline.getLineNum();
      }

const std::string& rnr::cmd::CommandLine::getName ( ) const

inline

Get command line interface's name.

Returns

Name string.

Definition at line 1040 of file CommandLine.h.

Referenced by execTPrint(), and readCommand().

      {
        return m_strName;
      }

const string & CommandLine::getPrompt

(

)

const

Get the current prompt string.

Returns

String.

Definition at line 1071 of file CommandLine.cxx.

References m_prompts, and rnr::cmd::noprompt.

Referenced by c14n(), execTPrint(), and popPrompt().

{
  if( !m_prompts.empty() )
  {
    return m_prompts.back();
  }
  else
  {
    return noprompt;
  }
}

bool CommandLine::hasCmd

(

const int

uid

)

const

Test if command exists.

Parameters

uid	Command unique id.

Returns

Returns true or false.

Definition at line 1879 of file CommandLine.cxx.

References at(), and m_cmdDefs.

Referenced by execTAdd().

{
  return m_cmdDefs.find(uid) != m_cmdDefs.end();
}

bool rnr::cmd::CommandLine::hasCmd

(

const std::string &

strName

)

const

Test if command exists.

Parameters

strName

Command name.

Returns

Returns true or false.

bool CommandLine::isReservedDataSection

(

const std::string &

ns

)

const

Test if the namespace is a command-line interface reserved name.

Parameters

ns	Namespace.

Returns

Returns true or false.

Definition at line 837 of file CommandLine.cxx.

References rnr::cmd::DataSectNsCore, rnr::cmd::DataSectNsNet, and rnr::cmd::DataSectNsOS.

Referenced by removeDataSection().

{
  return  (ns == DataSectNsCore) || (ns == DataSectNsOS) ||
          (ns == DataSectNsNet);
}

ssize_t CommandLine::lexQuotedString ( const std::string &  strInput, ssize_t  cursor, TokenVec &  tokens  )

protectedvirtual

Quoted string lexical analyzer.

The unescaped double quotes are not included in the token. Escape sequences interpreted.

On success, the generated <interp-char-seq> token is placed at the end of the vector.

Syntax:

<quoted-string> ::= '"' <interp-char-seq> '"'

<interp-char-seq> ::= <interp-char>
                    | <interp-char-seq> <interp-char>

<interp-char> ::= NON_BACKSLASH_CHAR
               |  <interp-esc-char>

<interp-esc-char> ::= '\' CHAR
                    | '\' 'x' HEXDIGIT
                    | '\' 'x' HEXDIGIT HEXDIGIT

Parameters

[in]	strInput	Input string to analyze.
[in]	cursor	Character position along input string.
[in,out]	tokens	Vector of generated tokens.

Returns

On success, returns new cursor position. Otherwise a negative error code is returned.

Definition at line 2256 of file CommandLine.cxx.

References rnr::cmd::EBadSyntax, rnr::eoe(), rnr::cmd::isdquote(), logLexToken(), m_log, pushToken(), and rnr::cmd::tohex().

Referenced by backtrace().

{
  size_t    len;      // length of input string;
  size_t    start;    // start character position of token in input string
  bool      escseq;   // is [not] in an escape sequence
  bool      eos;      // is [not] at end of string
  char      c;        // working converted character
  string    value;    // working token value

  len   = strInput.length();

  if( isdquote(strInput[cursor]) )
  {
    ++cursor;
    start = cursor;
  }
  else
  {
    logLexToken(strInput, cursor, cursor, tokens);
    m_log << labelSyntax << "No starting double qoute '\"' found." << eoe;
    return EBadSyntax;
  }

  escseq  = false;
  eos     = false;

  while( (cursor >= 0) && (cursor < len) && !eos )
  {
    // escape sequence
    if( escseq )
    {
      switch( strInput[cursor] )
      {
        case 't':   // tab
          c = '\t';
          break;
        case 'n':   // newline
          c = '\n';
          break;
        case 'r':   // carriage return
          c = '\r';
          break;
        case 'v':   // vertical tab
          c = '\v';
          break;
        case 'f':   // formfeed
          c = '\f';
          break;
        case 'x':   // h[h]
          {
            int i = cursor + 1;
            if( (i < len) && isxdigit(strInput[i]) )
            {
              c = tohex(strInput[i]);
              ++cursor;
              ++i;
              if( (i < len) && isxdigit(strInput[i]) )
              {
                c <<= 4;
                c |= tohex(strInput[i]);
                ++cursor;
              }
            }
            else
            {
              c = 'x';
            }
          }
          break;
        default:
          c = strInput[cursor];
          break;
      }

      value.push_back(c);
      escseq = false;
      ++cursor;
    }

    else
    {
      switch( strInput[cursor] )
      {
        case '\\':
          escseq = true;
          break;
        case '"':
          eos = true;
          break;
        default:
          value.push_back(strInput[cursor++]);
          break;
      }
    }
  }

  if( isdquote(strInput[cursor]) )
  {
    pushToken(strInput, start, cursor, tokens);

    ++cursor;   // get past quote

    return cursor;
  }
  else
  {
    logLexToken(strInput, start, cursor, tokens);
    m_log << labelSyntax << "No ending double qoute '\"' found." << eoe;
    return EBadSyntax;
  }
}

ssize_t CommandLine::lexSyntaxParenExpr ( const std::string &  strSyntax, ssize_t  cursor, TokenVec &  tokens  )

protectedvirtual

Syntax parenthetical expression lexical analyzer.

A syntax parenthetical expression isdefined as any contiguous sequence block of character delineated by a balanced pair of parentheses. A backslash escaped parenthesis does to factor into the paentheses countiog.

On success,the generated tokens '(', <paren-tok>, and ')' are placed at the end of the vector.

Syntax:

<paren-expr-def> ::= '(' <paren-tok> ')'

Parameters

[in]	strSyntax	Syntax string to analyze.
[in]	cursor	Character position along syntax string.
[in,out]	tokens	Vector of generated tokens.

Returns

On success, returns new cursor position. Otherwise a negative error code is returned.

Definition at line 2137 of file CommandLine.cxx.

References rnr::cmd::EBadSyntax, rnr::eoe(), getErrorStr(), rnr::cmd::iscparen(), rnr::cmd::isoparen(), LOGERROR_STREAM, logLexToken(), m_log, and pushToken().

Referenced by tokenizeSyntax().

{
  size_t    len;      // length of input string;
  size_t    start;    // start character position of token in input string
  int       pdepth;   // parenthesis depth
  bool      escseq;   // is [not] in an escape sequence
  bool      eop;      // is [not] at end of parenthetical
  char      c;        // working character
  string    value;    // working token value

  len     = strSyntax.length();
  start   = cursor;
  pdepth  = 0;
  escseq  = false;
  eop     = false;

  if( isoparen(strSyntax[cursor]) )
  {
    // '(' token
    start = cursor++;
    pushToken(strSyntax, start, cursor, tokens);

    start = cursor;
    ++pdepth;
  }
  else
  {
    logLexToken(strSyntax, start, cursor, tokens);
    m_log << labelSyntax << "No starting '(' found." << eoe;
    LOGERROR_STREAM(getErrorStr());
    return EBadSyntax;
  }

  while( (cursor >= 0) && (cursor < len) && !eop )
  {
    switch( strSyntax[cursor] )
    {
      case '\\':
        escseq = true;
        break;
      case '(':
        if( !escseq )
        {
          ++pdepth;
        }
        escseq = false;
        break;
      case ')':
        if( !escseq )
        {
          if( --pdepth == 0 )
          {
            eop = true;
          }
        }
        escseq = false;
        break;
      default:
        escseq = false;
        break;
    }

    if( !eop )
    {
      value.push_back(strSyntax[cursor++]);
    }
  }

  if( iscparen(strSyntax[cursor]) )
  {
    // expression token
    pushToken(strSyntax, start, cursor, tokens);

    // ')' token
    start = cursor++;
    pushToken(strSyntax, start, cursor, tokens);

    return cursor;
  }
  else
  {
    logLexToken(strSyntax, start, cursor, tokens);
    m_log << labelSyntax << "No ending ')' found." << eoe;
    LOGERROR_STREAM(getErrorStr());
    return EBadSyntax;
  }
}

ssize_t CommandLine::lexSyntaxWord ( const std::string &  strSyntax, ssize_t  cursor, TokenVec &  tokens  )

protectedvirtual

Syntax word lexical analyzer.

A syntax word is defined as any contiguous sequence of non-whitespace, non-syntax-special symbol characters.

On success, the generated <word> token is placed at the end of the vector.

Parameters

[in]	strSyntax	Syntax string to analyze.
[in]	cursor	Character position along syntax string.
[in,out]	tokens	Vector of generated tokens.

Returns

On success, returns new cursor position. Otherwise a negative error code is returned.

Definition at line 2104 of file CommandLine.cxx.

References rnr::cmd::EBadSyntax, rnr::eoe(), getErrorStr(), rnr::cmd::isspecial(), LOGERROR_STREAM, logLexToken(), m_log, and pushToken().

Referenced by tokenizeSyntax().

{
  size_t    len;
  size_t    start;

  len   = strSyntax.length();
  start = cursor;

  // find end of word
  while( (cursor < len) &&
         !isspace((int)strSyntax[cursor]) &&
         !isspecial(strSyntax[cursor]) )
  {
    ++cursor;
  }

  if( cursor > start )
  {
    pushToken(strSyntax, start, cursor, tokens);
  }
  else
  {
    logLexToken(strSyntax, start, cursor, tokens);
    m_log << labelSyntax << "No <word> found." << eoe;
    LOGERROR_STREAM(getErrorStr());
    cursor = EBadSyntax;
  }

  return cursor;
}

ssize_t CommandLine::lexWord ( const std::string &  strInput, ssize_t  cursor, TokenVec &  tokens  )

protectedvirtual

Word lexical analyzer.

A word is defined as any contiguous sequence of non-whitespace characters.

On success, the generated <word> token is placed at the end of the vector.

Parameters

[in]	strInput	Input string to analyze.
[in]	cursor	Character position along input string.
[in,out]	tokens	Vector of generated tokens.

Returns

On success, returns new cursor position. Otherwise a negative error code is returned.

Definition at line 2227 of file CommandLine.cxx.

References rnr::cmd::EBadSyntax, rnr::eoe(), logLexToken(), m_log, and pushToken().

Referenced by backtrace().

{
  size_t    len;
  size_t    start;

  len   = strInput.length();
  start = cursor;

  while( (cursor < len) && !isspace((int)strInput[cursor]) )
  {
    ++cursor;
  }

  if( cursor > start )
  {
    pushToken(strInput, start, cursor, tokens);
  }
  else
  {
    logLexToken(strInput, start, cursor, tokens);
    m_log << labelSyntax << "No <word> found." << eoe;
    cursor = EBadSyntax;
  }

  return cursor;
}

void CommandLine::logLexToken ( const std::string &  strSource, const size_t  start, const ssize_t  cursor, TokenVec &  tokens, const bool  bLoc = false  )

protectedvirtual

Log lexigraphical token.

Parameters

	strSource	Source string of tokens.
	start	Start token character position in source.
	cursor	Cursor position in source.
[in,out]	tokens	Vector of lexical tokens.
	bLoc	If true, then include line number and token characater positions.

Definition at line 2370 of file CommandLine.cxx.

References rnr::eoe(), m_log, and pushToken().

Referenced by lexQuotedString(), lexSyntaxParenExpr(), lexSyntaxWord(), and lexWord().

{
  stringstream ss;

  pushToken(strSource, start, cursor, tokens);
  tokens.back().printAnnotated(ss, strSource);
  m_log << labelAt << ss.str() << eoe;
}

int CommandLine::match ( const TokenVec &  tokens, CmdExtArgVec &  argv  )

protected

Match the input tokens to the compiled commands to find the best fit.

Parameters

[in]	tokens	Vector of input tokens.
[out]	argv	Vector of extended arguments, with argv[0] being the command name argument.

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 1128 of file CommandLine.cxx.

References rnr::cmd::AOk, c14n(), cmdAt(), rnr::cmd::EAmbigCmd, rnr::cmd::EArgv0, rnr::cmd::EError, rnr::eoe(), rnr::cmd::EUnknownCmd, rnr::cmd::CmdDef::formAt(), rnr::cmd::CmdFormDef::getSyntax(), m_cmdDefs, m_log, matchCommand(), rnr::cmd::NoIndex, and rnr::cmd::NoUid.

Referenced by processInput().

{
  CmdDefIter    iter;           // command definition iterator

  double        fUltFitness;    // best fitness value
  int           uidUlt;         // best command unique id
  int           iformUlt;       // best form index

  double        fPenultFitness; // second best fitness value
  int           uid2nd;         // seconds best command unique id
  int           iform2nd;       // second best form index

  CmdExtArgVec  argvCmd;        // working command extended arguments
  double        fFitness;       // working fitness
  int           cnt;            // count of commands matching argv0
  int           rc;             // return code

  // This is considered a bug. 
  if( tokens.size() == 0 )
  {
    LOGERROR("Bug: No tokens.");
    return EError;
  }

  argvCmd.clear();

  fPenultFitness  = fUltFitness = 0.0;
  uid2nd          = uidUlt      = NoUid;
  iform2nd        = iformUlt    = NoIndex;

  cnt = 0;

  //
  // Find the best and second best command fits.
  //
  for(iter = m_cmdDefs.begin(); iter != m_cmdDefs.end(); ++iter)
  {
    rc = matchCommand(iter->second, tokens, argvCmd, fFitness);

    switch( rc )
    {
      case AOk:      // complete match
        ++cnt;
        break;
      case EArgv0:  // argv0 not matched
        break;
      default:      // argv0 matched, but args failed to match 
        ++cnt;
        continue;
    }

    // Found a new best.
    if( fFitness > fUltFitness )
    {
      fPenultFitness  = fUltFitness;
      uid2nd          = uidUlt;
      iform2nd        = iformUlt;

      argv        = argvCmd;
      fUltFitness = fFitness;
      uidUlt      = iter->second.getUid();
      iformUlt    = argv[0].formIndex();
    }

    // Found a new second best, but not a new best.
    else if( fFitness > fPenultFitness )
    {
      fPenultFitness  = fFitness;
      uid2nd          = iter->second.getUid();
      iform2nd        = argvCmd[0].formIndex();
    }
  }

  //
  // No interface match.
  //
  if( uidUlt == NoUid )
  {
    if( cnt > 0 )
    {
      m_log << labelNoMatch << c14n(tokens) << eoe;
    }
    else
    {
      m_log << labelSyntax << "Command " << tokens[0] << " not found." << eoe;
    }
    rc = EUnknownCmd;
  }

  //
  // Duplicate fitness.
  //
  else if( fUltFitness == fPenultFitness )
  {
    m_log << labelNoMatch
          << "Command '" << tokens[0] << "' ambiguous. Matches:"
          << eoe;
    m_log << labelBlank << cmdAt(uidUlt).formAt(iformUlt).getSyntax() << eoe;
    m_log << labelBlank << cmdAt(uid2nd).formAt(iform2nd).getSyntax() << eoe;
    rc = EAmbigCmd;
  }

  //
  // Got a unambiguous, matched command.
  //
  else
  {
    m_log << labelSelect << cmdAt(uidUlt).formAt(iformUlt).getSyntax() << eoe;
    rc = AOk;
  }

  return rc;
}

int CommandLine::matchCommand ( const CmdDef &  cmddef, const TokenVec &  tokens, CmdExtArgVec &  argv, double &  fFitness  )

protected

Match best command form against input line argument list.

Parameters

[in]	cmddef	Compiled command definition.
[in]	tokens	Vector of arguments.
[out]	argv	Vector of extended arguments, with argv[0] being the command name argument.
[out]	fFitness	Fitness of match [0.0 - 1.0].

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 1242 of file CommandLine.cxx.

References rnr::cmd::AOk, rnr::cmd::CmdFormDef::at(), rnr::cmd::CmdDef::at(), rnr::cmd::EArgv0, rnr::cmd::EBadSyntax, rnr::cmd::EError, rnr::eoe(), rnr::cmd::CmdDef::getName(), rnr::cmd::CmdFormDef::getSyntax(), m_log, rnr::cmd::CmdArgDef::match(), matchCommandForm(), rnr::cmd::NoIndex, and rnr::cmd::CmdDef::numOfForms().

Referenced by match().

{
  CmdExtArgVec  argvForm;     // working form extended arguments
  double        fMaxFitness;  // working and best form fitness
  int           iBest;        // best form index
  int           i;            // working index
  int           rc;           // return code

  // This is considered a bug. 
  if( tokens.size() == 0 )
  {
    LOGERROR("Bug: No tokens.");
    return EError;
  }

  argv.clear();

  fFitness    = 0.0;
  fMaxFitness = 0.0;
  iBest       = NoIndex;

  //
  // If argv0 doesn't match, don't try to apply matching algorithm to this
  // command.
  //
  // Note: All command forms must have the same argv0 argument type and value.
  //
  if( cmddef.at(0).at(0).match(tokens[0].value()) == 0.0 )
  {
    return EArgv0;
  }

  for(i = 0; i < cmddef.numOfForms(); ++i)
  {
    const CmdFormDef &form = cmddef.at(i);

    m_log << labelTry << form.getSyntax() << eoe;

    if( (rc = matchCommandForm(form, tokens, argvForm, fFitness)) == AOk )
    {
      if( fFitness > fMaxFitness )
      {
        argv        = argvForm;
        fMaxFitness = fFitness;
        iBest       = i;
      }
    }

    m_log << labelFit << fFitness << eoe;

    if( fMaxFitness >= 1.0 )
    {
      break;
    }
  }

  //
  // Found the best command form that matches the input.
  //
  if( iBest >= 0 )
  {
    m_log << labelMatch
          << "Command '" << cmddef.getName()
          << "', form " << iBest << ": Fitness " << fMaxFitness
          << eoe;
    fFitness = fMaxFitness;
    rc = AOk;
  }

  //
  // No fit.
  //
  else
  {
    m_log << labelNoMatch
          << "Command '" << cmddef.getName()
          << "', all forms."
          << eoe;
    rc = EBadSyntax;
  }

  return rc;
}

int CommandLine::matchCommandForm ( const CmdFormDef &  form, const TokenVec &  tokens, CmdExtArgVec &  argv, double &  fFitness  )

protected

Match command form against input line argument list.

Parameters

[in]	form	Compiled command form definition.
[in]	tokens	Vector of arguments.
[out]	argv	Vector of extended arguments, with argv[0] being the command name argument.
[out]	fFitness	Fitness of match [0.0 - 1.0].

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 1329 of file CommandLine.cxx.

References rnr::cmd::AOk, rnr::cmd::CmdArgDef::ArgTypeBoolean, rnr::cmd::CmdArgDef::ArgTypeFile, rnr::cmd::CmdArgDef::ArgTypeFpn, rnr::cmd::CmdArgDef::ArgTypeIdentifier, rnr::cmd::CmdArgDef::ArgTypeInteger, rnr::cmd::CmdArgDef::ArgTypeLiteral, rnr::cmd::CmdArgDef::ArgTypeMultiWord, rnr::cmd::CmdArgDef::ArgTypeRegEx, rnr::cmd::CmdArgDef::ArgTypeUndef, rnr::cmd::CmdArgDef::ArgTypeWord, rnr::cmd::CmdFormDef::at(), rnr::cmd::CmdArgDef::constructLiteralList(), rnr::cmd::CmdArgDef::constructRangeList(), rnr::cmd::CmdArgDef::convert(), rnr::cmd::EBadSyntax, rnr::cmd::EError, rnr::eoe(), rnr::cmd::CmdFormDef::getIndex(), rnr::cmd::CmdArgDef::getIndex(), rnr::cmd::CmdFormDef::getParentCmdUid(), rnr::cmd::CmdArgDef::getRanges(), rnr::cmd::CmdArgDef::getRegEx(), rnr::cmd::CmdArgDef::getType(), rnr::cmd::CmdArgDef::isOptional(), rnr::cmd::CmdArgDef::lookupArgSymbol(), m_bIgnoreCase, m_cmdDefs, m_log, rnr::cmd::CmdArgDef::match(), rnr::cmd::CmdFormDef::numOfArgs(), and rnr::cmd::CmdFormDef::numOfRequiredArgs().

Referenced by matchCommand().

{
  int     argcToks = (int)tokens.size();  // number of input tokens
  int     argcForm = form.numOfArgs();    // form total number of arguments
  double  fWeight, fDecay;                // match weight and decay multiplier
  int     iArg;                           // working form argument index
  int     iTok;                           // working input tokens index
  int     rc;                             // return code

  argv.clear();

  fFitness = 0.0;
  fDecay   = 1.0;

  // command name (for logging)
  const string &strCmdName = m_cmdDefs[form.getParentCmdUid()].getName();

  // 
  // Too many input arguments.
  //
  if( argcToks > argcForm )
  {
    m_log << labelNoMatch
          << "Command '" << strCmdName << "', "
          << "form " << form.getIndex() << ": "
          << "Too many arguments: "
          << argcToks << " specified, "
          << argcForm << " maximum."
          << eoe;
    return EBadSyntax;
  }

  //
  // Missing required input arguments.
  //
  else if( argcToks < form.numOfRequiredArgs() )
  {
    m_log << labelNoMatch
          << "Command '" << strCmdName << "', "
          << "form " << form.getIndex() << ": "
          << "Missing required arguments: "
          << argcToks << " specified, "
          << form.numOfRequiredArgs() << " required."
          << eoe;
    return EBadSyntax;
  }

  //
  // Match input arguments to form syntax.
  //
  for(iArg = 0, iTok = 0, rc = AOk;
      (iArg < argcForm) && (iTok < argcToks) && (rc == AOk);
      ++iArg)
  {
    const CmdArgDef &argdef = form.at(iArg);

    // try to match input token to argument sytax
    fWeight = argdef.match(tokens[iTok].value(), m_bIgnoreCase);

    // no match
    if( fWeight == 0.0 )
    {
      rc = EBadSyntax;

      // start log entry
      m_log << labelNoMatch
            << "Input argument " << tokens[iTok] << " doesn't match "
            << "command '" << strCmdName << "', "
            << "form " << form.getIndex() << ", "
            << (argdef.isOptional()? "(opt)": "")
            << "arg " << argdef.getIndex()
            << " definition."
            << eoe;
    
      //
      // Log reason of match failure.
      //
      switch( argdef.getType() )
      {
        case CmdArgDef::ArgTypeLiteral:
          m_log << labelBlank << "  Not one of: "
                << argdef.constructLiteralList() << "."
                << eoe;
        break;

        case CmdArgDef::ArgTypeWord:
        case CmdArgDef::ArgTypeMultiWord:
        case CmdArgDef::ArgTypeIdentifier:
        case CmdArgDef::ArgTypeBoolean:
        case CmdArgDef::ArgTypeFile:
          m_log << labelBlank << "  Not a "
                << "'" << CmdArgDef::lookupArgSymbol(argdef.getType())
                << "' type." << eoe;
          break;

        case CmdArgDef::ArgTypeInteger:
        case CmdArgDef::ArgTypeFpn:
          m_log << labelBlank << "  Not a "
                << "'" << CmdArgDef::lookupArgSymbol(argdef.getType())
                << "' type";
          if( argdef.getRanges().size() > 0 )
          {
            m_log << " or out of range " << argdef.constructRangeList();
          }
          m_log << "." << eoe;
          break;

        case CmdArgDef::ArgTypeRegEx:
          m_log << labelBlank << "  Failed to match re: "
                << "'" << argdef.getRegEx() << "'."
                << eoe;
          break;

        case CmdArgDef::ArgTypeUndef:
        default:
          LOGERROR("Bug: Unknown type %d.", argdef.getType());
          rc = EError;
          break;
      }
    }

    //
    // Good argument match.
    //
    if( rc == AOk )
    {
      m_log << labelMatch
            << "Input argument " << tokens[iTok] << " matches "
            << "cmd '" << strCmdName << "', "
            << "form " << form.getIndex() << ", "
            << "arg " << argdef.getIndex() << " "
            << "definition."
            << eoe;

      argv.push_back(argdef.convert(tokens[iTok].value(), m_bIgnoreCase));

      // don't decay perfection
      if( fWeight == 1.0 )
      {
        fFitness += fWeight;
      }
      else
      {
        fFitness += fWeight * fDecay;
      }

      fDecay *= 0.9;

      ++iTok;
    }

    //
    // Bad match, but argument is optional, and there are more optionals.
    //
    else if( argdef.isOptional() && (iArg < argcForm-1) )
    {
      rc = AOk;
    }

    //
    // Bad match.
    //
    else
    {
      fFitness = 0.0;
    }
  }

  // normalize fitness
  fFitness /= (double)argcToks;

  return rc;
}

int CommandLine::numOfArgs	(	int	uid,
		int	iform
	)		const

Get the total number of arguments.

The first argument (argv0) is the command.

Parameters

uid	Matched command unique id.
iform	Matched command form index.

Returns

Number of arguments.

Definition at line 1542 of file CommandLine.cxx.

References rnr::cmd::CmdDef::at(), at(), and rnr::cmd::CmdFormDef::numOfArgs().

Referenced by numOfArgs().

{
  return at(uid).at(iform).numOfArgs();
}

int CommandLine::numOfArgs

(

const CmdExtArg &

arg

)

const

Get the total number of arguments of matched command.

The extended argument contains matched command context.

Parameters

arg	Extended argument.

Returns

Number of arguments.

Definition at line 1547 of file CommandLine.cxx.

References at(), rnr::cmd::CmdExtArg::formIndex(), numOfArgs(), and rnr::cmd::CmdExtArg::uid().

{
  return at(arg.uid()).at(arg.formIndex()).numOfArgs();
}

int rnr::cmd::CommandLine::numOfCmds ( ) const

inline

Get the total number of added commands.

Returns

Number of commands.

Definition at line 1108 of file CommandLine.h.

Referenced by c14n(), compile(), execTCompile(), execTPrint(), and readCommand().

      {
        return (int)m_cmdDefs.size();
      }

int CommandLine::numOfOptionalArgs	(	int	uid,
		int	iform
	)		const

Get the total number of optional arguments.

Optional arguments start at argument index numOfRequiredArgs().

Parameters

uid	Matched command unique id.
iform	Matched command form index.

Returns

Number of optional arguments.

Definition at line 1562 of file CommandLine.cxx.

References rnr::cmd::CmdDef::at(), at(), and rnr::cmd::CmdFormDef::numOfOptionalArgs().

Referenced by numOfOptionalArgs().

{
  return at(uid).at(iform).numOfOptionalArgs();
}

int CommandLine::numOfOptionalArgs

(

const CmdExtArg &

arg

)

const

Get the total number of arguments of matched command.

The extended argument contains matched command context.

Parameters

arg	Extended argument.

Returns

Number of optional arguments.

Definition at line 1567 of file CommandLine.cxx.

References at(), rnr::cmd::CmdExtArg::formIndex(), numOfOptionalArgs(), and rnr::cmd::CmdExtArg::uid().

{
  return at(arg.uid()).at(arg.formIndex()).numOfOptionalArgs();
}

int CommandLine::numOfRequiredArgs	(	int	uid,
		int	iform
	)		const

Get the total number of required arguments.

The required number includes the command argv0.

Required arguments start at argument index 0.

Parameters

uid	Matched command unique id.
iform	Matched command form index.

Returns

Number of required arguments.

Definition at line 1552 of file CommandLine.cxx.

References rnr::cmd::CmdDef::at(), at(), and rnr::cmd::CmdFormDef::numOfRequiredArgs().

Referenced by checkCmd(), and numOfRequiredArgs().

{
  return at(uid).at(iform).numOfRequiredArgs();
}

int CommandLine::numOfRequiredArgs

(

const CmdExtArg &

arg

)

const

Get the total number of required arguments of matched command.

The extended argument contains matched command context.

The required number includes the command argv0.

Required arguments start at argument index 0.

Parameters

arg	Extended argument.

Returns

Number of required arguments.

Definition at line 1557 of file CommandLine.cxx.

References at(), rnr::cmd::CmdExtArg::formIndex(), numOfRequiredArgs(), and rnr::cmd::CmdExtArg::uid().

{
  return at(arg.uid()).at(arg.formIndex()).numOfRequiredArgs();
}

bool rnr::cmd::CommandLine::ok ( ) const

inline

Test if command-line interface is ok to continue.

Returns

Returns true or false.

Definition at line 481 of file CommandLine.h.

References rnr::cmd::DataSectNsCore.

Referenced by run().

      {
        return !((DataSectCore*)m_dataSects.at(DataSectNsCore).data())->m_bQuit;
      }

const CmdDef& rnr::cmd::CommandLine::operator[]

(

const int

uid

)

const

Index operator.

Get the command definition with the unique id.

Parameters

uid	Command unique id.

Returns

Command definition reference.

const CmdDef& rnr::cmd::CommandLine::operator[]

(

const std::string &

strName

)

const

Index operator.

Get the command definition with the unique id.

Parameters

strName

Command name.

Returns

Command definition reference.

bool CommandLine::parseArg ( CmdDef &  cmddef, CmdFormDef &  form, const TokenVec &  tokens, size_t &  pos  )

protected

Parse argument syntax.

Syntax:

<arg> ::= <xor-list-arg>
        | <variable-arg>
        | <literal-arg>

Parameters

[in,out]	cmddef	Command definition.
[in,out]	form	Command form definition.
[in]	tokens	Lexical tokens generated from the syntax usage.
[in,out]	pos	The parse cursor position.

See also

parseSyntax().

Returns

Returns true on a successful parse, false otherwise.

Definition at line 2605 of file CommandLine.cxx.

References rnr::eoe(), getErrorStr(), LOGERROR_STREAM, m_log, rnr::str::okstr(), parseLiteralArg(), parseVariableArg(), parseXorListArg(), and peekEq().

Referenced by parseOptionalArgList(), and parseRequiredArgList().

{
  bool  bOk;

  CL_DBG_PARSE_CALL_IN(cmddef, form, tokens, pos, endl);

  if( pos < tokens.size() )
  {
    if( peekEq("{", tokens[pos]) )
    {
      bOk = parseXorListArg(cmddef, form, tokens, pos);
    }
    else if( peekEq("<", tokens[pos]) )
    {
      bOk = parseVariableArg(cmddef, form, tokens, pos);
    }
    else
    {
      bOk = parseLiteralArg(cmddef, form, tokens, pos);
    }
  }
  else
  {
    m_log << labelSyntax << "Command argument not found." << eoe;
    LOGERROR_STREAM(getErrorStr());
    bOk = false;
  }

  CL_DBG_CALL_OUT_NL(okstr(bOk) << ", pos=" << pos);

  return bOk;
}

bool CommandLine::parseArgv0 ( CmdDef &  cmddef, CmdFormDef &  form, const TokenVec &  tokens, size_t &  pos  )

protected

Parse argument 0 (command name) syntax.

Argv0 is a special argument that defines the command name. Only literal and variable arguments types are valid.

Syntax:

<argv0> ::= <literal-arg>
          | <variable-arg>

Parameters

[in,out]	cmddef	Command definition.
[in,out]	form	Command form definition.
[in]	tokens	Lexical tokens generated from the syntax usage.
[in,out]	pos	The parse cursor position.

See also

parseSyntax().

Returns

Returns true on a successful parse, false otherwise.

Definition at line 2470 of file CommandLine.cxx.

References rnr::cmd::CmdArgDef::ArgTypeLiteral, rnr::eoe(), rnr::cmd::CmdArgDef::FlagCommand, getErrorStr(), rnr::cmd::CmdFormDef::getIndex(), rnr::cmd::CmdDef::getName(), rnr::cmd::CmdArgDef::getName(), rnr::cmd::CmdArgDef::getType(), rnr::cmd::CmdFormDef::lastArg(), rnr::cmd::CmdArgDef::literalAt(), LOGERROR_STREAM, m_log, rnr::cmd::CmdFormDef::m_nArgcReq, rnr::str::okstr(), rnr::cmd::CmdArgDef::orFlags(), parseLiteralArg(), parseVariableArg(), peekEq(), and rnr::cmd::CmdDef::setName().

Referenced by parseSyntax().

{
  bool    bOk;
  string  strName;

  CL_DBG_PARSE_CALL_IN(cmddef, form, tokens, pos, endl);

  if( pos < tokens.size() )
  {
    if( peekEq("<", tokens[pos]) )
    {
      bOk = parseVariableArg(cmddef, form, tokens, pos);
    }
    else
    {
      bOk = parseLiteralArg(cmddef, form, tokens, pos);
    }
  }
  else
  {
    m_log << labelSyntax << "Command argument not found in form "
          << form.getIndex() << "."
          << eoe;
    LOGERROR_STREAM(getErrorStr());
    bOk = false;
  }

  if( bOk )
  {
    form.m_nArgcReq++;

    form.lastArg().orFlags(CmdArgDef::FlagCommand);

    // set command's name
    if( form.lastArg().getType() == CmdArgDef::ArgTypeLiteral )
    {
      // literals are anonymous, use the literal itself
      strName = form.lastArg().literalAt(0);
    }
    else
    {
      // variables have required names
      strName = form.lastArg().getName();
    }

    // assign command name
    if( cmddef.getName().empty() )
    {
      cmddef.setName(strName);
    }
    // all forms must have the same command name
    else if( cmddef.getName() != strName )
    {
      m_log << labelSyntax << "Expected command name '" << cmddef.getName()
            << "', but found '" << strName << "' in form " << form.getIndex()
            << "."
            << eoe;
      LOGERROR_STREAM(getErrorStr());
      bOk = false;
    }
  }

  CL_DBG_CALL_OUT_NL(okstr(bOk) << ", pos=" << pos);

  return bOk;
}

bool CommandLine::parseIdentifier ( CmdDef &  cmddef, CmdFormDef &  form, const TokenVec &  tokens, size_t &  pos, std::string &  strIdent  )

protected

Parse identifier.

Syntax:

<identifier> ::= ALPHA {ALPHANUMERIC}*
               | '_' {ALPHANUMERIC}*

Parameters

[in,out]	cmddef	Command definition.
[in,out]	form	Command form definition.
[in]	tokens	Lexical tokens generated from syntax usage.
[in,out]	pos	The parse cursor position.

See also

parseSyntax().

Parameters

[out]

strIdent

Identity string.

Returns

Returns true on a successful parse, false otherwise.

Definition at line 2810 of file CommandLine.cxx.

References rnr::eoe(), getErrorStr(), LOGERROR_STREAM, m_log, rnr::str::okstr(), and tokIdentifier().

Referenced by parseVariableArg().

{
  bool    bOk;

  CL_DBG_PARSE_CALL_IN(cmddef, form, tokens, pos, endl);

  strIdent.clear();

  if( pos < tokens.size() )
  {
    strIdent = tokens[pos].value();
    bOk = tokIdentifier(tokens, pos);
  }
  else
  {
    m_log << labelSyntax << "No identifier found." << eoe;
    LOGERROR_STREAM(getErrorStr());
    bOk = false;
  }

  CL_DBG_CALL_OUT_NL(okstr(bOk) << ", identifier='" << strIdent
      << "', pos=" << pos);

  return bOk;
}

bool CommandLine::parseLiteralArg ( CmdDef &  cmddef, CmdFormDef &  form, const TokenVec &  tokens, size_t &  pos  )

protected

Parse literal, fixed-valued argument syntax.

A CmdArgDef object is added to the CmdDef

Syntax:

<literal-arg> ::= <literal>

Parameters

[in,out]	cmddef	Command definition.
[in,out]	form	Command form definition.
[in]	tokens	Lexical tokens generated from the syntax usage.
[in,out]	pos	The parse cursor position.

See also

parseSyntax().

Returns

Returns true on a successful parse, false otherwise.

Definition at line 2729 of file CommandLine.cxx.

References rnr::cmd::CmdArgDef::addLiteralValue(), rnr::cmd::CmdArgDef::ArgTypeLiteral, rnr::cmd::CmdFormDef::lastArg(), rnr::cmd::CmdFormDef::numOfArgs(), rnr::str::okstr(), parseLiteralValue(), rnr::cmd::CmdFormDef::pushArg(), rnr::cmd::CmdArgDef::setName(), and rnr::cmd::CmdArgDef::setType().

Referenced by parseArg(), and parseArgv0().

{
  bool      bOk;
  CmdArgDef argdef;
  string    strValue;

  CL_DBG_PARSE_CALL_IN(cmddef, form, tokens, pos, endl);

  form.pushArg(argdef);

  bOk = parseLiteralValue(cmddef, form, tokens, pos, strValue);

  if( bOk )
  {
    stringstream  ss;
    int           n = form.numOfArgs() - 1;

    ss << "_" << n;

    form.lastArg().setName(ss.str());
    form.lastArg().setType(CmdArgDef::ArgTypeLiteral);
    form.lastArg().addLiteralValue(strValue);
  }

  CL_DBG_CALL_OUT_NL(okstr(bOk) << ", pos=" << pos);

  return bOk;
}

bool CommandLine::parseLiteralValue ( CmdDef &  cmddef, CmdFormDef &  form, const TokenVec &  tokens, size_t &  pos, std::string &  strValue  )

protected

Parse literal value.

Syntax:

<literal> ::= {NON_SPECIAL_CHAR}+

Parameters

[in,out]	cmddef	Command definition.
[in,out]	form	Command form definition.
[in]	tokens	Lexical tokens generated from syntax usage.
[in,out]	pos	The parse cursor position.

See also

parseSyntax().

Parameters

[out]

strValue

Value string.

Returns

Returns true on a successful parse, false otherwise.

Definition at line 3079 of file CommandLine.cxx.

References rnr::eoe(), getErrorStr(), LOGERROR_STREAM, m_log, and rnr::str::okstr().

Referenced by parseLiteralArg(), and parseXorList().

{
  bool  bOk;

  CL_DBG_PARSE_CALL_IN(cmddef, form, tokens, pos, " ");

  strValue.clear();

  if( pos < tokens.size() )
  {
    strValue = tokens[pos++].value();
    bOk = true;
  }
  else
  {
    m_log << labelSyntax << "Literal value not found." << eoe;
    LOGERROR_STREAM(getErrorStr());
    bOk = false;
  }

  CL_DBG_CALL_OUT_IL(okstr(bOk) << ", value='" << strValue << "', "
      << "pos=" << pos);

  return bOk;
}

bool CommandLine::parseOptionalArgList ( CmdDef &  cmddef, CmdFormDef &  form, const TokenVec &  tokens, size_t &  pos  )

protected

Parse optional argument list syntax.

Syntax:

<optional-arg-list> ::= '[' <arg> ']'
                      | <optional-arg-list> '[' <arg> ']'

Parameters

[in,out]	cmddef	Command definition.
[in,out]	form	Command form definition.
[in]	tokens	Lexical tokens generated from the syntax usage.
[in,out]	pos	The parse cursor position.

See also

parseSyntax().

Returns

Returns true on a successful parse, false otherwise.

Definition at line 2569 of file CommandLine.cxx.

References rnr::cmd::CmdArgDef::FlagOptional, rnr::cmd::CmdFormDef::lastArg(), rnr::cmd::CmdFormDef::m_nArgcOpt, rnr::str::okstr(), rnr::cmd::CmdArgDef::orFlags(), parseArg(), peekEq(), and tokEq().

Referenced by parseSyntax().

{
  bool  bOk = true;

  CL_DBG_PARSE_CALL_IN(cmddef, form, tokens, pos, endl);

  while( bOk && (pos < tokens.size()) )
  {
    // peek if start an optional arguments
    if( !peekEq("[", tokens[pos]) )
    {
      break;
    }
    
    // "[ argument ]"
    if( tokEq("[", tokens, pos) &&
        parseArg(cmddef, form, tokens, pos) &&
        tokEq("]", tokens, pos) )
    {
      form.lastArg().orFlags(CmdArgDef::FlagOptional);
      form.m_nArgcOpt++;
    }
    else
    {
      bOk = false;
    }
  }

  CL_DBG_CALL_OUT_NL(okstr(bOk) << ", pos=" << pos);

  return bOk;
}

bool CommandLine::parseRequiredArgList ( CmdDef &  cmddef, CmdFormDef &  form, const TokenVec &  tokens, size_t &  pos  )

protected

Parse required argument list syntax.

Syntax:

<required-arg-list> ::= <arg>
                      | <required-arg-list> <arg>

Parameters

[in,out]	cmddef	Command definition.
[in,out]	form	Command form definition.
[in]	tokens	Lexical tokens generated from the syntax usage.
[in,out]	pos	The parse cursor position.

See also

parseSyntax().

Returns

Returns true on a successful parse, false otherwise.

Definition at line 2540 of file CommandLine.cxx.

References rnr::cmd::CmdFormDef::m_nArgcReq, rnr::str::okstr(), parseArg(), and peekEq().

Referenced by parseSyntax().

{
  bool  bOk = true;

  CL_DBG_PARSE_CALL_IN(cmddef, form, tokens, pos, endl);

  while( bOk && (pos < tokens.size()) )
  {
    // peek if start of optional arguments
    if( peekEq("[", tokens[pos]) )
    {
      break;
    }
    
    // required argument
    else if( (bOk = parseArg(cmddef, form, tokens, pos)) )
    {
      form.m_nArgcReq++;
    }
  }

  CL_DBG_CALL_OUT_NL(okstr(bOk) << ", pos=" << pos);

  return bOk;
}

int CommandLine::parseSyntax ( CmdDef &  cmddef, CmdFormDef &  form, const TokenVec &  tokens  )

protectedvirtual

Parse command syntax.

The parsed, generated internal data are used for readline tab completion, input - command pattern matching, and first-level validation.

The parseSyntax() function [in]directly calls the CommandLine::parse family of member functions. Each function takes, at a minimum, four parameters:

Parameter	Description
cmddef	Definition of an added command. It may be modified.
form	Definition of a command form. It may be modified.
tokens	Lexical tokens generated from the extended usage syntax.
pos	The parse cursor position. On input, it specifies
^	the starting position in the tokens vector. On a
^	succesful parse, the cursor position is advanced
^	to the first token after the relevant syntax block.

Syntax:

<command> ::= <argv0> [<required-arg-list>] [<optional-arg-list>]

Parameters

[in,out]	cmddef	Command definition.
[in,out]	form	Command form definition.
[in]	tokens	Lexical tokens generated from the syntax usage.

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 2398 of file CommandLine.cxx.

References rnr::cmd::AOk, rnr::cmd::EBadSyntax, rnr::eoe(), getErrorStr(), rnr::cmd::CmdFormDef::getIndex(), rnr::cmd::CmdDef::getName(), rnr::cmd::CmdFormDef::getSyntax(), rnr::cmd::CmdDef::getUid(), LOGDIAG2_STREAM, LOGERROR_STREAM, m_log, rnr::cmd::CmdFormDef::numOfArgs(), rnr::str::okstr(), parseArgv0(), parseOptionalArgList(), and parseRequiredArgList().

Referenced by compile().

{
  size_t  tokcnt  = tokens.size();
  size_t  pos     = 0;
  bool    bOk     = true;
  int     rc;

  CL_DBG_PARSE_CALL_IN(cmddef, form, tokens, 0, endl);

  m_log << labelParse
        << "cmddef " << cmddef.getUid() << ", "
        << "form " << form.getIndex() << ": "
        << form.getSyntax()
        << eoe;

  // command
  if( !parseArgv0(cmddef, form, tokens, pos) )
  {
    m_log << labelFail << "Parssing special argv0." << eoe;
    bOk = false;
  }

  // required argmuents - may be none
  else if( !parseRequiredArgList(cmddef, form, tokens, pos) )
  {
    m_log << labelFail << "Parsing required argument list." << eoe;
    bOk = false;
  }

  // optional arguments - may be none
  else if( !parseOptionalArgList(cmddef, form, tokens, pos) )
  {
    m_log << labelFail << "Parsing optional argument list." << eoe;
    bOk = false;
  }

  // final checks
  else if( pos < tokcnt )
  {
    m_log << labelFail
          << "Extraneous tokens found after optional arguments."
          << eoe;
    bOk = false;
  }

  // all good
  if( bOk )
  {
    m_log << labelParse << "Ok" << eoe;
    LOGDIAG2_STREAM("Command("
        << "uid=" << cmddef.getUid() << ", "
        << "name=" << cmddef.getName() << ", "
        << "form=" << form.getIndex() << ", "
        << "argc=" << form.numOfArgs() << ") "
        << "successfully parsed.");
    rc = AOk;
  }

  // not so good - log error
  else
  {
    LOGERROR_STREAM(getErrorStr());
    rc = EBadSyntax;
  }

  CL_DBG_CALL_OUT_NL("rc=" << rc << ", " << okstr(bOk) << ", pos=" << pos);

  return rc;
}

bool CommandLine::parseVariableArg ( CmdDef &  cmddef, CmdFormDef &  form, const TokenVec &  tokens, size_t &  pos  )

protected

Parse variable argument syntax.

A CmdArgDef object is added to the CmdDef

Syntax:

<variable-arg> ::= '<' <identifier> '>'
                 | '<' <identifier> ':' <var-modifier> '>'

Parameters

[in,out]	cmddef	Command definition.
[in,out]	form	Command form definition.
[in]	tokens	Lexical tokens generated from the syntax usage.
[in,out]	pos	The parse cursor position.

See also

parseSyntax().

Returns

Returns true on a successful parse, false otherwise.

Definition at line 2680 of file CommandLine.cxx.

References rnr::cmd::CmdArgDef::ArgTypeWord, rnr::cmd::CmdFormDef::lastArg(), rnr::str::okstr(), parseIdentifier(), parseVarMod(), peekEq(), rnr::cmd::CmdFormDef::pushArg(), rnr::cmd::CmdArgDef::setName(), rnr::cmd::CmdArgDef::setRanges(), rnr::cmd::CmdArgDef::setRegEx(), rnr::cmd::CmdArgDef::setType(), and tokEq().

Referenced by parseArg(), and parseArgv0().

{
  bool                bOk;
  CmdArgDef           argdef;
  string              strName;
  CmdArgDef::ArgType  eType;
  CmdArgDef::RangeVec ranges;
  RegEx               re;

  CL_DBG_PARSE_CALL_IN(cmddef, form, tokens, pos, endl);

  form.pushArg(argdef);

  bOk = tokEq("<", tokens, pos) &&
        parseIdentifier(cmddef, form, tokens, pos, strName);

  if( bOk )
  {
    // variable modifier
    if( peekEq(":", tokens[pos]) )
    {
      bOk = tokEq(":", tokens, pos) &&
            parseVarMod(cmddef, form, tokens, pos, eType, ranges, re);
    }
    // default
    else
    {
      eType = CmdArgDef::ArgTypeWord;
    }
  }

  bOk = bOk && tokEq(">", tokens, pos);

  if( bOk )
  {
    form.lastArg().setName(strName);
    form.lastArg().setType(eType);
    form.lastArg().setRanges(ranges);
    form.lastArg().setRegEx(re);
  }

  CL_DBG_CALL_OUT_NL(okstr(bOk) << ", pos=" << pos);

  return bOk;
}

bool CommandLine::parseVarMod ( CmdDef &  cmddef, CmdFormDef &  form, const TokenVec &  tokens, size_t &  pos, CmdArgDef::ArgType &  eType, CmdArgDef::RangeVec &  ranges, RegEx &  re  )

protected

Parse variable modifier.

Syntax:

<var-modifier> ::= <var-type>
                 | <var-type> <var-paren-expr>

<var-paren-expr> ::= '(' <range-expr> ')'
                   | '(' <regex> ')'

Parameters

[in,out]	cmddef	Command definition.
[in,out]	form	Command form definition.
[in]	tokens	Lexical tokens generated from the syntax usage.
[in,out]	pos	The parse cursor position.

See also

parseSyntax().

Parameters

[out]	eType	Type enum.
[out]	ranges	Vector of ranges.
[out]	re	Regular expression.

Returns

Returns true on a successful parse, false otherwise.

Definition at line 2840 of file CommandLine.cxx.

References rnr::cmd::CmdArgDef::ArgTypeFpn, rnr::cmd::CmdArgDef::ArgTypeInteger, rnr::cmd::CmdArgDef::ArgTypeRegEx, rnr::eoe(), getErrorStr(), LOGERROR_STREAM, rnr::cmd::CmdArgDef::lookupArgSymbol(), m_log, rnr::str::okstr(), parseVarRangeExpr(), parseVarRegExpr(), parseVarType(), peekEq(), and tokEq().

Referenced by parseVariableArg().

{
  bool  bOk;

  CL_DBG_PARSE_CALL_IN(cmddef, form, tokens, pos, endl);

  bOk = parseVarType(cmddef, form, tokens, pos, eType);

  if( bOk )
  {
    if( peekEq("(", tokens[pos]) )
    {
      switch( eType )
      {
        case CmdArgDef::ArgTypeInteger:
        case CmdArgDef::ArgTypeFpn:
          bOk = tokEq("(", tokens, pos) &&
                parseVarRangeExpr(cmddef, form, tokens, pos, ranges) &&
                tokEq(")", tokens, pos);
          break;
        case CmdArgDef::ArgTypeRegEx:
          bOk = tokEq("(", tokens, pos) &&
                parseVarRegExpr(cmddef, form, tokens, pos, re) &&
                tokEq(")", tokens, pos);
          break;
        default:
          m_log << labelSyntax
                << "Unexpected '(' token found for argument type "
                << "'" << CmdArgDef::lookupArgSymbol(eType) << "'."
                << eoe;
          LOGERROR_STREAM(getErrorStr());
          bOk = false;
      }
    }
  }

  CL_DBG_CALL_OUT_NL(okstr(bOk) << ", type=" << eType << ", pos=" << pos);

  return bOk;
}

bool CommandLine::parseVarRangeExpr ( CmdDef &  cmddef, CmdFormDef &  form, const TokenVec &  tokens, size_t &  pos, CmdArgDef::RangeVec &  ranges  )

protected

Parse variable range expression.

Syntax:

<range-expr> ::= <range>
               | <range-expr> ',' <range>

<range> ::= NUMBER
          | NUMBER ':' NUMBER

Parameters

[in,out]	cmddef	Command definition.
[in,out]	form	Command form definition.
[in]	tokens	Lexical tokens generated from the syntax usage.
[in,out]	pos	The parse cursor position.

See also

parseSyntax().

Parameters

[out]

ranges

Vector of ranges.

Returns

Returns true on a successful parse, false otherwise.

Definition at line 2929 of file CommandLine.cxx.

References rnr::eoe(), getErrorStr(), LOGERROR_STREAM, m_log, rnr::cmd::CmdArgDef::range::max, rnr::cmd::CmdArgDef::range::min, rnr::str::okstr(), rnr::str::split(), and rnr::str::todouble().

Referenced by parseVarMod().

{
  bool              bOk = true;
  StringVec         subranges;
  StringVec         minmax;
  CmdArgDef::range  r;

  CL_DBG_PARSE_CALL_IN(cmddef, form, tokens, pos, " ");

  ranges.clear();

  if( pos < tokens.size() )
  {
    split(tokens[pos].value(), ',', subranges);

    for(size_t i = 0; bOk && (i < subranges.size()); ++i)
    {
      minmax.clear();

      split(subranges[i], ':', minmax);

      if( minmax.size() == 0 )
      {
        m_log << labelSyntax << "No 'min[:max]' subrange found in "
              << "'" << tokens[pos].value() << "'.'"
              << eoe;
        bOk = false;
        break;
      }
      else if( minmax.size() > 2 )
      {
        m_log << labelSyntax << "Too many 'min:max:?' subrange values found in "
              << "'" << tokens[pos].value() << "'.'"
              << eoe;
        bOk = false;
        break;
      }

      if( todouble(minmax[0], r.min) != OK )
      {
        m_log << labelSyntax << "Subrange min '" << minmax[0] << "' NaN in "
              << "'" << tokens[pos].value() << "'.'"
              << eoe;
        bOk = false;
        break;
      }

      if( minmax.size() == 2 )
      {
        if( todouble(minmax[1], r.max) != OK )
        {
          m_log << labelSyntax << "Subrange max '" << minmax[1] << "' NaN in "
                << "'" << tokens[pos].value() << "'.'"
                << eoe;
          bOk = false;
          break;
        }
      }
      else
      {
        r.max = r.min;
      }

      // reverse ranges are ok, just swap order
      if( r.max < r.min )
      {
        double tmp;

        r.min = tmp;
        r.min = r.max;
        r.max = r.min;
      }

      ranges.push_back(r);
    }
  }

  // everything is cool, but no ranges specified
  if( bOk && (ranges.size() == 0) )
  {
    m_log << labelSyntax << "Range expression not found." << eoe;
    bOk = false;
  }

  if( bOk )
  {
    ++pos; // advance token parse position
  }
  else
  {
    LOGERROR_STREAM(getErrorStr());
  }

  CL_DBG_CALL_OUT_IL(okstr(bOk) << ", numranges=" << ranges.size()
      << ", pos=" << pos);

  return bOk;
}

bool CommandLine::parseVarRegExpr ( CmdDef &  cmddef, CmdFormDef &  form, const TokenVec &  tokens, size_t &  pos, RegEx &  re  )

protected

Parse variable regular expression.

Syntax:

<regex> ::= REGEX

Parameters

[in,out]	cmddef	Command definition.
[in,out]	form	Command form definition.
[in]	tokens	Lexical tokens generated from the syntax usage.
[in,out]	pos	The parse cursor position.

See also

parseSyntax().

Parameters

[out]

re

Regular expression.

Returns

Returns true on a successful parse, false otherwise.

Definition at line 3032 of file CommandLine.cxx.

References rnr::eoe(), rnr::RegEx::getErrorStr(), getErrorStr(), rnr::RegEx::getRegEx(), rnr::RegEx::isValid(), LOGERROR_STREAM, m_bIgnoreCase, m_log, rnr::str::okstr(), rnr::RegEx::ReFlagICase, and rnr::RegEx::setFlags().

Referenced by parseVarMod().

{
  bool  bOk;

  CL_DBG_PARSE_CALL_IN(cmddef, form, tokens, pos, " ");

  if( pos < tokens.size() )
  {
    if( m_bIgnoreCase )
    {
      re.setFlags(RegEx::ReFlagICase);
    }

    re = tokens[pos++].value();

    if( re.isValid() )
    {
      bOk = true;
    }
    else
    {
      m_log << labelSyntax << "Regular expression '"
            << "'" << re.getRegEx() << "': "
            << re.getErrorStr() << "."
            << eoe;
      LOGERROR_STREAM(getErrorStr());
      bOk = false;
    }
  }

  else
  {
    m_log << labelSyntax << "Regular expression not found." << eoe;
    LOGERROR_STREAM(getErrorStr());
    bOk = false;
  }

  CL_DBG_CALL_OUT_IL(okstr(bOk) << ", re='" << re.getRegEx() << "', pos="
      << pos);

  return bOk;
}

bool CommandLine::parseVarType ( CmdDef &  cmddef, CmdFormDef &  form, const TokenVec &  tokens, size_t &  pos, CmdArgDef::ArgType &  eType  )

protected

Parse variable type.

Syntax:

<var-type> ::= word | multiword | identifier | bool |
               int | fpn | re | file

Parameters

[in,out]	cmddef	Command definition.
[in,out]	form	Command form definition.
[in]	tokens	Lexical tokens generated from the syntax usage.
[in,out]	pos	The parse cursor position.

See also

parseSyntax().

Parameters

[out]

eType

Type enum.

Returns

Returns true on a successful parse, false otherwise.

Definition at line 2887 of file CommandLine.cxx.

References rnr::cmd::CmdArgDef::ArgTypeUndef, rnr::eoe(), getErrorStr(), LOGERROR_STREAM, rnr::cmd::CmdArgDef::lookupArgType(), m_log, and rnr::str::okstr().

Referenced by parseVarMod().

{
  bool  bOk;

  CL_DBG_PARSE_CALL_IN(cmddef, form, tokens, pos, " ");

  eType = CmdArgDef::ArgTypeUndef;

  if( pos < tokens.size() )
  {
    eType = CmdArgDef::lookupArgType(tokens[pos].value());

    if( eType != CmdArgDef::ArgTypeUndef )
    {
      ++pos;
      bOk = true;
    }
    else
    {
      m_log << labelSyntax << "Unknown variable type '" << tokens[pos].value()
            << "'." << eoe;
      LOGERROR_STREAM(getErrorStr());
      bOk = false;
    }
  }

  else
  {
    m_log << labelSyntax << "No variable type found." << eoe;
    LOGERROR_STREAM(getErrorStr());
    bOk = false;
  }

  CL_DBG_CALL_OUT_IL(okstr(bOk) << ", type=" << eType << ", pos=" << pos);

  return bOk;
}

bool CommandLine::parseXorList ( CmdDef &  cmddef, CmdFormDef &  form, const TokenVec &  tokens, size_t &  pos, str::StringVec &  literals  )

protected

Parse mutually exclusive list.

Syntax:

<xor-list> ::= <literal>
             | <xor-list> '|' <literal>

Parameters

[in,out]	cmddef	Command definition.
[in,out]	form	Command form definition.
[in]	tokens	Lexical tokens generated from syntax usage.
[in,out]	pos	The parse cursor position.

See also

parseSyntax().

Parameters

[out]

literals

Vector of literals.

Returns

Returns true on a successful parse, false otherwise.

Definition at line 2761 of file CommandLine.cxx.

References rnr::eoe(), getErrorStr(), LOGERROR_STREAM, m_log, rnr::str::okstr(), parseLiteralValue(), peekEq(), and tokEq().

Referenced by parseXorListArg().

{
  bool    bOk   = true;
  bool    more = true;
  string  strValue;

  CL_DBG_PARSE_CALL_IN(cmddef, form, tokens, pos, endl);

  while( more && bOk && (pos < tokens.size()) )
  {
    if( peekEq("}", tokens[pos]) )
    {
      m_log << labelSyntax << "Expected literal value but found '}'." << eoe;
      LOGERROR_STREAM(getErrorStr());
      bOk = false;
    }

    else if( (bOk = parseLiteralValue(cmddef, form, tokens, pos, strValue)) )
    {
      literals.push_back(strValue);

      // peek if start of another xor option
      if( peekEq("|", tokens[pos]) )
      {
        bOk = tokEq("|", tokens, pos);
      }
      else
      {
        more = false;
      }
    }
  }

  if( more && bOk )
  {
    m_log << labelSyntax << "No literal value found." << eoe;
    LOGERROR_STREAM(getErrorStr());
    bOk = false;
  }

  CL_DBG_CALL_OUT_NL(okstr(bOk) << ", pos=" << pos);

  return bOk;
}

bool CommandLine::parseXorListArg ( CmdDef &  cmddef, CmdFormDef &  form, const TokenVec &  tokens, size_t &  pos  )

protected

Parse mutually exclusive argument values syntax.

A CmdArgDef object is added to the CmdDef

Syntax:

<xor-list-arg> ::= '{' <xor-list> '}'

Parameters

[in,out]	cmddef	Command definition.
[in,out]	form	Command form definition.
[in]	tokens	Lexical tokens generated from the syntax usage.
[in,out]	pos	The parse cursor position.

See also

parseSyntax().

Returns

Returns true on a successful parse, false otherwise.

Definition at line 2641 of file CommandLine.cxx.

References rnr::cmd::CmdArgDef::addLiteralValue(), rnr::cmd::CmdArgDef::ArgTypeLiteral, rnr::cmd::CmdArgDef::FlagXorList, rnr::cmd::CmdFormDef::lastArg(), rnr::cmd::CmdFormDef::numOfArgs(), rnr::str::okstr(), rnr::cmd::CmdArgDef::orFlags(), parseXorList(), rnr::cmd::CmdFormDef::pushArg(), rnr::cmd::CmdArgDef::setName(), rnr::cmd::CmdArgDef::setType(), and tokEq().

Referenced by parseArg().

{
  bool      bOk;
  CmdArgDef argdef;
  StringVec literals;

  CL_DBG_PARSE_CALL_IN(cmddef, form, tokens, pos, endl);

  form.pushArg(argdef);

  bOk = tokEq("{", tokens, pos) &&
        parseXorList(cmddef, form, tokens, pos, literals) &&
        tokEq("}", tokens, pos);

  if( bOk )
  {
    stringstream  ss;
    int           n = form.numOfArgs() - 1;

    ss << "_" << n;

    form.lastArg().setName(ss.str());
    form.lastArg().setType(CmdArgDef::ArgTypeLiteral);
    form.lastArg().orFlags(CmdArgDef::FlagXorList);

    for(size_t i = 0; i < literals.size(); ++i)
    {
      form.lastArg().addLiteralValue(literals[i]);
    }
  }

  CL_DBG_CALL_OUT_NL(okstr(bOk) << ", pos=" << pos);

  return bOk;
}

bool rnr::cmd::CommandLine::peekEq ( const std::string  strCmp, const Token &  token  ) const

inlineprotected

Peek if token is equal to string.

The position cursor is not advance nor any error message logged.

Parameters

[in]	strCmp	String to compare token against.
[in]	token	Lexical token.

Returns

Returns true on equal, false otherwise.

Definition at line 1789 of file CommandLine.h.

References rnr::cmd::Token::value().

Referenced by parseArg(), parseArgv0(), parseOptionalArgList(), parseRequiredArgList(), parseVariableArg(), parseVarMod(), and parseXorList().

      {
        return token.value() == strCmp;
      }

void CommandLine::popPrompt

(

)

Pop prompt string from stack of prompts.

The new top prompt string will be used for user prompting.

Definition at line 1058 of file CommandLine.cxx.

References getPrompt(), m_prompts, m_readline, rnr::cmd::noprompt, and rnr::cmd::ReadLine::setPrompt().

Referenced by execCliTest().

{
  if( !m_prompts.empty() )
  {
    m_prompts.pop_back();
    m_readline.setPrompt(getPrompt());
  }
  else
  {
    m_readline.setPrompt(noprompt);
  }
}

int CommandLine::processInput ( const std::string &  strLine, CmdExtArgVec &  argv  )

protected

Process a line of input.

The line is tokenized and matched to the command with the best fit.

Parameters

[in]	strLine	Line of input.
[out]	argv	Vector of extended arguments, with argv[0] being the command name argument.

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 1083 of file CommandLine.cxx.

References checkReadResult(), rnr::cmd::EBadSyntax, match(), and tokenizeInput().

Referenced by readCommand().

{
  TokenVec  tokens; // tokenized input arguments
  int       argc;   // argument count
  int       rc;     // return code

  argv.clear();

  //
  // The line is empty - find out why?
  //
  if( strLine.empty() )
  {
    rc = checkReadResult();
  }

  //
  // Tokenize the input line.
  //
  else if( (argc = (int)tokenizeInput(strLine, tokens)) < 0 )
  {
    // bad token - error string already set
    rc = EBadSyntax;
  }

  //
  // Line full of whitespace - again, find out why?
  //
  else if( argc == 0 )
  {
    rc = checkReadResult();
  }

  //
  // Otherwise match the input arguments to the best form of the best fit 
  // command definition.
  //
  else
  {
    rc = match(tokens, argv);
  }

  return rc;
}

void CommandLine::pushPrompt

(

const std::string &

strPrompt

)

Push prompt string onto stack of prompts.

If in interactive mode, the user will be prompted with the prompt string found at the top of the prompt stack. If the stack or prompt string is empty, no prompt will be displayed. Any prompt is written to standard output (stdout).

Parameters

strPrompt

Prompt string.

Definition at line 1052 of file CommandLine.cxx.

References m_prompts, m_readline, and rnr::cmd::ReadLine::setPrompt().

Referenced by CommandLine(), and execTPush().

{
  m_prompts.push_back(strPrompt);
  m_readline.setPrompt(strPrompt);
}

void CommandLine::pushToken ( const std::string &  strSource, const size_t  start, const ssize_t  cursor, TokenVec &  tokens  )

protected

Push token to the end of the generated tokens.

Parameters

	strSource	Source string of tokens.
	start	Start token character position in source.
	cursor	Cursor position in source.
[in,out]	tokens	Vector of lexical tokens.

Definition at line 2383 of file CommandLine.cxx.

References getLineNum().

Referenced by lexQuotedString(), lexSyntaxParenExpr(), lexSyntaxWord(), lexWord(), logLexToken(), and tokenizeSyntax().

{
  Token tok(strSource.substr(start, cursor-start),
            getLineNum(), start, cursor-1);
  tokens.push_back(tok);
}

virtual int rnr::cmd::CommandLine::readCommand ( int &  uid, int &  iform, str::StringVec &  argv  )

inlinevirtual

Read an input line from stdin and match to the best compiled command.

Simple string argument version.

On success, no arguments indicate an empty input line. Otherwise, the command name argv[0] is guaranteed to be present in the vector.

Parameters

[out]	uid	Matched command unique id.
[out]	iform	Matched command form index.
[out]	argv	Vector of arguments, with argv[0] being the command name.

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 683 of file CommandLine.h.

Referenced by readCommand(), and run().

      {
        return readCommand(stdin, uid, iform, argv);
      }

virtual int rnr::cmd::CommandLine::readCommand ( CmdExtArgVec &  argv )

inlinevirtual

Read an input line from stdin and match to the best compiled command.

Extended argument version.

Each extended argument contains matched command context of:

• the command's unique id and definition
• form definition index
• argument definition index
• argument instance number for (future) argument repetition

On success, no arguments indicate an empty input line. Otherwise, the command name argv[0] is guaranteed to be present in the vector.

Extended arguments gives access to the compiled, matched command definition data such as number of required, optional, and total arguments, plus argument specific info such as name, type, etc.

Parameters

[out]	uid	Matched command unique id.
[out]	argv	Vector of extended arguments, with argv[0] being the command name argument.

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 713 of file CommandLine.h.

References rnr::cmd::CmdExec::execute().

      {
        return readCommand(stdin, argv);
      }

int CommandLine::readCommand ( FILE *  fp, int &  uid, int &  iform, str::StringVec &  argv  )

virtual

Read an input line from file fp and match to the best compiled command.

Simple string argument version.

On success, no arguments indicate an empty input line. Otherwise, the command name argv[0] is guaranteed to be present in the vector.

Parameters

	fp	Input file pointer.
[out]	uid	Matched command unique id.
[out]	iform	Matched command form index.
[out]	argv	Vector of arguments, with argv[0] being the command name.

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 848 of file CommandLine.cxx.

References rnr::cmd::AOk, rnr::cmd::NoIndex, rnr::cmd::NoUid, readCommand(), and toVec().

{
  CmdExtArgVec  extargv;
  int           rc;

  argv.clear();

  uid   = NoUid;
  iform = NoIndex;

  if( ((rc = readCommand(fp, extargv)) == AOk) && (extargv.size() > 0) )
  {
    uid   = extargv[0].uid();
    iform = extargv[0].formIndex();

    toVec(extargv, argv);
  }

  return rc;
}

int CommandLine::readCommand ( FILE *  fp, CmdExtArgVec &  argv  )

virtual

Read an input line from file fp and match to the best compiled command.

Extended argument version.

Each extended argument contains matched command context of:

• the command's unique id and definition
• form definition index
• argument definition index
• argument instance number for (future) argument repetition

On success, no arguments indicate an empty input line. Otherwise, the command name argv[0] is guaranteed to be present in the vector.

Extended arguments gives access to the compiled, matched command definition data such as number of required, optional, and total arguments, plus argument specific info such as name, type, etc.

Parameters

	fp	Input file pointer.
[out]	argv	Vector of extended arguments, with argv[0] being the command name argument.

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 869 of file CommandLine.cxx.

References rnr::cmd::AOk, backtrace(), rnr::bookmark(), rnr::LogBook::clear(), rnr::cmd::ENoExec, rnr::eoe(), getBtEnable(), getErrorStr(), getLineNum(), getName(), rnr::cmd::ReadLine::ireadLine(), LOGDIAG3_STREAM, LOGERROR_STREAM, m_cmdDefs, m_log, m_readline, numOfCmds(), processInput(), and rnr::cmd::ReadLine::rlreadLine().

{
  string  strLine;
  int     rc;

  m_log.clear();
  m_log << bookmark(markExec) << labelExec << __func__ << eoe;

  argv.clear();

  //
  // Preliminary checks.
  //
  if( numOfCmds() == 0 )
  {
    m_log << labelNoExec << "No commands added to interface." << eoe;
    LOGERROR_STREAM(getErrorStr());
    return ENoExec;
  }
  else if( !isDefined() )
  {
    m_log << labelNoExec << "Commands not fully compiled." << eoe;
    LOGERROR_STREAM(getErrorStr());
    return ENoExec;
  }

  //
  // Read a line of input.
  //
  if( fileno(fp) == fileno(stdin) )
  {
    strLine = m_readline.rlreadLine();
  }
  else
  {
    strLine = m_readline.ireadLine(fp);
  }

  m_log << labelInput << "stdin" << "[" << getLineNum() << "] "
    << strLine << eoe;

  //
  // Process input, match to best command.
  //
  if( (rc = processInput(strLine, argv)) == AOk )
  {
    m_log << labelExec << "Ok" << eoe;

    if( argv.size() > 0 )
    {
      LOGDIAG3_STREAM("Command "
        << m_cmdDefs[argv[0].uid()].getName()
        << "(" << argv[0].uid() << "), form "
        << argv[0].formIndex() << " matched.");
    }
  }
  else
  {
    m_log << labelFail << "Input not matched to any command." << eoe;

    LOGDIAG3("No command matched to input.");
  }

  if( getBtEnable() )
  {
    backtrace(cerr);
  }

  return rc;
}

int CommandLine::removeAllCommands ( )

virtual

Remove all commands from command line interface.

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 619 of file CommandLine.cxx.

References rnr::cmd::AOk, rnr::eoe(), m_bIsCompiled, m_cmdDefs, and m_log.

{
  m_cmdDefs.clear();
  m_bIsCompiled = false;
  m_log << "All commands removed." << eoe;
  return AOk;
}

int CommandLine::removeCommand ( const int  uid )

virtual

Remove command from command line interface.

No re-comiple is necessary.

Parameters

uid	Command unique id.

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 569 of file CommandLine.cxx.

References rnr::cmd::AOk, cmdAt(), rnr::cmd::EBadVal, rnr::eoe(), getErrorStr(), rnr::cmd::CmdDef::getUid(), LOGERROR_STREAM, m_bIsCompiled, m_cmdDefs, m_cmdExecs, m_log, and rnr::cmd::NoUid.

Referenced by execTRemove().

{
  CmdDefIter  dpos; // definition position
  CmdExecIter epos; // execution position
  int         rc;   // return code

  if( uid == NoUid )
  {
    rc = EBadVal;
  }
  else if( (dpos = m_cmdDefs.find(uid)) == m_cmdDefs.end() )
  {
    rc = EBadVal;
  }
  else
  {
    // remove command definition
    m_cmdDefs.erase(dpos);

    // remove any command execution function
    if( (epos = m_cmdExecs.find(uid)) != m_cmdExecs.end() )
    {
      m_cmdExecs.erase(epos);
    }

    if( m_cmdDefs.size() == 0 )
    {
      m_bIsCompiled = false;
    }

    m_log << "Command " << uid << " removed." << eoe;
    rc = AOk;
  }

  if( rc != AOk )
  {
    m_log << "No command with uid " << uid << " found." << eoe;
    LOGERROR_STREAM(getErrorStr());
  }

  return rc;
}

virtual int rnr::cmd::CommandLine::removeCommand ( const std::string &  strName )

virtual

Remove command from command line interface.

No re-comiple is necessary.

Parameters

strName

Command name.

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

int CommandLine::removeDataSection

(

const std::string &

ns

)

Remove a data section from the command-line interface.

If a deallocation function was specified, the section data is also deleted. Otherwise, the data remains intact.

Parameters

ns	Namespace of data section to remove.

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 809 of file CommandLine.cxx.

References rnr::cmd::AOk, rnr::cmd::EBadVal, rnr::cmd::ENoExec, isReservedDataSection(), LOGERROR_STREAM, and m_dataSects.

{
  DataSectIter pos = m_dataSects.find(ns);

  if( pos != m_dataSects.end() )
  {
    LOGERROR_STREAM("No data section '" << ns << "' exist - cannot remove.");
    return EBadVal;
  }
  else if( isReservedDataSection(pos->first) )
  {
    LOGERROR_STREAM("Reserved data section '" << ns << "' cannot be removed.");
    return ENoExec;
  }
  else
  {
    m_dataSects.erase(pos);
    return AOk;
  }
}

void CommandLine::rlArgDefs ( const std::string &  strSubtext, std::vector< CmdArgDef * > &  argdefs  )

protected

Build list of all command argument definitions that match completed subtext.

Parameters

[in]	strSubtext	Complete subtext string.
[out]	argdefs	List of matched argument definitions.

Definition at line 1654 of file CommandLine.cxx.

References rnr::cmd::CmdFormDef::argAt(), rnr::cmd::CmdArgDef::getParentCmdUid(), rnr::cmd::CmdArgDef::getParentFormIndex(), m_bIgnoreCase, m_cmdDefs, rnr::cmd::CmdArgDef::match(), rnr::cmd::CmdFormDef::numOfArgs(), and tokenizeInput().

Referenced by rlGenerator().

{
  CmdDefIter          iter;         // command definition iterator
  vector<CmdArgDef*>  v[2];         // work swap vectors of argument definitions
  int                 tog0, tog1;   // vector toggle source/destination indices
  StringVec           tokens;       // input tokens
  size_t              argc;         // token working argument count
  size_t              i, j;         // working indices

  argdefs.clear();

  tokenizeInput(strSubtext, tokens);
    
  tog0 = 0, tog1 = 1;

  //
  // Seed with argv0 (command).
  //
  for(iter = m_cmdDefs.begin(); iter != m_cmdDefs.end(); ++iter)
  {
    for(j = 0; j < iter->second.numOfForms(); ++j)
    {
      CmdFormDef &form = iter->second.formAt(j);
      v[tog0].push_back(&form.argAt(0));
    }
  }

  //
  // Walk across token arguments, paring unmatched argument defs from list.
  //
  for(argc = 0; argc < tokens.size(); ++argc)
  {
    v[tog1].clear();

    for(i = 0; i < v[tog0].size(); ++i)
    {
      CmdArgDef *p = v[tog0][i];

      if( p->match(tokens[argc], m_bIgnoreCase) > 0.0 )
      {
        CmdFormDef &form =
                m_cmdDefs[p->getParentCmdUid()].formAt(p->getParentFormIndex());

        if( argc+1 < form.numOfArgs() )
        {
          v[tog1].push_back(&form.argAt(argc+1));
        }
      }
    }

    tog0 = tog1;
    tog1 = (tog1 + 1) % 2;
  }

  // copy to interface parameter
  for(i = 0; i < v[tog0].size(); ++i)
  {
    argdefs.push_back(v[tog0][i]);
  }
}

int CommandLine::rlBuildReadLineGenerator ( )

protectedvirtual

Perform any necessary pre-processing to prepare for command line TAB completion.

Note

Nothing is needed for the CommandLine base class.

Returns

On success, AOk(0) is returned. On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 1592 of file CommandLine.cxx.

References rnr::cmd::AOk.

Referenced by compile().

{
  return AOk;
}

const string CommandLine::rlGenerator ( const std::string &  strText, int  nIndex, const std::string &  strContext, int  nStart, int  nEnd, unsigned &  uFlags  )

protectedvirtual

TAB completion generator.

See ReadLine::AltAppGenFunc for description of a ReadLine generator.

Parameters

	strText	Partial text string to complete.
	nIndex	Match candidate index starting from 0.
	strContext	Generator context (i.e. input buffer).
	nStart	Starting index in context of text.
	nEnd	Ending index in context of the position immediately after the end of text. If nStart equals nEnd, then empty text.
[out]	uFlags	TAB completion modifier flags.

Returns

Match or empty string.

Definition at line 1616 of file CommandLine.cxx.

References rlArgDefs(), rnr::cmd::RlTabEnd, and rlTabList().

{
  static vector<CmdArgDef*> argdefs;

  StringVec tabList;
  size_t    i;

  //cerr  << "{text=" << strText
  //      << ", index=" << nIndex
  //      << ", context=" << strContext
  //      << ", start=" << nStart
  //      << ", end=" << nEnd
  //      << "}" << endl;

  if( nIndex == 0 )
  {
    //cerr << "rebuild args" << endl;
    argdefs.clear();
    rlArgDefs(strContext.substr(0, nStart), argdefs);
  }

  rlTabList(strText, argdefs, tabList, uFlags);

  if( nIndex < tabList.size() )
  {
    return tabList[nIndex];
  }
  else
  {
    return RlTabEnd;
  }
}

const string CommandLine::rlGeneratorWrapper ( void *  pAppArg, const std::string &  strText, int  nIndex, const std::string &  strContext, int  nStart, int  nEnd, unsigned &  uFlags  )

staticprotected

Static TAB completion generator wrapper.

See ReadLine::AltAppGenFunc for description of a ReadLine generator.

Parameters

	pAppArg	Pointer to this CommandLine object.
	strText	Partial text string to complete.
	nIndex	Match candidate index starting from 0.
	strContext	Generator context (i.e. input buffer).
	nStart	Starting index in context of text.
	nEnd	Ending index in context of the position immediately after the end of text. If nStart equals nEnd, then empty text.
[out]	uFlags	TAB completion modifier flags.

Returns

Match or empty string.

Definition at line 1597 of file CommandLine.cxx.

References rnr::cmd::emptystring.

Referenced by compile().

{
  if( pAppArg != NULL )
  {
    return ((CommandLine *)pAppArg)->rlGenerator(strText, nIndex, strContext,
                                                 nStart, nEnd, uFlags);
  }
  else
  {
    return emptystring;
  }
}

bool CommandLine::rlPartialMatch ( const std::string &  strText, const std::string  strLiteral, const size_t  uLen  )

protected

Match partial text agains literal string.

Ignore case is taken into account when strings are compared.

Parameters

[in]	strText	Partial text string to complete.
[in]	strLiteral	Literal text string to compare.
[in]	uLen	Number of characters to match.

Returns

Returns true on partial match, false otherwise.

Definition at line 1860 of file CommandLine.cxx.

References rnr::str::lowercase(), and m_bIgnoreCase.

Referenced by rlTabList().

{
  if( m_bIgnoreCase )
  {
    return lowercase(strText) == lowercase(strLiteral.substr(0, uLen));
  }
  else
  {
    return strText == strLiteral.substr(0, uLen);
  }
}

void CommandLine::rlTabList ( const std::string &  strText, std::vector< CmdArgDef * > &  argdefs, str::StringVec &  tabList, unsigned &  uFlags  )

protected

Build TAB completion list and set appropriate readline modifiers.

Parameters

[in]	strText	Partial text string to complete.
[in]	argdefs	List of matched argument definitions.
[out]	tabList	List of TAB completion matches.
[out]	uFlags	TAB completion modifier flags.

Definition at line 1716 of file CommandLine.cxx.

References rnr::cmd::CmdArgDef::ArgTypeBoolean, rnr::cmd::CmdArgDef::ArgTypeFile, rnr::cmd::CmdArgDef::ArgTypeFpn, rnr::cmd::CmdArgDef::ArgTypeIdentifier, rnr::cmd::CmdArgDef::ArgTypeInteger, rnr::cmd::CmdArgDef::ArgTypeLiteral, rnr::cmd::CmdArgDef::ArgTypeMultiWord, rnr::cmd::CmdArgDef::ArgTypeRegEx, rnr::cmd::CmdArgDef::ArgTypeUndef, rnr::cmd::CmdArgDef::ArgTypeWord, rnr::str::FalseHood, rnr::cmd::ReadLine::FlagTabNoDefault, rnr::cmd::ReadLine::FlagTabNoFilename, rnr::cmd::ReadLine::FlagTabNoSpace, rnr::str::gcss(), rlPartialMatch(), and rnr::str::TruthHood.

Referenced by rlGenerator().

{
  size_t                len;          // length of input text
  set<string>           A;            // set with unique keys == values
  set<string>::iterator iter, jter;   // bidirectional set iterators
  string                str;          // working string
  size_t                i, j, min;    // working indices, minimum

  // clear TAB list of all existing candidates
  tabList.clear();

  // no filename completion
  uFlags = ReadLine::FlagTabNoFilename;

  // nothing to TAB complete
  if( argdefs.size() == 0 )
  {
    return;
  }

  // length of partial text to complete
  len = strText.size();

  //
  // Build tab completion super list.
  //
  // Note: Sets automatically handle duplicates.
  //
  for(i = 0; i < argdefs.size(); ++i)
  {
    switch( argdefs[i]->getType() )
    {
      // Find all literals that partially match text.
      case CmdArgDef::ArgTypeLiteral:
        for(j = 0; j < argdefs[i]->numOfLiterals(); ++j)
        {
          str = argdefs[i]->literalAt(j);

          if( rlPartialMatch(strText, str, len) )
          {
            A.insert(str);
          }
        }
        break;

      case CmdArgDef::ArgTypeBoolean:
        for(j = 0; FalseHood[j] != NULL; ++j)
        {
          if( rlPartialMatch(strText, FalseHood[j], len) )
          {
            // bit of hack. don't want 'false' and 'f' in TAB complition list
            if( FalseHood[j] != "f" )
            {
              A.insert(FalseHood[j]);
            }
          }
        }
        for(j = 0; TruthHood[j] != NULL; ++j)
        {
          if( rlPartialMatch(strText, TruthHood[j], len) )
          {
            // bit of hack. don't want 'true' and 't' in TAB complition list
            if( TruthHood[j] != "t" )
            {
              A.insert(TruthHood[j]);
            }
          }
        }
        break;

      // Argument types not posible to TAB complete, provide syntax if no text.
      case CmdArgDef::ArgTypeWord:
      case CmdArgDef::ArgTypeMultiWord:
      case CmdArgDef::ArgTypeIdentifier:
      case CmdArgDef::ArgTypeInteger:
      case CmdArgDef::ArgTypeFpn:
      case CmdArgDef::ArgTypeRegEx:
        if( len == 0 )
        {
          A.insert(argdefs[i]->constructSyntax());
          uFlags |= ReadLine::FlagTabNoDefault;
        }
        break;

      // Filename argument type, allow filename completion.
      case CmdArgDef::ArgTypeFile:
        uFlags &= ~ReadLine::FlagTabNoFilename;
        break;

      // Unknown.
      case CmdArgDef::ArgTypeUndef:
      default:
        break;
    }
  } 

  //
  // Find the greatest common prefix substring.
  //
  if( !(uFlags & ReadLine::FlagTabNoDefault) && (A.size() > 1) )
  {
    jter = A.begin();
    iter = jter++;

    size_t  min = iter->size();

    for(; (jter != A.end()) && (min > 0); ++iter, ++jter)
    {
      j = gcss(*iter, *jter);

      if( j < min )
      {
        min = j;
      }
    }

    // Common substring is longer than text. This is the only default TAB entry.
    if( min > len )
    {
      str = *A.begin();
      A.clear();
      A.insert(str.substr(0, min));
      uFlags |= ReadLine::FlagTabNoSpace;
    }
  }

  //
  // Copy set to vector list
  //
  for(iter = A.begin(); iter != A.end(); ++iter)
  {
    tabList.push_back(*iter);
  }

  // Disable default if multiple unique matches.
  if( tabList.size() > 1 )
  {
    uFlags |= ReadLine::FlagTabNoDefault;
  }
}

void rnr::cmd::CommandLine::setBtEnable ( bool  bEnable )

inline

Enable/disable backtracing.

Parameters

bEnable

Enable(true) or Disable(false).

Definition at line 510 of file CommandLine.h.

References rnr::cmd::DataSectNsCore.

Referenced by rnr::cmd::addons::execBtEnable().

      {
        ((DataSectCore*)m_dataSects.at(DataSectNsCore).data())->m_bBacktrace =
          bEnable;
      }

void rnr::cmd::CommandLine::setLineNum ( const size_t  uLineNum )

inline

Set the current line number.

Parameters

Line

number.

Definition at line 863 of file CommandLine.h.

      {
        m_readline.setLineNum(uLineNum);
      }

virtual ssize_t rnr::cmd::CommandLine::tokenizeInput ( const std::string &  strInput, TokenVec &  tokens  )

virtual

Lexically analyze input string to generate a series of tokens.

Tokens are separated by whitespace.

Each tokens is either:

• A contiguous sequence of non-whitespace characters.
• An escapable sequence of characters delineated by double quotes '"'.

<token-list>    ::= <token>
                  | <token-list> <token>

<token>         ::= <word>
                  | <quoted-string>

<word>          ::= {NONWHITE_CHAR}+

<qouted-string> ::= '"' {ESCAPABLE_CHAR}* '"'

Parameters

[in]	strInput	Input string to analyze.
[out]	tokens	Generated tokens.

Returns

On success, returns size (count). On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Referenced by backtrace(), processInput(), and rlArgDefs().

virtual ssize_t rnr::cmd::CommandLine::tokenizeInput ( const std::string &  strInput, str::StringVec &  tokens  )

virtual

Lexically analyze input string to generate a series of string tokens.

See tokenize()

Parameters

[in]	strInput	Input string to analyze.
[out]	tokens	Generated string tokens.

Returns

On success, returns size (count). On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

ssize_t CommandLine::tokenizeSyntax ( const std::string &  strSyntax, TokenVec &  tokens  )

protectedvirtual

Lexically analyze extened usage syntax string to generate a series of tokens.

Tokens are separated by either whitespace, parenthetical blocks, or syntax special characters.

Parameters

[in]	strSyntax	Syntax string to analyze.
[out]	tokens	Generated tokens.

Returns

On success, returns size (count). On error, a CommandLine error code (< 0) is returned. See getErroStr() and backtrace() to retrieve or print error(s).

Definition at line 2042 of file CommandLine.cxx.

References rnr::cmd::isoparen(), rnr::cmd::isspecial(), lexSyntaxParenExpr(), lexSyntaxWord(), and pushToken().

Referenced by compile().

{
  size_t    len;      // length of syntax string
  ssize_t   cursor;   // cursor character position along syntax string
  size_t    start;    // start character position of token in syntax string

  CL_DBG_CALL_IN("\"" << strSyntax << "\", tokens", endl);

  tokens.clear();

  len = strSyntax.length();

  for(cursor = 0; (cursor >= 0) && (cursor < len); )
  {
    // find start of the next token
    while( (cursor < len) && isspace((int)strSyntax[cursor]) )
    {
      ++cursor;
    }

    // no more tokens
    if( cursor >= len ) 
    {
      break;
    }

    // new parenthetical expression
    if( isoparen(strSyntax[cursor]) )
    {
      cursor = lexSyntaxParenExpr(strSyntax, cursor, tokens);
    }

    //  special character token
    else if( isspecial(strSyntax[cursor]) )
    {
      start = cursor++;
      pushToken(strSyntax, start, cursor, tokens);
    }

    // new contiguous word token
    else
    {
      cursor = lexSyntaxWord(strSyntax, cursor, tokens);
    }
  }

#ifdef CL_ENABLE_DEBUG
  {
    stringstream ss;
    string       sep;
    for(size_t i = 0; i < tokens.size(); ++i)
    {
      ss << sep << tokens[i];
      sep = ", ";
    }
    CL_DBG_CALL_OUT_NL(ss.str());
  }
#endif // CL_ENABLE_DEBUG

  return cursor >= 0? (ssize_t)tokens.size(): cursor;
}

bool CommandLine::tokEq ( const std::string  strCmp, const TokenVec &  tokens, size_t &  pos  )

protected

Test if token at position is equal to string.

If equal, the position cursor is advanced on position. If not equal, an error message will be logged.

Parameters

[in]	strCmp	String to compare token against.
[in]	tokens	Lexical tokens generated from the syntax usage.
[in,out]	pos	The position in the token vector. Advanced 1 position if equal.

Returns

Returns true on equal, false otherwise.

Definition at line 3109 of file CommandLine.cxx.

References rnr::eoe(), getErrorStr(), LOGERROR_STREAM, m_log, and rnr::str::okstr().

Referenced by parseOptionalArgList(), parseVariableArg(), parseVarMod(), parseXorList(), and parseXorListArg().

{
  bool  bOk;

  CL_DBG_CALL_IN("input, strcmp=\"" << strCmp << "\", "
      << "tokens, pos=" << pos, " ");

  if( pos >= tokens.size() )
  {
    m_log << labelSyntax << "Token " << pos << " '" << strCmp
          << "' does not exist." << eoe;
    LOGERROR_STREAM(getErrorStr());
    bOk = false;
  }

  else if( tokens[pos].value() != strCmp )
  {
    m_log << labelSyntax << "Expected token '" << strCmp << "'"
          << ", but found " << tokens[pos]
          << eoe;
    LOGERROR_STREAM(getErrorStr());
    bOk = false;
  }

  else
  {
    ++pos;
    bOk = true;
  }

  CL_DBG_CALL_OUT_IL(okstr(bOk) << ", pos=" << pos);

  return bOk;
}

bool CommandLine::tokIdentifier ( const TokenVec &  tokens, size_t &  pos  )

protected

Test if string has valid identifier syntax.

Parameters

[in]	tokens	Lexical tokens generated from the syntax usage.
[in,out]	pos	The position in the token vector. Advanced 1 position if valid identifier.

Returns

Returns true or false.

Definition at line 3146 of file CommandLine.cxx.

References rnr::eoe(), getErrorStr(), rnr::cmd::isIdentifier(), LOGERROR_STREAM, m_log, and rnr::str::okstr().

Referenced by parseIdentifier().

{
  bool    bOk;

  CL_DBG_CALL_IN("tokens=" << tokens.size() << ", pos=" << pos, " ");

  bOk = isIdentifier(tokens[pos].value());

  if( bOk )
  {
    ++pos;
  }
  else
  {
    m_log << labelSyntax << "Invalid identifier " << tokens[pos] << eoe;
    LOGERROR_STREAM(getErrorStr());
  }

  CL_DBG_CALL_OUT_IL(okstr(bOk) << ", pos=" << pos);

  return bOk;
}

void CommandLine::toVec ( const CmdExtArgVec &  v1, str::StringVec &  v2  )

protected

Convert extended argument vector to string argument vector.

Parameters

[in]	v1	Extended argument vector.
[out]	v2	String argument vector.

Definition at line 1529 of file CommandLine.cxx.

Referenced by addToHistory(), and readCommand().

{
  for(size_t i = 0; i < v1.size(); ++i)
  {
    v2.push_back(v1[i].arg());
  }
}

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os, const CommandLine &  cl  )

friend

Insert object into output stream.

Parameters

os	Output stream.
cl	Object to insert.

Returns

Reference to output stream.

---

The documentation for this class was generated from the following files:

• include/rnr/appkit/CommandLine.h
• sw/librnr_appkit/CommandLine.cxx