exprtk::lexer::helper::operator_joiner Class Reference

Inheritance diagram for exprtk::lexer::helper::operator_joiner:

Collaboration diagram for exprtk::lexer::helper::operator_joiner:

Public Member Functions
	operator_joiner (const std::size_t &stride)
bool	join (const lexer::token &t0, const lexer::token &t1, lexer::token &t)
bool	join (const lexer::token &t0, const lexer::token &t1, const lexer::token &t2, lexer::token &t)
Public Member Functions inherited from exprtk::lexer::token_joiner
	token_joiner (const std::size_t &stride)
std::size_t	process (generator &g)
Public Member Functions inherited from exprtk::lexer::helper_interface
virtual void	init ()
virtual void	reset ()
virtual bool	result ()
virtual	~helper_interface ()

Detailed Description

Definition at line 3595 of file exprtk.hpp.

Constructor & Destructor Documentation

operator_joiner()

exprtk::lexer::helper::operator_joiner::operator_joiner ( const std::size_t &  stride )

inlineexplicit

Definition at line 3599 of file exprtk.hpp.

            : token_joiner(stride)
            {}

Member Function Documentation

join() [1/2]

bool exprtk::lexer::helper::operator_joiner::join ( const lexer::token &  t0, const lexer::token &  t1, const lexer::token &  t2, lexer::token &  t  )

inlinevirtual

Reimplemented from exprtk::lexer::token_joiner.

Definition at line 3748 of file exprtk.hpp.

            {
               // '[ * ]' --> '[*]'
               if (
                    (t0.type == lexer::token::e_lsqrbracket) &&
                    (t1.type == lexer::token::e_mul        ) &&
                    (t2.type == lexer::token::e_rsqrbracket)
                  )
               {
                  t.type     = lexer::token::e_symbol;
                  t.value    = "[*]";
                  t.position = t0.position;
 
                  return true;
               }
               else
                  return false;
            }

References exprtk::lexer::token::e_lsqrbracket, exprtk::lexer::token::e_mul, exprtk::lexer::token::e_rsqrbracket, and exprtk::lexer::token::e_symbol.

join() [2/2]

bool exprtk::lexer::helper::operator_joiner::join ( const lexer::token &  t0, const lexer::token &  t1, lexer::token &  t  )

inlinevirtual

Reimplemented from exprtk::lexer::token_joiner.

Definition at line 3603 of file exprtk.hpp.

            {
               // ': =' --> ':='
               if ((t0.type == lexer::token::e_colon) && (t1.type == lexer::token::e_eq))
               {
                  t.type     = lexer::token::e_assign;
                  t.value    = ":=";
                  t.position = t0.position;
 
                  return true;
               }
               // '+ =' --> '+='
               else if ((t0.type == lexer::token::e_add) && (t1.type == lexer::token::e_eq))
               {
                  t.type     = lexer::token::e_addass;
                  t.value    = "+=";
                  t.position = t0.position;
 
                  return true;
               }
               // '- =' --> '-='
               else if ((t0.type == lexer::token::e_sub) && (t1.type == lexer::token::e_eq))
               {
                  t.type     = lexer::token::e_subass;
                  t.value    = "-=";
                  t.position = t0.position;
 
                  return true;
               }
               // '* =' --> '*='
               else if ((t0.type == lexer::token::e_mul) && (t1.type == lexer::token::e_eq))
               {
                  t.type     = lexer::token::e_mulass;
                  t.value    = "*=";
                  t.position = t0.position;
 
                  return true;
               }
               // '/ =' --> '/='
               else if ((t0.type == lexer::token::e_div) && (t1.type == lexer::token::e_eq))
               {
                  t.type     = lexer::token::e_divass;
                  t.value    = "/=";
                  t.position = t0.position;
 
                  return true;
               }
               // '% =' --> '%='
               else if ((t0.type == lexer::token::e_mod) && (t1.type == lexer::token::e_eq))
               {
                  t.type     = lexer::token::e_modass;
                  t.value    = "%=";
                  t.position = t0.position;
 
                  return true;
               }
               // '> =' --> '>='
               else if ((t0.type == lexer::token::e_gt) && (t1.type == lexer::token::e_eq))
               {
                  t.type     = lexer::token::e_gte;
                  t.value    = ">=";
                  t.position = t0.position;
 
                  return true;
               }
               // '< =' --> '<='
               else if ((t0.type == lexer::token::e_lt) && (t1.type == lexer::token::e_eq))
               {
                  t.type     = lexer::token::e_lte;
                  t.value    = "<=";
                  t.position = t0.position;
 
                  return true;
               }
               // '= =' --> '=='
               else if ((t0.type == lexer::token::e_eq) && (t1.type == lexer::token::e_eq))
               {
                  t.type     = lexer::token::e_eq;
                  t.value    = "==";
                  t.position = t0.position;
 
                  return true;
               }
               // '! =' --> '!='
               else if ((static_cast<details::char_t>(t0.type) == '!') && (t1.type == lexer::token::e_eq))
               {
                  t.type     = lexer::token::e_ne;
                  t.value    = "!=";
                  t.position = t0.position;
 
                  return true;
               }
               // '< >' --> '<>'
               else if ((t0.type == lexer::token::e_lt) && (t1.type == lexer::token::e_gt))
               {
                  t.type     = lexer::token::e_ne;
                  t.value    = "<>";
                  t.position = t0.position;
 
                  return true;
               }
               // '<= >' --> '<=>'
               else if ((t0.type == lexer::token::e_lte) && (t1.type == lexer::token::e_gt))
               {
                  t.type     = lexer::token::e_swap;
                  t.value    = "<=>";
                  t.position = t0.position;
 
                  return true;
               }
               // '+ -' --> '-'
               else if ((t0.type == lexer::token::e_add) && (t1.type == lexer::token::e_sub))
               {
                  t.type     = lexer::token::e_sub;
                  t.value    = "-";
                  t.position = t0.position;
 
                  return true;
               }
               // '- +' --> '-'
               else if ((t0.type == lexer::token::e_sub) && (t1.type == lexer::token::e_add))
               {
                  t.type     = lexer::token::e_sub;
                  t.value    = "-";
                  t.position = t0.position;
 
                  return true;
               }
               // '- -' --> '+'
               else if ((t0.type == lexer::token::e_sub) && (t1.type == lexer::token::e_sub))
               {
                  /*
                     Note: May need to reconsider this when wanting to implement
                     pre/postfix decrement operator
                  */
                  t.type     = lexer::token::e_add;
                  t.value    = "+";
                  t.position = t0.position;
 
                  return true;
               }
               else
                  return false;
            }

References exprtk::lexer::token::e_add, exprtk::lexer::token::e_addass, exprtk::lexer::token::e_assign, exprtk::lexer::token::e_colon, exprtk::lexer::token::e_div, exprtk::lexer::token::e_divass, 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_mod, exprtk::lexer::token::e_modass, exprtk::lexer::token::e_mul, exprtk::lexer::token::e_mulass, exprtk::lexer::token::e_ne, exprtk::lexer::token::e_sub, exprtk::lexer::token::e_subass, and exprtk::lexer::token::e_swap.

---

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

• exprtk/exprtk.hpp