rnr::cmd::ReadLine Class Reference

ReadLine class provides a C++ wrapper around the readline C library. More...

#include <ReadLine.h>

Public Types
enum	RlFlags {   FlagTabNoMods = 0x0000,   FlagTabNoDefault = 0x0001,   FlagTabNoFilename = 0x0002,   FlagTabNoSpace = 0x0004 }
	ReadLine flag modifiers. More...
typedef char *(*	AppGenFunc) (void *pAppArg, const std::string &strText, int nState, const std::string &strContext)
	Application-specific TAB completion generator function type. More...
typedef const std::string(*	AltAppGenFunc) (void *pAppArg, const std::string &strText, int nIndex, const std::string &strContext, int nStart, int nEnd, unsigned &uFlags)
	Alternative application-specific TAB completion generator function type. More...

Public Member Functions
	ReadLine (const std::string strName="", const std::string strPrompt="> ", bool bUseRlLib=true)
	Default initialization constructor. More...
virtual	~ReadLine ()
	Destructor.
void	registerGenerator (AppGenFunc fnAppGen, void *pAppArg)
	Register application-specific tab-completion generator. More...
void	registerAltGenerator (AltAppGenFunc fnAltAppGen, void *pAppArg)
	Register alternate application-specific tab-completion generator. More...
void	unregisterGenerator ()
	Unregister application-specific generator associated with path.
std::string &	rlreadLine ()
	Interactively read a line of input from standard input (stdin). More...
std::string &	ireadLine ()
	Interactively read a line of input from standard input (stdin). More...
std::string &	ireadLine (FILE *fp)
	Interactively read a line of input from an input stream. More...
std::string &	freadLine (FILE *fp)
	Read one input line from the given input stream. More...
void	addToHistory (const std::string &strLine)
const std::string &	getName () const
	Get this instance of readline name.
bool	haveRlLib () const
	Test if have readline library. More...
bool	useRlLib () const
	Test if the readline library is enabled. More...
bool	isInteractive (FILE *fp)
	Test if input file pointer is interactive. More...
void	setPrompt (const std::string &strPrompt)
	Set the prompt string. More...
const std::string &	getPrompt () const
	Get the current prompt string. More...
const std::string &	getLastRead () const
	Get last read line. 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.
bool	isEoF () const
	Test if the last read operation resulted in an end-of-file condition. More...
bool	isFError () const
	Test if the last read operation resulted in an I/O error condition. More...
const std::string &	getErrorStr () const
	Get the most recently set error string. More...
size_t	tokenize (char *s, char *tokv[], size_t tokmax)
	In-place string tokenizer. More...

Static Public Member Functions
static char *	filenameCompletionGenerator (const char *sText, int nState)
	Filename TAB completion generator. More...
static char *	usernameCompletionGenerator (const char *sText, int nState)
	Username TAB completion generator. More...
static char *	dupstr (const std::string &str)
	Duplicate string. More...
static char *	dupstr (const char *s)
	Duplicate string. More...
static size_t	tokenize (const std::string &str, str::StringVec &tokens)
	Tokenize the given string. More...
static int	wc (const std::string &str)
	Count the words in the string. More...
static int	wc (const char *s)
	Count the words in the string. More...

Static Public Attributes
static const int	FIRST = 0
	first state

Protected Member Functions
char **	completion (const char *sText, int nStart, int nEnd)
	Command completion callback function. More...
char **	altCompletion (const std::string strText, int nStart, int nEnd)
	Command completion callback function. More...
void	setStreamStatus (FILE *fp)
	Set stream status for the last read operation. More...
void	clearStreamStatus ()
	Clear stream status prior to next read operation.

Static Protected Member Functions
static char **	completionWrapper (const char *sText, int nStart, int nEnd)
	Command completion callback function wrapper. More...
static char *	generatorWrapper (const char *sText, int nState)
	Generator wrapper. More...

Protected Attributes
std::string	m_strName
	readline name
std::string	m_strPrompt
	prompt string
bool	m_bUseRlLib
	[do not] use readline library
std::string	m_strLine
	last read line
size_t	m_uLineNum
	line number
bool	m_bEoF
	last file op end of file condition
bool	m_bFError
	last file op file error condition
std::string	m_strError
	error string
AppGenFunc	m_fnAppGen
	application-specific generator
AltAppGenFunc	m_fnAltAppGen
	alternate app-specific generator
void *	m_pAppArg
	application-specific argument

Static Protected Attributes
static ReadLine *	ThisObj = NULL
	static pointer to this single instance More...

Detailed Description

ReadLine class provides a C++ wrapper around the readline C library.

Features:

• line input processing
• tab completion
• history

If libreadline is not available, then only simple line input processing is available.

Definition at line 112 of file ReadLine.h.

Member Typedef Documentation

typedef const std::string(* rnr::cmd::ReadLine::AltAppGenFunc) (void *pAppArg, const std::string &strText, int nIndex, const std::string &strContext, int nStart, int nEnd, unsigned &uFlags)

Alternative application-specific TAB completion generator function type.

This is a somewhat more powerful TAB completion function that remains entirely in C++. The calling function is ReadLine::completion() which, in turn, is called by the readline library through the set rl_attempted_completion_function variable.

The generator is called multiple times on a TAB completion event. On the first call, nIndex is equal to 0. Subsequent calls, nIndex is incremented by one. The function may safely use this index to sequence through any application-specific data.

Return Values:

1. match: Any non-empty, non-whitespace string.
2. empty: An empty string "" terminates TAB completion generation. RlTabEnd is equivalent to the empty string.

Tab Modifier Flags:

• FlagTabNoDefault: If this flag is set at index 0 and a match is returned, then a "no default" readline library value will be set. Otherwise the this first match is the default.
• FlagTabNoFilename: If this flag is set at the end of TAB completion (an empty string is returned), then readline library default filename completion action is disabled. (See rl_attempted_completion_over.) The readline library default action is only invoked if no strings are generated.

Flags only apply to the current TAB completion event and are reset to defaults there after.

ReadLine Support Methods: See AppGenFunc.

Parameters

	pAppArg	Generator function argument.
	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 211 of file ReadLine.h.

typedef char*(* rnr::cmd::ReadLine::AppGenFunc) (void *pAppArg, const std::string &strText, int nState, const std::string &strContext)

Application-specific TAB completion generator function type.

The generator is called multiple times on a TAB completion event. The call is made through the readline library rl_completion_matches() C function. On the first call, nState equals ReadLine::FIRST. This allows for any necessary initaliazation of (static) application specific state variables. On subsequent calls, nState > 0.

For each matched candidate, a malloc'd string must be returned. The readline library automatically frees the memory allocation after use.

When all candidates are exhausted, return NULL to signal no more matches to the readline library calling function.

ReadLine Support Methods:

• ReadLine::dupstr() - string allocation.
• ReadLine::tokenize() - simple, whitespace token generator.
• ReadLine::wc() count whitespace separated words.

Parameters

pAppArg	Generator function argument.
strText	Partial text string to complete.
nState	Generator state. If FIRST(0), initialize any state statics.
strContext	Generator context (i.e. stripped input buffer).

Returns

If a first/next match is made, return allocated completed match.
Otherwise return NULL.

Definition at line 158 of file ReadLine.h.

Member Enumeration Documentation

enum rnr::cmd::ReadLine::RlFlags

ReadLine flag modifiers.

Enumerator
FlagTabNoMods	no TAB modifiers
FlagTabNoDefault	no default TAB completion match
FlagTabNoFilename	no filename TAB completion attempt
FlagTabNoSpace	no space(' ') after TAB completion

Definition at line 120 of file ReadLine.h.

      {
        FlagTabNoMods     = 0x0000, ///< no TAB modifiers
        FlagTabNoDefault  = 0x0001, ///< no default TAB completion match
        FlagTabNoFilename = 0x0002, ///< no filename TAB completion attempt
        FlagTabNoSpace    = 0x0004  ///< no space(' ') after TAB completion
      };

Constructor & Destructor Documentation

ReadLine::ReadLine	(	const std::string	strName = "",
		const std::string	strPrompt = "> ",
		bool	bUseRlLib = true
	)

Default initialization constructor.

Parameters

strName	Name of readline. Used to allow for 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 the input is interactive. Otherwise a simple command-line interface will be used.

Definition at line 111 of file ReadLine.cxx.

References completionWrapper(), m_bEoF, m_bFError, m_fnAltAppGen, m_fnAppGen, m_pAppArg, m_strName, m_uLineNum, and ThisObj.

                                           :
    m_strName(strName), m_strPrompt(strPrompt), m_bUseRlLib(bUseRlLib)
{
  m_uLineNum    = 0;
  m_bEoF        = false;
  m_bFError     = false;
  m_fnAppGen    = NULL;
  m_fnAltAppGen = NULL;
  m_pAppArg     = NULL;

#ifdef HAVE_READLINE
  //
  // Only one instance of this class can be instantiated since:
  //  1. The readline library provides no user argument(s) for callbacks to use.
  //  2. And more importantly, readline library uses global variables.
  //
  assert(ThisObj == NULL);

  // limitation of readline library which does not provide context feedback
  ThisObj = this;

  // tell readline completer that we want a crack at it first before default
  rl_attempted_completion_function = ReadLine::completionWrapper;

  // allow conditional parsing of the ~/.inputrc file
  rl_readline_name = m_strName.c_str();

#endif // HAVE_READLINE
}

Member Function Documentation

char ** ReadLine::altCompletion ( const std::string  strText, int  nStart, int  nEnd  )

protected

Command completion callback function.

If an alternative application-specific generator is registered, this method is used to provide the requisite C++ interface.

Attempt to complete on the contents of text. The start and end bound the region of rl_line_buffer that contains the word to complete. Text is the word to complete. We can use the entire contents of rl_line_buffer to provide context.

This method also provides the indexing for the registered generator.

Parameters

sText	Text string to complete as a command.
nStart	Start index of text string in line.
nEnd	End index of text string in line.

Returns

Array of matches, NULL if none.

Definition at line 493 of file ReadLine.cxx.

References dupstr(), FlagTabNoDefault, FlagTabNoFilename, FlagTabNoSpace, m_fnAltAppGen, and m_pAppArg.

Referenced by completion().

{
#ifdef HAVE_READLINE
  string          strContext(rl_line_buffer);
  int             nIndex;
  unsigned        uFlags;
  string          strMatch;
  vector<string>  matchList;
  size_t          i;
  char            **tabList;

  rl_attempted_completion_over  = 0;  // disable default filename TAB completion
  rl_completion_suppress_append = 0;  // enable default space (' ') after match

  // no flags
  uFlags = 0;

  for(nIndex = 0; ; ++nIndex)
  {
    strMatch = m_fnAltAppGen(m_pAppArg, strText, nIndex,
                             strContext, nStart, nEnd, uFlags);

    // end of completion generation
    if( strMatch.empty() )
    {
      if( uFlags & FlagTabNoFilename )
      {
        rl_attempted_completion_over = 1;
      }

      if( uFlags & FlagTabNoSpace )
      {
        rl_completion_suppress_append = 1;
      }
      break;
    }

    // regular completion
    else
    {
      // Empty string disables default. Undocumented.
      if( (nIndex == 0) && (uFlags & FlagTabNoDefault) )
      {
        matchList.push_back("");
      }
      matchList.push_back(strMatch);
    }
  }

  // no matches
  if( matchList.size() == 0 )
  {
    return NULL;
  }

  //
  // Malloc a tap-completion array.
  //
  // Note:  The readlline library frees all entries in this array along with
  //        the array itself. Undocumented.
  //
  i = sizeof(char*) * (matchList.size() + 1);

  tabList = (char**)malloc(i);

  // copy allocated char *'s
  for(i = 0; i < matchList.size(); ++i)
  {
    tabList[i] = dupstr(matchList[i]);
  }
  tabList[i] = NULL;

  return tabList;

#else // !HAVE_READLINE

  return NULL;

#endif // HAVE_READLINE
}

char ** ReadLine::completion ( const char *  sText, int  nStart, int  nEnd  )

protected

Command completion callback function.

Attempt to complete on the contents of text. The start and end bound the region of rl_line_buffer that contains the word to complete. Text is the word to complete. We can use the entire contents of rl_line_buffer to provide context.

Parameters

sText	Text string to complete as a command.
nStart	Start index of text string in line.
nEnd	End index of text string in line.

Returns

Array of matches, NULL if none.

Definition at line 476 of file ReadLine.cxx.

References altCompletion(), generatorWrapper(), and m_fnAltAppGen.

Referenced by completionWrapper().

{
#ifdef HAVE_READLINE
  if( m_fnAltAppGen != NULL )
  {
    return altCompletion(sText, nStart, nEnd);
  }
  else
  {
    return rl_completion_matches(sText, generatorWrapper);
  }

#else
  return NULL;
#endif // HAVE_READLINE
}

char ** ReadLine::completionWrapper ( const char *  sText, int  nStart, int  nEnd  )

staticprotected

Command completion callback function wrapper.

Wraps method ReadLine::completion().

Parameters

sText	Text string to complete as a command.
nStart	Start index of text string in line.
nEnd	End index of text string in line.

Returns

Array of matches, NULL if none.

Definition at line 471 of file ReadLine.cxx.

References completion(), and ThisObj.

Referenced by ReadLine().

{
  return ThisObj->completion(sText, nStart, nEnd);
}

static char* rnr::cmd::ReadLine::dupstr ( const std::string &  str )

inlinestatic

Duplicate string.

The readline library requires allocated char*'s.

Parameters

str	String to dup.

Returns

Duplicated, allocated char*.

Definition at line 556 of file ReadLine.h.

References tokenize().

Referenced by altCompletion().

      {
        return ReadLine::dupstr(str.c_str());
      }

char * ReadLine::dupstr ( const char *  s )

static

Duplicate string.

The readline library requires allocated char*'s.

Parameters

s	Null-terminated string to dup.

Returns

Duplicated, allocated char *.

Definition at line 356 of file ReadLine.cxx.

References tokenize().

{
  size_t  size = sizeof(char) * (strlen(s) + 1);
  char *t = (char *)malloc(size);
  strcpy(t, s);
  return t;
}

static char* rnr::cmd::ReadLine::filenameCompletionGenerator ( const char *  sText, int  nState  )

inlinestatic

Filename TAB completion generator.

A completion generator for filenames.

Parameters

sText	Partial text string to complete.
nState	Generator state. If FIRST,then initialize any statics.

Returns

If a first/next match is made, return allocated completed match.
Otherwise return NULL.

Definition at line 512 of file ReadLine.h.

      {
    #ifdef HAVE_READLINE
        return rl_filename_completion_function(sText, nState);
    #else // !HAVE_READLINE
        return NULL;
    #endif // HAVE_READLINE
      }

string & ReadLine::freadLine

(

FILE *

fp

)

Read one input line from the given input stream.

The input stream may be attached to a terminal, pipe, or file. No prompting will occur.

Parameters

fp	Input file stream pointer.

Returns

Returns the string of the line read, stripped of leading and trailing whitespace. If the string is empty, then one of:

• The line was all whitespace.
• EOF was reached. Use isEoF() to test this condition.
• A file read error occurred. Use isFError() to test this conition.

Definition at line 239 of file ReadLine.cxx.

References clearStreamStatus(), m_strLine, m_uLineNum, setStreamStatus(), and rnr::str::trim().

Referenced by ireadLine(), and rlreadLine().

{
  static size_t   BufSize = 4096;

  char    bufLine[BufSize];
  size_t  n;

  clearStreamStatus();
  m_strLine.clear();

  if( fgets(bufLine, BufSize, fp) != NULL )
  {
    bufLine[BufSize-1] = 0;
    n = strlen(bufLine);

    // some characters were read
    if( n > 0 )
    {
      // got end of line
      if( bufLine[n-1] == '\n' )
      {
        bufLine[n-1] = 0;
        ++m_uLineNum;
      }

      // oops, input line trunctated - too long
      else
      {
        bufLine[n-1] = 0;
        ++m_uLineNum;
        LOGWARN("Input line too long. Exceeds %zu characters.", BufSize);
      }
    }

    // no i/o errors but also no characters read - odd
    else
    {
      setStreamStatus(fp);

      bufLine[0] = 0;
    }
  }

  // read failure
  else
  {
    setStreamStatus(fp);

    bufLine[0] = 0;
  }

  m_strLine = bufLine;

  trim(m_strLine);

  return m_strLine;
}

char * ReadLine::generatorWrapper ( const char *  sText, int  nState  )

staticprotected

Generator wrapper.

Calls the registered application-specific generator.

Parameters

sText	Partial text string to complete.
nState	Generator state. If FIRST,then initialize any statics.

Returns

If a first/next match is made, return allocated completed match.
Otherwise return NULL.

Definition at line 574 of file ReadLine.cxx.

References FIRST, m_fnAppGen, m_pAppArg, ThisObj, and rnr::str::trim().

Referenced by completion().

{
#ifdef HAVE_READLINE
  // no registered generator match current path
  if( ThisObj->m_fnAppGen == NULL )
  {
    return NULL;
  }

  string strText(sText);
  string strContext(rl_line_buffer);

  // trim left and right whitespace
  trim(strContext);

  // first time through
  if( nState == ReadLine::FIRST )
  {
  }

  // call application-specific generator
  return ThisObj->m_fnAppGen(ThisObj->m_pAppArg, strText, nState, strContext);

#else // !HAVE_READLINE

  return NULL;

#endif // HAVE_READLINE
}

const string & ReadLine::getErrorStr

(

)

const

Get the most recently set error string.

Returns

Error string.

Definition at line 322 of file ReadLine.cxx.

References m_strError.

Referenced by rnr::cmd::CommandLine::checkReadResult(), and isFError().

{
  return m_strError;
}

const std::string& rnr::cmd::ReadLine::getLastRead ( ) const

inline

Get last read line.

Returns

String.

Definition at line 433 of file ReadLine.h.

References m_strLine.

      {
        return m_strLine;
      }

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

inline

Get the line number of the last read line.

Returns

Line number.

Definition at line 443 of file ReadLine.h.

References m_uLineNum.

      {
        return m_uLineNum;
      }

const std::string& rnr::cmd::ReadLine::getPrompt ( ) const

inline

Get the current prompt string.

Returns

String.

Definition at line 423 of file ReadLine.h.

References m_strPrompt.

Referenced by ireadLine(), and rlreadLine().

      {
        return m_strPrompt;
      }

bool rnr::cmd::ReadLine::haveRlLib ( ) const

inline

Test if have readline library.

Returns

Returns true or false.

Definition at line 379 of file ReadLine.h.

Referenced by rnr::cmd::CommandLine::c14n().

      {
#ifdef HAVE_READLINE
        return true;
#else // !HAVE_READLINE
        return false;
#endif // HAVE_READLINE
      }

std::string& rnr::cmd::ReadLine::ireadLine ( )

inline

Interactively read a line of input from standard input (stdin).

The readline library is not used.

If in interactive mode, the user will be prompted with the currently set prompt string. Any prompt is written to standard output (stdout).

Note

The rlreadLine() call is the preferred method since it automatically determines the best underlining function/method to call.

Returns

Returns the string of the line read, stripped of leading and trailing whitespace. If the string is empty, then one of:

• The line was all whitespace.
• EOF was reached. Use isEoF() to test this condition.
• A file read error occurred. Use isFError() to test this conition.

Definition at line 313 of file ReadLine.h.

References freadLine().

Referenced by rnr::cmd::CommandLine::readCommand(), and rlreadLine().

      {
        return ireadLine(stdin);
      }

string & ReadLine::ireadLine

(

FILE *

fp

)

Interactively read a line of input from an input stream.

The readline library is not used.

If in interactive mode, the user will be prompted with the currently set prompt string. Any prompt is written to standard output (stdout).

Parameters

fp	Input file stream pointer.

Returns

Returns the string of the line read, stripped of leading and trailing whitespace. If the string is empty, then one of:

• The line was all whitespace.
• EOF was reached. Use isEoF() to test this condition.
• A file read error occurred. Use isFError() to test this conition.

Definition at line 227 of file ReadLine.cxx.

References freadLine(), getPrompt(), and isInteractive().

{
  // prompt
  if( isInteractive(fp) && !getPrompt().empty() )
  {
    fprintf(stdout, "%s", getPrompt().c_str());
    fflush(stdout);
  }

  return freadLine(fp);
}

bool rnr::cmd::ReadLine::isEoF ( ) const

inline

Test if the last read operation resulted in an end-of-file condition.

Returns

Returns true or false.

Definition at line 472 of file ReadLine.h.

References m_bEoF.

Referenced by rnr::cmd::CommandLine::checkReadResult().

      {
        return m_bEoF;
      }

bool rnr::cmd::ReadLine::isFError ( ) const

inline

Test if the last read operation resulted in an I/O error condition.

Returns

Returns true or false.

Definition at line 483 of file ReadLine.h.

References getErrorStr(), and m_bFError.

Referenced by rnr::cmd::CommandLine::checkReadResult().

      {
        return m_bFError;
      }

bool ReadLine::isInteractive

(

FILE *

fp

)

Test if input file pointer is interactive.

A file input stream is interactive if it is bound to a terminal or tty.

Returns

Returns true or false.

Definition at line 317 of file ReadLine.cxx.

Referenced by ireadLine(), rlreadLine(), and useRlLib().

{
  return isatty(fileno(fp))? true: false;
}

void ReadLine::registerAltGenerator	(	AltAppGenFunc	fnAltAppGen,
		void *	pAppArg
	)

Register alternate application-specific tab-completion generator.

The registered function will be called through the ReadLine::completion C++ method.

Parameters

fnAltAppGen	Alt application-specific generator function.
pAppArg	Optional application argument generator function.

Definition at line 155 of file ReadLine.cxx.

References m_fnAltAppGen, m_fnAppGen, and m_pAppArg.

Referenced by rnr::cmd::CommandLine::compile().

{
  m_fnAppGen    = NULL;
  m_fnAltAppGen = fnAltAppGen;
  m_pAppArg     = pAppArg;
}

void ReadLine::registerGenerator	(	AppGenFunc	fnAppGen,
		void *	pAppArg
	)

Register application-specific tab-completion generator.

The registered function will be called through the readline library rl_completion_matches() C function.

Parameters

fnAppGen	Application-specific generator function.
pAppArg	Optional application argument generator function.

Definition at line 148 of file ReadLine.cxx.

References m_fnAltAppGen, m_fnAppGen, and m_pAppArg.

{
  m_fnAppGen    = fnAppGen;
  m_fnAltAppGen = NULL;
  m_pAppArg     = pAppArg;
}

string & ReadLine::rlreadLine

(

)

Interactively read a line of input from standard input (stdin).

The readline library function readline() will be called iff:

• The readline library is available (HAVE_READLINE).
• The application enabled the ReadLine instance to use the readline.
• library (bUseRlLib).
• The input stdin is interactive (i.e. bound to a terminal or tty).

Otherwise, ireadLine() is used.

The readline() library call enables TAB completion, line editing, and history recording/recall.

If in interactive mode, the user will be prompted with the current prompt string. Any prompt is written to standard output (stdout).

Returns

Returns the string of the line read, stripped of leading and trailing whitespace. If the string is empty, then one of:

• The line was all whitespace.
• EOF was reached. Use isEoF() to test this condition.
• A file read error occurred. Use isFError() to test this conition.

Definition at line 174 of file ReadLine.cxx.

References clearStreamStatus(), freadLine(), getPrompt(), ireadLine(), isInteractive(), m_bUseRlLib, m_strLine, m_uLineNum, and setStreamStatus().

Referenced by rnr::cmd::CommandLine::readCommand().

{
#ifdef HAVE_READLINE
  bool  bInteractive = isInteractive(stdin);

  // 
  // Use readline library.
  //
  if( m_bUseRlLib  && bInteractive )
  {
    clearStreamStatus();
    m_strLine.clear();

    char *sLine = readline(getPrompt().c_str());   // fixed at stdin

    if( sLine != NULL )
    {
      m_strLine = sLine;
      free(sLine);
      ++m_uLineNum;
    }

    else
    {
      setStreamStatus(stdin);
    }

    return m_strLine;
  }

  //
  // Interactive, but don't use the readline library.
  //
  else if( bInteractive )
  {
    return ireadLine(stdin);
  }

  //
  // Non-interactive.
  //
  else
  {
    return freadLine(stdin);
  }

#else // !HAVE_READLINE

  return ireadLine(stdin);

#endif // HAVE_READLINE
}

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

inline

Set the current line number.

Parameters

Line

number.

Definition at line 453 of file ReadLine.h.

References m_uLineNum.

      {
        m_uLineNum = uLineNum;
      }

void rnr::cmd::ReadLine::setPrompt ( const std::string &  strPrompt )

inline

Set the prompt string.

Parameters

strPrompt

New prompt string.

Definition at line 413 of file ReadLine.h.

References m_strPrompt.

Referenced by rnr::cmd::CommandLine::popPrompt(), and rnr::cmd::CommandLine::pushPrompt().

      {
        m_strPrompt = strPrompt;
      }

void ReadLine::setStreamStatus ( FILE *  fp )

protected

Set stream status for the last read operation.

Parameters

fp	Input file pointer.

Definition at line 327 of file ReadLine.cxx.

References m_bEoF, m_bFError, and m_strError.

Referenced by freadLine(), and rlreadLine().

{
  m_bEoF    = feof(fp)?   true: false;
  m_bFError = ferror(fp)? true: false;

  if( m_bFError )
  {
    stringstream ss;

    if( errno > 0 )
    {
      ss << strerror(errno) << "(errno=" << errno << "}";
    }
    else
    {
      ss << "File read error.";
    }

    m_strError = ss.str();
  }
}

static size_t rnr::cmd::ReadLine::tokenize ( const std::string &  str, str::StringVec &  tokens  )

static

Tokenize the given string.

Tokens are contiguous non-whitespace character sequences, separated by either the start-of-string, whitespace, or the end-of-string.

Parameters

[in]	str	Input string to generate tokens.
[out]	tokens	Vector of tokens.

Returns

Number of tokens.

Referenced by dupstr().

size_t ReadLine::tokenize	(	char *	s,
		char *	tokv[],
		size_t	tokmax
	)

In-place string tokenizer.

Tokens are contiguous non-whitespace character sequences, separated by either the start-of-string, whitespace, or the end-of-string.

The '\0' character is inserted at the end of each detected word in s. No memory allocation is used.

Parameters

[in,out]	s	Input/output null-terminated string to tokenize.
[out]	tokv	Array of tokens (pointer to locations in s).
[in]	tokmax	Maximum number of tokens.

Returns

Number of tokens.

Definition at line 401 of file ReadLine.cxx.

{
  int       tokc = 0;

  while( tokc < (int)tokmax )
  {
    // find start of the next token
    while( *s && isspace((int)*s) )
    {
      s++;
    }

    // no more tokens
    if( *s == 0 )
    {
      return tokc;
    }

    // new token
    tokv[tokc++] = s;

    // find end of the token
    while( *s && !isspace((int)*s) )
    {
      s++;
    }

    // end of the line
    if( *s == 0 )
    {
      return tokc;
    }

    // null terminate
    *s++ = 0;
  }

  return (size_t)tokc;
}

bool rnr::cmd::ReadLine::useRlLib ( ) const

inline

Test if the readline library is enabled.

Returns

Returns true or false.

Definition at line 393 of file ReadLine.h.

References isInteractive(), and m_bUseRlLib.

Referenced by rnr::cmd::CommandLine::c14n().

      {
        return m_bUseRlLib;
      }

static char* rnr::cmd::ReadLine::usernameCompletionGenerator ( const char *  sText, int  nState  )

inlinestatic

Username TAB completion generator.

A completion generator for usernames.

Parameters

sText	Partial text string to complete.
nState	Generator state. If FIRST,then initialize any statics.

Returns

If a first/next match is made, return allocated completed match.
Otherwise return NULL.

Definition at line 533 of file ReadLine.h.

      {
    #ifdef HAVE_READLINE
        return rl_username_completion_function(sText, nState);
    #else // !HAVE_READLINE
        return NULL;
    #endif // HAVE_READLINE
      }

static int rnr::cmd::ReadLine::wc ( const std::string &  str )

inlinestatic

Count the words in the string.

Parameters

str	String to count.

Returns

Number of words.

Definition at line 609 of file ReadLine.h.

Referenced by wc().

      {
        return ReadLine::wc(str.c_str());
      }

int ReadLine::wc ( const char *  s )

static

Count the words in the string.

Parameters

s	Null-terminated string to count.

Returns

Number of words.

Definition at line 441 of file ReadLine.cxx.

References wc().

{
  int   wc = 0;

  while( *s )
  {
    // find start of the next word
    while( *s && isspace((int)*s) )
    {
      s++;
    }

    // no more words
    if( *s == 0 )
    {
      break;
    }

    ++wc;

    // find end of the word
    while( *s && !isspace((int)*s) )
    {
      s++;
    }
  }

  return wc;
}

Member Data Documentation

ReadLine * ReadLine::ThisObj = NULL

staticprotected

static pointer to this single instance

Pointer to the only instance of ReadLine supported per application.

Definition at line 624 of file ReadLine.h.

Referenced by completionWrapper(), generatorWrapper(), ReadLine(), and ~ReadLine().

---

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

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