StreamParser Class Reference

Read parameters from a text buffer. More...

#include <paramsparser.h>

Inheritance diagram for StreamParser:

Collaboration diagram for StreamParser:

Public Member Functions
	StreamParser (const char *stream)
virtual	~StreamParser ()
virtual bool	read (const char *stream)
virtual bool	readArguments (istream &IN, int &l_count, string &args)
void	replaceCR (string &stream, const char rpl='\n')
Public Member Functions inherited from ParamsParser
	ParamsParser (const char *name)
virtual	~ParamsParser ()
void	setName (const char *name)
map< string, string >	get_inputParams ()
map< string, vector< string > > &	getParsedParameters (const char *stream_name)
map< string, vector< string > > &	getParsedParameters ()
map< string, string > &	getParameters (const char *stream_name)
map< string, string > &	getParameters ()
virtual bool	read (const char *stream)=0
	Read/parse params & args from a file or a string or an R object. More...
void	parse ()
	Builds the _parsedParams from the _inputParams. More...
string	replaceMacro (const string &arg)
	Macros. More...
string	parseMacroFunctionBlock (const string &in_arg)
string	callMacro (const string &name, const string &argstr)
vector< string >	getMacroArgs (const string &args, const int min_arg, const size_t max_arg, const string macro_name, const string syntax, bool lastArgIsSeparatorChar=true)
string	getMacroSepParamChar (const string &sep_in, const string macro_name)
string	getMacroParamValue (const string &str_in, const string &par_name, const string &macro_name)
string	quote (const string &argstr)
	Macro "q" returns a quoted string. More...
string	concat (const string &argstr)
	Macro "c" returns a character-delimited string of atomic arguments. More...
string	rep (const string &argstr)
string	seq (const string &argstr)
string	tempseq (const string &argstr)
string	matrix (const string &argstr)
string	diag_matrix (const string &argstr)
string	sym_matrix (const string &argstr)
string	runif (const string &argstr)
string	rnorm (const string &argstr)
string	rpoiss (const string &argstr)
string	rbernoul (const string &argstr)
string	rgamma (const string &argstr)
string	rlognorm (const string &argstr)
string	rexp (const string &argstr)

Static Public Member Functions
static bool	removeComment (istream &IN, int &l_count)
	Recusively removes comments until the end of a line/of the file, or of a block comment is reached. More...
static bool	removeSpaceAndComment (istream &IN, int &l_count, bool keepLast=false)
	Removes whitespace char on a line until a non-ws or EOL is reached. More...
static string	readUntilCharacter (istream &IN, int &l_count, const char start_c, const char end_c)
static void	eatLine (istream &IN, int &l_count)
Static Public Member Functions inherited from ParamsParser
static void	getBlockArgument (istream &IN, char &c, string &arg)
static void	getArguments (string &arg_str, vector< string > &arg_vect)

Additional Inherited Members
Protected Member Functions inherited from ParamsParser
void	reset_inputParams ()
void	add_inputParam (string &param, const string &arg)

Detailed Description

Read parameters from a text buffer.

Constructor & Destructor Documentation

StreamParser()

StreamParser::StreamParser ( const char *  stream )

inline

: ParamsParser(stream) {}

~StreamParser()

virtual StreamParser::~StreamParser ( )

inlinevirtual

{}

Member Function Documentation

eatLine()

void StreamParser::eatLine ( istream &  IN, int &  l_count  )

static

{
  char c;
  while(IN.get(c) && IN.good() && c != EOL && !IN.eof());
  ++l_count;
}

References EOL.

Referenced by readArguments(), and readUntilCharacter().

Here is the caller graph for this function:

read()

bool StreamParser::read ( const char *  stream )

virtual

Implements ParamsParser.

Reimplemented in FileParser, and BinaryFileParser.

  {
    int linecnt = 0;    
    //output string to collect parameter arguments
    string args;
    //string to store parameter name
    string key;
    
    ParamsParser::reset_inputParams();
    
    //--------------------------------------------------------------------------------
    char c = 0, eof = '\0';
    //put the char stream into a string
    string input_stream(stream);
    //add the terminating character to the string:
    input_stream += eof;
    
    //check if LF 
    if(input_stream.find_first_of('\r') != string::npos) {
      //guess if NL is CRLF as in DOS files:
      if(input_stream.find_first_of('\n') == input_stream.find_first_of('\r') + 1)
        replaceCR(input_stream, ' '); //remove CR
      else
        replaceCR(input_stream); //replaces CR with LF
    }
    
    //initiate the input stringstream:
    istringstream IN(input_stream);
 
    //--------------------------------------------------------------------------------
    //read the file line by line
    while(IN.good() && !IN.eof()) {
      
      linecnt++;
      
      // remove the forgoing space of the line, returns false if EOL is reached
      if(!removeSpaceAndComment(IN, linecnt)) continue;
 
      //--------------------------------------------------------------------------------
      //read the parameter name and record it in 'key':
      
      key="";
      while(IN.get(c) && IN.good() && !IN.eof() && c != EOL && !isspace(c)){
        //whitespace is the split char between a parameter and its argument
        //this basically does the same as IN>>key, but we have to check for comments:
        if(c == '#'){
          removeComment(IN, linecnt);
          break;
        }
        
        key += c;
      } //__end_while_key__
      
      if(c == EOL || !removeSpaceAndComment(IN, linecnt) ) {
        if(c != eof){
          if(key.size() != 0) {//boolean param
            args = "1";
            ParamsParser::add_inputParam(key, args);
          }
#ifdef _DEBUG_
          message("  line %i: %s (1)\n", linecnt, key.c_str());
#endif 
        }
          continue;
      }
                      
#ifdef _DEBUG_
      message("  line %i: %s (", linecnt, key.c_str());
#endif
            
      //--------------------------------------------------------------------------------
      //read the arguments:
      args = "";
      while( readArguments(IN, linecnt, args) );
      
      //remove any trailling space on the argument string
      int i;
      for(i=(int)args.size()-1; i>=0; --i){
        if(!isspace(args[i])) break;
      }
      args[i+1]='\0';
      
      //--------------------------------------------------------------------------------
      // store the key - args pair in the _inputParam table
      ParamsParser::add_inputParam(key, args.c_str());
      
#ifdef _DEBUG_
      message("%s)\n", args.c_str());
#endif
      //reset the stream state, is changed by operator >>
      IN.clear(ios::goodbit);
            
    }//__END__WHILE__
    
    return true;
  }

References ParamsParser::add_inputParam(), EOL, message(), readArguments(), removeComment(), removeSpaceAndComment(), replaceCR(), and ParamsParser::reset_inputParams().

Referenced by FileParser::read(), and BinaryFileParser::read().

Here is the caller graph for this function:

readArguments()

bool StreamParser::readArguments ( istream &  IN, int &  l_count, string &  args  )

virtual

{
  char c;
  
  //read one byte at a time
  while(IN.get(c) && IN.good() && !IN.eof() && c != EOL){
 
    if(c == '\\')
      eatLine(IN, l_count);
    //block delimiters: the block will be parsed in Param
    else if(c == '{')
      args += readUntilCharacter(IN, l_count, c, '}');
    else if(c == '(')
      args += readUntilCharacter(IN, l_count, c, ')');
    else if(c == '[')
      args += readUntilCharacter(IN, l_count, c, ']');
    else if(c == '\"')
      args += readUntilCharacter(IN, l_count, c, '\"');
    //comment delimiter:
    else if(c == '#') {
      if(!removeComment(IN, l_count))
        return false; // reached end of line
 
    //argument in external file
    } else if (c == '&') {
      
      //read the file name
      string file;
 
      while(IN.get(c) && IN.good() && !IN.eof() && !isspace(c)){
 
        if(c=='#'){      // check if a comment is included
          IN.putback(c);                                       // comment
          if(!removeSpaceAndComment(IN, l_count)) break;
        }
        file += c;
      }
 
      if(c==EOL || isspace(c)) IN.putback(c);
 
      //put the file name back into the arg, will be processed later
      args += "&" + file + " ";
 
    } else
      args += c;
    
  }//end while read args
 
  if(c == EOL || IN.eof())  return false;
  
  if(!IN.good())  //this may happen if an external file doesn't end with a \n
    fatal("problem reading input file; line %i appears corrupted, skipping line\n",l_count);
  
  return true; 
}

References eatLine(), EOL, fatal(), readUntilCharacter(), removeComment(), and removeSpaceAndComment().

Referenced by Param::getArgumentFromFile(), and read().

Here is the caller graph for this function:

readUntilCharacter()

string StreamParser::readUntilCharacter ( istream &  IN, int &  l_count, const char  start_c, const char  end_c  )

static

{
  string out;
  char c;
  bool closed = false;
    
  out += start_c;
 
  //cout << "start block : "<<start_c<<endl;
  while (IN.get(c) && IN.good() && !IN.eof() ) {
    
    if(c == EOL) //a block can span several lines
    
      ++l_count;
    
    else if(c == end_c) {
      
      out += c;
      //remove trailing spaces but keep last one, it's the arg seperator
      if(!removeSpaceAndComment(IN, l_count, true)) {
        IN.putback(EOL); //we've reached eol, put it back
      }
      
      closed = true;
      break;
    
    } else if(c == start_c) {//nested blocks
 
      out += readUntilCharacter(IN, l_count, start_c, end_c);
    
    } else if(c == '\\') {//line continuation within a block
      
      eatLine(IN, l_count);
      
    } else if(c == '#') {
    
      if(!removeComment(IN, l_count)) l_count++;
    
    } else out += c;
  } //__end_while__
  
  if(!closed) fatal("missing closing character '%c' on line %i.\n", end_c, l_count);
 
  return out;
}

References eatLine(), EOL, fatal(), readUntilCharacter(), removeComment(), and removeSpaceAndComment().

Referenced by ParamsParser::getBlockArgument(), readArguments(), and readUntilCharacter().

Here is the caller graph for this function:

removeComment()

bool StreamParser::removeComment ( istream &  IN, int &  l_count  )

static

Recusively removes comments until the end of a line/of the file, or of a block comment is reached.

#: commented line (removed until the end of the line is reached) #/ ... /#: a block comment (may span several lines) Consecutive lines of comments are also removed, even if not part of a block comment. Note: this function always returns false, unless something remains on a line after a block comment (i.e. if removeSpaceAndComment() returns true)

{
  char c;
  
  //remember: we enter the loop with c = '#'
  //check if next char is the start of a block comment:
  bool isBlock = (IN.peek() == '/');
  bool prevIsComment = true;
  
  while(IN.get(c) && IN.good() && !IN.eof()){
    
    //break if EOL && next line not a comment, continue otherwise:
    if (c == EOL){
      //check if next line is also a comment, start the loop again:
      if (IN.peek() == '#') {
        
        IN.get(c);
        prevIsComment = true;
        ++l_count;
        continue;
        
      //continue if within a block comment:
      } else if( isBlock ) {
        ++l_count;
        continue;
      //next line not a comment, get out of the loop:
      } else
        return false;
    }
    
    //check if we had the block str '#/' within a commented line
    if (c == '/'){ 
      
      if(IN.peek() == '#') {
        IN.get(c);
        
        if(isBlock)
          //block termination string '/#', remove trailing space
          //note: the string '#/#' is also considered as a terminating string
          return removeSpaceAndComment(IN, l_count);
        
      } else if(prevIsComment) { 
        //we've got '#/', a block comment may start anywhere on a comment line
        isBlock = true;
      }
    }
    
    if(c == '#') prevIsComment = true;
    else prevIsComment = false;
    
  } //__END_WHILE__
  
  return false;
}

References EOL, and removeSpaceAndComment().

Referenced by read(), readArguments(), readUntilCharacter(), and removeSpaceAndComment().

Here is the caller graph for this function:

removeSpaceAndComment()

bool StreamParser::removeSpaceAndComment ( istream &  IN, int &  l_count, bool  keepLast = false  )

static

Removes whitespace char on a line until a non-ws or EOL is reached.

Returns false if EOL or EOF is reached or true otherwise.

{
  char c;
  
  while(IN.get(c) && IN.good() && !IN.eof() && c != EOL) {
        
    if(!isspace(c)){
      
      if(c=='#') return removeComment(IN, l_count); // recursively remove comment
      
      IN.putback(c); //this is a parameter: put the character back
      
      if(keepLast) {
        //get back one char:
        IN.unget();
        IN.get(c); //read it again and check if whitespace:
        if(isspace(c)) IN.putback(c);
      }
      
      return true;
    }
  }
  return false;
}

References EOL, and removeComment().

Referenced by ParamsParser::getArguments(), read(), readArguments(), readUntilCharacter(), and removeComment().

Here is the caller graph for this function:

replaceCR()

void StreamParser::replaceCR	(	string &	stream,
		const char	rpl = '\n'
	)

{
  size_t pos = 0;
  
  while ( (pos = stream.find_first_of('\r', pos)) != string::npos) {
    stream[pos] = rpl;
  }
}

Referenced by read().

Here is the caller graph for this function:

---

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

• paramsparser.h
• paramsparser.cc