exprtk::lexer::generator Class Reference

#include <exprtk.hpp>

Collaboration diagram for exprtk::lexer::generator:

Public Types
typedef token	token_t
typedef std::vector< token_t >	token_list_t
typedef token_list_t::iterator	token_list_itr_t
typedef details::char_t	char_t

Public Member Functions
	generator ()
void	clear ()
bool	process (const std::string &str)
bool	empty () const
std::size_t	size () const
void	begin ()
void	store ()
void	restore ()
token_t &	next_token ()
token_t &	peek_next_token ()
token_t &	operator[] (const std::size_t &index)
token_t	operator[] (const std::size_t &index) const
bool	finished () const
void	insert_front (token_t::token_type tk_type)
std::string	substr (const std::size_t &begin, const std::size_t &end) const
std::string	remaining () const

Private Member Functions
bool	is_end (details::char_cptr itr) const
bool	is_comment_start (details::char_cptr itr) const
void	skip_whitespace ()
void	skip_comments ()
bool	next_is_digit (const details::char_cptr itr) const
void	scan_token ()
void	scan_operator ()
void	scan_symbol ()
void	scan_number ()
void	scan_special_function ()
void	scan_string ()

Private Attributes
token_list_t	token_list_
token_list_itr_t	token_itr_
token_list_itr_t	store_token_itr_
token_t	eof_token_
details::char_cptr	base_itr_
details::char_cptr	s_itr_
details::char_cptr	s_end_

Friends
class	token_scanner
class	token_modifier
class	token_inserter
class	token_joiner

Detailed Description

Definition at line 2457 of file exprtk.hpp.

Member Typedef Documentation

char_t

typedef details::char_t exprtk::lexer::generator::char_t

Definition at line 2464 of file exprtk.hpp.

token_list_itr_t

typedef token_list_t::iterator exprtk::lexer::generator::token_list_itr_t

Definition at line 2463 of file exprtk.hpp.

token_list_t

typedef std::vector<token_t> exprtk::lexer::generator::token_list_t

Definition at line 2462 of file exprtk.hpp.

token_t

typedef token exprtk::lexer::generator::token_t

Definition at line 2461 of file exprtk.hpp.

Constructor & Destructor Documentation

generator()

exprtk::lexer::generator::generator ( )

inline

Definition at line 2466 of file exprtk.hpp.

         : base_itr_(0)
         , s_itr_   (0)
         , s_end_   (0)
         {
            clear();
         }

References base_itr_, clear(), s_end_, and s_itr_.

Here is the call graph for this function:

Member Function Documentation

begin()

void exprtk::lexer::generator::begin ( )

inline

Definition at line 2514 of file exprtk.hpp.

         {
            token_itr_ = token_list_.begin();
            store_token_itr_ = token_list_.begin();
         }

References store_token_itr_, token_itr_, and token_list_.

Referenced by exprtk::parser< Type >::compile(), and substr().

Here is the caller graph for this function:

clear()

void exprtk::lexer::generator::clear ( )

inline

Definition at line 2474 of file exprtk.hpp.

         {
            base_itr_ = 0;
            s_itr_    = 0;
            s_end_    = 0;
            token_list_.clear();
            token_itr_ = token_list_.end();
            store_token_itr_ = token_list_.end();
         }

References base_itr_, s_end_, s_itr_, store_token_itr_, token_itr_, and token_list_.

Referenced by generator().

Here is the caller graph for this function:

empty()

bool exprtk::lexer::generator::empty ( ) const

inline

Definition at line 2504 of file exprtk.hpp.

         {
            return token_list_.empty();
         }

References token_list_.

finished()

bool exprtk::lexer::generator::finished ( ) const

inline

Definition at line 2570 of file exprtk.hpp.

         {
            return (token_list_.end() == token_itr_);
         }

References token_itr_, and token_list_.

Referenced by remaining().

Here is the caller graph for this function:

insert_front()

void exprtk::lexer::generator::insert_front ( token_t::token_type tk_type )

inline

Definition at line 2575 of file exprtk.hpp.

         {
            if (
                 !token_list_.empty() &&
                 (token_list_.end() != token_itr_)
               )
            {
               token_t t = *token_itr_;
 
               t.type     = tk_type;
               token_itr_ = token_list_.insert(token_itr_,t);
            }
         }

References token_itr_, token_list_, and exprtk::lexer::token::type.

Referenced by exprtk::parser< Type >::post_bracket_process(), and exprtk::parser< Type >::post_variable_process().

Here is the caller graph for this function:

is_comment_start()

bool exprtk::lexer::generator::is_comment_start ( details::char_cptr itr ) const

inlineprivate

Definition at line 2615 of file exprtk.hpp.

         {
            const char_t c0 = *(itr + 0);
            const char_t c1 = *(itr + 1);
 
            if ('#' == c0)
               return true;
            else if (!is_end(itr + 1))
            {
               if (('/' == c0) && ('/' == c1)) return true;
               if (('/' == c0) && ('*' == c1)) return true;
            }
            return false;
         }

References is_end().

Referenced by scan_token().

Here is the call graph for this function:

Here is the caller graph for this function:

is_end()

bool exprtk::lexer::generator::is_end ( details::char_cptr itr ) const

inlineprivate

Definition at line 2609 of file exprtk.hpp.

         {
            return (s_end_ == itr);
         }

References s_end_.

Referenced by is_comment_start(), process(), scan_number(), scan_operator(), scan_string(), scan_symbol(), skip_comments(), and skip_whitespace().

Here is the caller graph for this function:

next_is_digit()

bool exprtk::lexer::generator::next_is_digit ( const details::char_cptr itr ) const

inlineprivate

Definition at line 2729 of file exprtk.hpp.

         {
            return ((itr + 1) != s_end_) &&
                   details::is_digit(*(itr + 1));
         }

References exprtk::details::is_digit(), and s_end_.

Referenced by scan_token().

Here is the call graph for this function:

Here is the caller graph for this function:

next_token()

token_t & exprtk::lexer::generator::next_token ( )

inline

Definition at line 2530 of file exprtk.hpp.

         {
            if (token_list_.end() != token_itr_)
            {
               return *token_itr_++;
            }
            else
               return eof_token_;
         }

References eof_token_, token_itr_, and token_list_.

operator[]() [1/2]

token_t & exprtk::lexer::generator::operator[] ( const std::size_t & index )

inline

Definition at line 2550 of file exprtk.hpp.

         {
            if (index < token_list_.size())
            {
               return token_list_[index];
            }
            else
               return eof_token_;
         }

References eof_token_, and token_list_.

operator[]() [2/2]

token_t exprtk::lexer::generator::operator[] ( const std::size_t & index ) const

inline

Definition at line 2560 of file exprtk.hpp.

         {
            if (index < token_list_.size())
            {
               return token_list_[index];
            }
            else
               return eof_token_;
         }

References eof_token_, and token_list_.

peek_next_token()

token_t & exprtk::lexer::generator::peek_next_token ( )

inline

Definition at line 2540 of file exprtk.hpp.

         {
            if (token_list_.end() != token_itr_)
            {
               return *token_itr_;
            }
            else
               return eof_token_;
         }

References eof_token_, token_itr_, and token_list_.

process()

bool exprtk::lexer::generator::process ( const std::string & str )

inline

Definition at line 2484 of file exprtk.hpp.

         {
            base_itr_ = str.data();
            s_itr_    = str.data();
            s_end_    = str.data() + str.size();
 
            eof_token_.set_operator(token_t::e_eof, s_end_, s_end_, base_itr_);
            token_list_.clear();
 
            while (!is_end(s_itr_))
            {
               scan_token();
 
               if (!token_list_.empty() && token_list_.back().is_error())
                  return false;
            }
 
            return true;
         }

References base_itr_, exprtk::lexer::token::e_eof, eof_token_, is_end(), s_end_, s_itr_, scan_token(), and token_list_.

Here is the call graph for this function:

remaining()

std::string exprtk::lexer::generator::remaining ( ) const

inline

Definition at line 2597 of file exprtk.hpp.

         {
            if (finished())
               return "";
            else if (token_list_.begin() != token_itr_)
               return std::string(base_itr_ + (token_itr_ - 1)->position, s_end_);
            else
               return std::string(base_itr_ + token_itr_->position, s_end_);
         }

References base_itr_, finished(), s_end_, token_itr_, and token_list_.

Here is the call graph for this function:

restore()

void exprtk::lexer::generator::restore ( )

inline

Definition at line 2525 of file exprtk.hpp.

         {
            token_itr_ = store_token_itr_;
         }

References store_token_itr_, and token_itr_.

scan_number()

void exprtk::lexer::generator::scan_number ( )

inlineprivate

Definition at line 2895 of file exprtk.hpp.

         {
            /*
               Attempt to match a valid numeric value in one of the following formats:
               (01) 123456
               (02) 123456.
               (03) 123.456
               (04) 123.456e3
               (05) 123.456E3
               (06) 123.456e+3
               (07) 123.456E+3
               (08) 123.456e-3
               (09) 123.456E-3
               (00) .1234
               (11) .1234e3
               (12) .1234E+3
               (13) .1234e+3
               (14) .1234E-3
               (15) .1234e-3
            */
 
            details::char_cptr initial_itr = s_itr_;
            bool dot_found                 = false;
            bool e_found                   = false;
            bool post_e_sign_found         = false;
            bool post_e_digit_found        = false;
            token_t t;
 
            while (!is_end(s_itr_))
            {
               if ('.' == (*s_itr_))
               {
                  if (dot_found)
                  {
                     t.set_error(token::e_err_number, initial_itr, s_itr_, base_itr_);
                     token_list_.push_back(t);
 
                     return;
                  }
 
                  dot_found = true;
                  ++s_itr_;
 
                  continue;
               }
               else if ('e' == std::tolower(*s_itr_))
               {
                  const char_t& c = *(s_itr_ + 1);
 
                  if (is_end(s_itr_ + 1))
                  {
                     t.set_error(token::e_err_number, initial_itr, s_itr_, base_itr_);
                     token_list_.push_back(t);
 
                     return;
                  }
                  else if (
                            ('+' != c) &&
                            ('-' != c) &&
                            !details::is_digit(c)
                          )
                  {
                     t.set_error(token::e_err_number, initial_itr, s_itr_, base_itr_);
                     token_list_.push_back(t);
 
                     return;
                  }
 
                  e_found = true;
                  ++s_itr_;
 
                  continue;
               }
               else if (e_found && details::is_sign(*s_itr_) && !post_e_digit_found)
               {
                  if (post_e_sign_found)
                  {
                     t.set_error(token::e_err_number, initial_itr, s_itr_, base_itr_);
                     token_list_.push_back(t);
 
                     return;
                  }
 
                  post_e_sign_found = true;
                  ++s_itr_;
 
                  continue;
               }
               else if (e_found && details::is_digit(*s_itr_))
               {
                  post_e_digit_found = true;
                  ++s_itr_;
 
                  continue;
               }
               else if (('.' != (*s_itr_)) && !details::is_digit(*s_itr_))
                  break;
               else
                  ++s_itr_;
            }
 
            t.set_numeric(initial_itr, s_itr_, base_itr_);
            token_list_.push_back(t);
 
            return;
         }

References base_itr_, exprtk::lexer::token::e_err_number, exprtk::details::is_digit(), is_end(), exprtk::details::is_sign(), s_itr_, exprtk::lexer::token::set_error(), exprtk::lexer::token::set_numeric(), and token_list_.

Referenced by scan_token().

Here is the call graph for this function:

Here is the caller graph for this function:

scan_operator()

void exprtk::lexer::generator::scan_operator ( )

inlineprivate

Definition at line 2798 of file exprtk.hpp.

         {
            token_t t;
 
            const char_t c0 = s_itr_[0];
 
            if (!is_end(s_itr_ + 1))
            {
               const char_t c1 = s_itr_[1];
 
               if (!is_end(s_itr_ + 2))
               {
                  const char_t c2 = s_itr_[2];
 
                  if ((c0 == '<') && (c1 == '=') && (c2 == '>'))
                  {
                     t.set_operator(token_t::e_swap, s_itr_, s_itr_ + 3, base_itr_);
                     token_list_.push_back(t);
                     s_itr_ += 3;
                     return;
                  }
               }
 
               token_t::token_type ttype = token_t::e_none;
 
               if      ((c0 == '<') && (c1 == '=')) ttype = token_t::e_lte;
               else if ((c0 == '>') && (c1 == '=')) ttype = token_t::e_gte;
               else if ((c0 == '<') && (c1 == '>')) ttype = token_t::e_ne;
               else if ((c0 == '!') && (c1 == '=')) ttype = token_t::e_ne;
               else if ((c0 == '=') && (c1 == '=')) ttype = token_t::e_eq;
               else if ((c0 == ':') && (c1 == '=')) ttype = token_t::e_assign;
               else if ((c0 == '<') && (c1 == '<')) ttype = token_t::e_shl;
               else if ((c0 == '>') && (c1 == '>')) ttype = token_t::e_shr;
               else if ((c0 == '+') && (c1 == '=')) ttype = token_t::e_addass;
               else if ((c0 == '-') && (c1 == '=')) ttype = token_t::e_subass;
               else if ((c0 == '*') && (c1 == '=')) ttype = token_t::e_mulass;
               else if ((c0 == '/') && (c1 == '=')) ttype = token_t::e_divass;
               else if ((c0 == '%') && (c1 == '=')) ttype = token_t::e_modass;
 
               if (token_t::e_none != ttype)
               {
                  t.set_operator(ttype, s_itr_, s_itr_ + 2, base_itr_);
                  token_list_.push_back(t);
                  s_itr_ += 2;
                  return;
               }
            }
 
            if ('<' == c0)
               t.set_operator(token_t::e_lt , s_itr_, s_itr_ + 1, base_itr_);
            else if ('>' == c0)
               t.set_operator(token_t::e_gt , s_itr_, s_itr_ + 1, base_itr_);
            else if (';' == c0)
               t.set_operator(token_t::e_eof, s_itr_, s_itr_ + 1, base_itr_);
            else if ('&' == c0)
               t.set_symbol(s_itr_, s_itr_ + 1, base_itr_);
            else if ('|' == c0)
               t.set_symbol(s_itr_, s_itr_ + 1, base_itr_);
            else
               t.set_operator(token_t::token_type(c0), s_itr_, s_itr_ + 1, base_itr_);
 
            token_list_.push_back(t);
            ++s_itr_;
         }

References base_itr_, exprtk::lexer::token::e_addass, exprtk::lexer::token::e_assign, exprtk::lexer::token::e_divass, exprtk::lexer::token::e_eof, exprtk::lexer::token::e_eq, exprtk::lexer::token::e_gt, exprtk::lexer::token::e_gte, exprtk::lexer::token::e_lt, exprtk::lexer::token::e_lte, exprtk::lexer::token::e_modass, exprtk::lexer::token::e_mulass, exprtk::lexer::token::e_ne, exprtk::lexer::token::e_none, exprtk::lexer::token::e_shl, exprtk::lexer::token::e_shr, exprtk::lexer::token::e_subass, exprtk::lexer::token::e_swap, is_end(), s_itr_, exprtk::lexer::token::set_operator(), exprtk::lexer::token::set_symbol(), and token_list_.

Referenced by scan_token().

Here is the call graph for this function:

Here is the caller graph for this function:

scan_special_function()

void exprtk::lexer::generator::scan_special_function ( )

inlineprivate

Definition at line 3002 of file exprtk.hpp.

         {
            details::char_cptr initial_itr = s_itr_;
            token_t t;
 
            // $fdd(x,x,x) = at least 11 chars
            if (std::distance(s_itr_,s_end_) < 11)
            {
               t.set_error(
                  token::e_err_sfunc,
                  initial_itr, std::min(initial_itr + 11, s_end_),
                  base_itr_);
               token_list_.push_back(t);
 
               return;
            }
 
            if (
                 !(('$' == *s_itr_)                       &&
                   (details::imatch  ('f',*(s_itr_ + 1))) &&
                   (details::is_digit(*(s_itr_ + 2)))     &&
                   (details::is_digit(*(s_itr_ + 3))))
               )
            {
               t.set_error(
                  token::e_err_sfunc,
                  initial_itr, std::min(initial_itr + 4, s_end_),
                  base_itr_);
               token_list_.push_back(t);
 
               return;
            }
 
            s_itr_ += 4; // $fdd = 4chars
 
            t.set_symbol(initial_itr, s_itr_, base_itr_);
            token_list_.push_back(t);
 
            return;
         }

References base_itr_, exprtk::lexer::token::e_err_sfunc, exprtk::details::imatch(), exprtk::details::is_digit(), s_end_, s_itr_, exprtk::lexer::token::set_error(), exprtk::lexer::token::set_symbol(), and token_list_.

Referenced by scan_token().

Here is the call graph for this function:

Here is the caller graph for this function:

scan_string()

void exprtk::lexer::generator::scan_string ( )

inlineprivate

Definition at line 3044 of file exprtk.hpp.

         {
            details::char_cptr initial_itr = s_itr_ + 1;
            token_t t;
 
            if (std::distance(s_itr_,s_end_) < 2)
            {
               t.set_error(token::e_err_string, s_itr_, s_end_, base_itr_);
               token_list_.push_back(t);
 
               return;
            }
 
            ++s_itr_;
 
            bool escaped_found = false;
            bool escaped = false;
 
            while (!is_end(s_itr_))
            {
               if (!details::is_valid_string_char(*s_itr_))
               {
                  t.set_error(token::e_err_string, initial_itr, s_itr_, base_itr_);
                  token_list_.push_back(t);
 
                  return;
               }
               else if (!escaped && ('\\' == *s_itr_))
               {
                  escaped_found = true;
                  escaped = true;
                  ++s_itr_;
 
                  continue;
               }
               else if (!escaped)
               {
                  if ('\'' == *s_itr_)
                     break;
               }
               else if (escaped)
               {
                  if (
                       !is_end(s_itr_) && ('0' == *(s_itr_)) &&
                       ((s_itr_ + 4) <= s_end_)
                     )
                  {
                     const bool x_separator = ('X' == std::toupper(*(s_itr_ + 1)));
 
                     const bool both_digits = details::is_hex_digit(*(s_itr_ + 2)) &&
                                              details::is_hex_digit(*(s_itr_ + 3)) ;
 
                     if (!(x_separator && both_digits))
                     {
                        t.set_error(token::e_err_string, initial_itr, s_itr_, base_itr_);
                        token_list_.push_back(t);
 
                        return;
                     }
                     else
                        s_itr_ += 3;
                  }
 
                  escaped = false;
               }
 
               ++s_itr_;
            }
 
            if (is_end(s_itr_))
            {
               t.set_error(token::e_err_string, initial_itr, s_itr_, base_itr_);
               token_list_.push_back(t);
 
               return;
            }
 
            if (!escaped_found)
               t.set_string(initial_itr, s_itr_, base_itr_);
            else
            {
               std::string parsed_string(initial_itr,s_itr_);
 
               if (!details::cleanup_escapes(parsed_string))
               {
                  t.set_error(token::e_err_string, initial_itr, s_itr_, base_itr_);
                  token_list_.push_back(t);
 
                  return;
               }
 
               t.set_string(
                  parsed_string,
                  static_cast<std::size_t>(std::distance(base_itr_,initial_itr)));
            }
 
            token_list_.push_back(t);
            ++s_itr_;
 
            return;
         }

References base_itr_, exprtk::details::cleanup_escapes(), exprtk::lexer::token::e_err_string, is_end(), exprtk::details::is_hex_digit(), exprtk::details::is_valid_string_char(), s_end_, s_itr_, exprtk::lexer::token::set_error(), exprtk::lexer::token::set_string(), and token_list_.

Referenced by scan_token().

Here is the call graph for this function:

Here is the caller graph for this function:

scan_symbol()

void exprtk::lexer::generator::scan_symbol ( )

inlineprivate

Definition at line 2863 of file exprtk.hpp.

         {
            details::char_cptr initial_itr = s_itr_;
 
            while (!is_end(s_itr_))
            {
               if (!details::is_letter_or_digit(*s_itr_) && ('_' != (*s_itr_)))
               {
                  if ('.' != (*s_itr_))
                     break;
                  /*
                     Permit symbols that contain a 'dot'
                     Allowed   : abc.xyz, a123.xyz, abc.123, abc_.xyz a123_.xyz abc._123
                     Disallowed: .abc, abc.<white-space>, abc.<eof>, abc.<operator +,-,*,/...>
                  */
                  if (
                       (s_itr_ != initial_itr)                     &&
                       !is_end(s_itr_ + 1)                         &&
                       !details::is_letter_or_digit(*(s_itr_ + 1)) &&
                       ('_' != (*(s_itr_ + 1)))
                     )
                     break;
               }
 
               ++s_itr_;
            }
 
            token_t t;
            t.set_symbol(initial_itr, s_itr_, base_itr_);
            token_list_.push_back(t);
         }

References base_itr_, is_end(), exprtk::details::is_letter_or_digit(), s_itr_, exprtk::lexer::token::set_symbol(), and token_list_.

Referenced by scan_token().

Here is the call graph for this function:

Here is the caller graph for this function:

scan_token()

void exprtk::lexer::generator::scan_token ( )

inlineprivate

Definition at line 2735 of file exprtk.hpp.

         {
            const char_t c = *s_itr_;
 
            if (details::is_whitespace(c))
            {
               skip_whitespace();
               return;
            }
            else if (is_comment_start(s_itr_))
            {
               skip_comments();
               return;
            }
            else if (details::is_operator_char(c))
            {
               scan_operator();
               return;
            }
            else if (details::is_letter(c))
            {
               scan_symbol();
               return;
            }
            else if (('.' == c) && !next_is_digit(s_itr_))
            {
               scan_operator();
               return;
            }
            else if (details::is_digit(c) || ('.' == c))
            {
               scan_number();
               return;
            }
            else if ('$' == c)
            {
               scan_special_function();
               return;
            }
            #ifndef exprtk_disable_string_capabilities
            else if ('\'' == c)
            {
               scan_string();
               return;
            }
            #endif
            else if ('~' == c)
            {
               token_t t;
               t.set_symbol(s_itr_, s_itr_ + 1, base_itr_);
               token_list_.push_back(t);
               ++s_itr_;
               return;
            }
            else
            {
               token_t t;
               t.set_error(token::e_error, s_itr_, s_itr_ + 2, base_itr_);
               token_list_.push_back(t);
               ++s_itr_;
            }
         }

References base_itr_, exprtk::lexer::token::e_error, is_comment_start(), exprtk::details::is_digit(), exprtk::details::is_letter(), exprtk::details::is_operator_char(), exprtk::details::is_whitespace(), next_is_digit(), s_itr_, scan_number(), scan_operator(), scan_special_function(), scan_string(), scan_symbol(), exprtk::lexer::token::set_error(), exprtk::lexer::token::set_symbol(), skip_comments(), skip_whitespace(), and token_list_.

Referenced by process().

Here is the call graph for this function:

Here is the caller graph for this function:

size()

std::size_t exprtk::lexer::generator::size ( ) const

inline

Definition at line 2509 of file exprtk.hpp.

         {
            return token_list_.size();
         }

References token_list_.

Referenced by exprtk::lexer::helper::dump(), and exprtk::parser< Type >::process_lexer_errors().

Here is the caller graph for this function:

skip_comments()

void exprtk::lexer::generator::skip_comments ( )

inlineprivate

Definition at line 2644 of file exprtk.hpp.

         {
            #ifndef exprtk_disable_comments
            // The following comment styles are supported:
            // 1. // .... \n
            // 2. #  .... \n
            // 3. /* .... */
            struct test
            {
               static inline bool comment_start(const char_t c0, const char_t c1, int& mode, int& incr)
               {
                  mode = 0;
                  if      ('#' == c0)    { mode = 1; incr = 1; }
                  else if ('/' == c0)
                  {
                     if      ('/' == c1) { mode = 1; incr = 2; }
                     else if ('*' == c1) { mode = 2; incr = 2; }
                  }
                  return (0 != mode);
               }
 
               static inline bool comment_end(const char_t c0, const char_t c1, int& mode)
               {
                  if (
                       ((1 == mode) && ('\n' == c0)) ||
                       ((2 == mode) && ( '*' == c0) && ('/' == c1))
                     )
                  {
                     mode = 0;
                     return true;
                  }
                  else
                     return false;
               }
            };
 
            int mode      = 0;
            int increment = 0;
 
            if (is_end(s_itr_))
               return;
            else if (!test::comment_start(*s_itr_, *(s_itr_ + 1), mode, increment))
               return;
 
            details::char_cptr cmt_start = s_itr_;
 
            s_itr_ += increment;
 
            while (!is_end(s_itr_))
            {
               if (details::is_invalid(*s_itr_))
               {
                  token_t t;
                  t.set_error(token::e_error, s_itr_, s_itr_ + 1, base_itr_);
                  token_list_.push_back(t);
                  return;
               }
 
               if ((1 == mode) && test::comment_end(*s_itr_, 0, mode))
               {
                  ++s_itr_;
                  return;
               }
 
               if ((2 == mode))
               {
                  if (!is_end((s_itr_ + 1)) && test::comment_end(*s_itr_, *(s_itr_ + 1), mode))
                  {
                     s_itr_ += 2;
                     return;
                  }
               }
 
               ++s_itr_;
            }
 
            if (2 == mode)
            {
               token_t t;
               t.set_error(token::e_error, cmt_start, cmt_start + mode, base_itr_);
               token_list_.push_back(t);
            }
            #endif
         }

References base_itr_, exprtk::lexer::token::e_error, is_end(), exprtk::details::is_invalid(), s_itr_, exprtk::lexer::token::set_error(), and token_list_.

Referenced by scan_token().

Here is the call graph for this function:

Here is the caller graph for this function:

skip_whitespace()

void exprtk::lexer::generator::skip_whitespace ( )

inlineprivate

Definition at line 2636 of file exprtk.hpp.

         {
            while (!is_end(s_itr_) && details::is_whitespace(*s_itr_))
            {
               ++s_itr_;
            }
         }

References is_end(), exprtk::details::is_whitespace(), and s_itr_.

Referenced by scan_token().

Here is the call graph for this function:

Here is the caller graph for this function:

store()

void exprtk::lexer::generator::store ( )

inline

Definition at line 2520 of file exprtk.hpp.

         {
            store_token_itr_ = token_itr_;
         }

References store_token_itr_, and token_itr_.

substr()

std::string exprtk::lexer::generator::substr ( const std::size_t & begin, const std::size_t & end ) const

inline

Definition at line 2589 of file exprtk.hpp.

         {
            const details::char_cptr begin_itr = ((base_itr_ + begin) < s_end_) ? (base_itr_ + begin) : s_end_;
            const details::char_cptr end_itr   = ((base_itr_ + end  ) < s_end_) ? (base_itr_ + end  ) : s_end_;
 
            return std::string(begin_itr,end_itr);
         }

References base_itr_, begin(), and s_end_.

Referenced by exprtk::parser< Type >::construct_subexpr(), and exprtk::parser< Type >::parse_assert_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

token_inserter

friend class token_inserter

friend

Definition at line 3159 of file exprtk.hpp.

References token_inserter.

Referenced by token_inserter.

token_joiner

friend class token_joiner

friend

Definition at line 3160 of file exprtk.hpp.

References token_joiner.

Referenced by token_joiner.

token_modifier

friend class token_modifier

friend

Definition at line 3158 of file exprtk.hpp.

References token_modifier.

Referenced by token_modifier.

token_scanner

friend class token_scanner

friend

Definition at line 3157 of file exprtk.hpp.

References token_scanner.

Referenced by token_scanner.

Member Data Documentation

base_itr_

details::char_cptr exprtk::lexer::generator::base_itr_

private

Definition at line 3153 of file exprtk.hpp.

Referenced by clear(), generator(), process(), remaining(), scan_number(), scan_operator(), scan_special_function(), scan_string(), scan_symbol(), scan_token(), skip_comments(), and substr().

eof_token_

token_t exprtk::lexer::generator::eof_token_

private

Definition at line 3152 of file exprtk.hpp.

Referenced by next_token(), operator[](), operator[](), peek_next_token(), and process().

s_end_

details::char_cptr exprtk::lexer::generator::s_end_

private

Definition at line 3155 of file exprtk.hpp.

Referenced by clear(), generator(), is_end(), next_is_digit(), process(), remaining(), scan_special_function(), scan_string(), and substr().

s_itr_

details::char_cptr exprtk::lexer::generator::s_itr_

private

Definition at line 3154 of file exprtk.hpp.

Referenced by clear(), generator(), process(), scan_number(), scan_operator(), scan_special_function(), scan_string(), scan_symbol(), scan_token(), skip_comments(), and skip_whitespace().

store_token_itr_

token_list_itr_t exprtk::lexer::generator::store_token_itr_

private

Definition at line 3151 of file exprtk.hpp.

Referenced by begin(), clear(), restore(), and store().

token_itr_

token_list_itr_t exprtk::lexer::generator::token_itr_

private

Definition at line 3150 of file exprtk.hpp.

Referenced by begin(), clear(), finished(), insert_front(), next_token(), peek_next_token(), remaining(), restore(), and store().

token_list_

token_list_t exprtk::lexer::generator::token_list_

private

Definition at line 3149 of file exprtk.hpp.

Referenced by begin(), clear(), empty(), finished(), insert_front(), next_token(), operator[](), operator[](), peek_next_token(), process(), exprtk::lexer::token_joiner::process_stride_2(), exprtk::lexer::token_joiner::process_stride_3(), remaining(), scan_number(), scan_operator(), scan_special_function(), scan_string(), scan_symbol(), scan_token(), size(), and skip_comments().

---

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

• exprtk/exprtk.hpp