lestes::lang::cplus::lex::line_join

lestes::lang::cplus::lex::line_join Class Reference

Line joining filter. More...

#include <line_join.hh>

Inheritance diagram for lestes::lang::cplus::lex::line_join:

lestes::lang::cplus::lex::ucn_filter lestes::std::object lestes::std::mem::keystone List of all members.

Public Member Functions

ptr< ucn_token > read (void)
 Reads next token.

Static Public Member Functions

static ptr< line_join > create (void)
 Returns new instance.

Protected Member Functions

 line_join (void)
 Creates the object.
virtual void gc_mark (void)
 Marks the object.

Private Types

enum  state_type { START = 0, BACKSLASH = 1, SAVED = 2, AFTER = 3 }
 States of the processor. More...

Private Member Functions

 line_join (const line_join &)
 Hides copy constructor.
line_join & operator= (const line_join &)
 Hides assignment operator.

Private Attributes

state_type state
 Current state of the processor.
srp< ucn_token > saved
 Buffered token.

Detailed Description

Line joining filter.

Performs joining of lines ending with backslash.

Definition at line 49 of file line_join.hh.

Member Enumeration Documentation

enum lestes::lang::cplus::lex::line_join::state_type [private]

States of the processor.

Enumerator:
START  No tokens in buffer.
BACKSLASH  Backslash in buffer.
SAVED  Ordinary character in buffer.
AFTER  After discarding the pair.

Definition at line 62 of file line_join.hh.

00062                      {
00063                 //! No tokens in buffer.
00064                 START = 0,
00065                 //! Backslash in buffer.
00066                 BACKSLASH = 1,
00067                 //! Ordinary character in buffer.
00068                 SAVED = 2,
00069                 //! After discarding the pair.
00070                 AFTER = 3
00071         } state_type;

Constructor & Destructor Documentation

lestes::lang::cplus::lex::line_join::line_join ( void   )  [protected]

Creates the object.

Creates the object.

Postcondition:
state == START

Definition at line 48 of file line_join.cc.

Referenced by create().

00048                         :
00049         state(START)
00050 {
00051 }

lestes::lang::cplus::lex::line_join::line_join ( const line_join &   )  [private]

Hides copy constructor.

Member Function Documentation

ptr< ucn_token > lestes::lang::cplus::lex::line_join::read ( void   )  [virtual]

Reads next token.

Reads next token, discards backslash newline sequences. If backslash newline is encountered before EOF, the newline is returned to avoid reporting no newline at the end of file.

Implements lestes::lang::cplus::lex::ucn_filter.

Definition at line 60 of file line_join.cc.

References AFTER, BACKSLASH, lestes::lang::cplus::lex::ucn_filter::input_read(), lassert2, saved, SAVED, START, state, lestes::lang::cplus::lex::ucn_token::TOK_BASIC, lestes::lang::cplus::lex::ucn_token::TOK_EOF, and u.

00061 {
00062         ptr<ucn_token> t;
00063         
00064         if (state == SAVED) {
00065                 // something left in buffer
00066                 t = saved;
00067                 // release reference
00068                 saved = NULL;
00069                 state = START;
00070                 return t;
00071         }
00072 
00073         ucn_token_type utt;
00074         ucn u;
00075 
00076         while (true) {
00077                 // read new token
00078                 t = input_read();
00079                 utt = t->type_get();
00080                 u = t->value_get();
00081                 switch (state) {
00082                         case AFTER:
00083                                 if (utt == ucn_token::TOK_EOF) {
00084                                         // get the newline from the last pair
00085                                         ptr<ucn_token> tmp = saved;
00086                                         // save the EOF
00087                                         saved = t;
00088                                         state = SAVED;
00089                                         return tmp;
00090                                 }
00091                                 saved = NULL;
00092                                 state = START;
00093                                 // fall through
00094                         case START:
00095                                 if (utt == ucn_token::TOK_BASIC && u == character::ascii_backslash) {
00096                                         // save the location
00097                                         saved = t;
00098                                         state = BACKSLASH;
00099                                 } else {
00100                                         return t;
00101                                 }
00102                                 break;
00103                         case BACKSLASH:
00104                                 // backslash newline combination
00105                                 if (utt == ucn_token::TOK_BASIC && u == character::ascii_new_line) {
00106                                         // switch to the newline in case EOF follows
00107                                         saved = t;
00108                                         // start anew
00109                                         state = AFTER;
00110                                 } else {
00111                                         if (utt != ucn_token::TOK_BASIC || u != character::ascii_backslash) {
00112                                                 // character different from backslash
00113                                                 state = SAVED;
00114                                         }
00115                                         // get the backslash
00116                                         ptr<ucn_token> tmp = saved;
00117                                         // save current
00118                                         saved = t;
00119                                         // return the backslash
00120                                         return tmp;
00121                                 }
00122                                 break;
00123                         default:
00124                                 lassert2(false,"You should never get here");
00125                 }
00126         }
00127 }

ptr< line_join > lestes::lang::cplus::lex::line_join::create ( void   )  [static]

Returns new instance.

Returns new instance.

Returns:
New instance of the class.

Definition at line 142 of file line_join.cc.

References line_join().

00143 {
00144         return new line_join();
00145 }

void lestes::lang::cplus::lex::line_join::gc_mark ( void   )  [protected, virtual]

Marks the object.

Marks the object.

Reimplemented from lestes::lang::cplus::lex::ucn_filter.

Definition at line 132 of file line_join.cc.

References lestes::lang::cplus::lex::ucn_filter::gc_mark(), and saved.

00133 {
00134         saved.gc_mark();
00135         ucn_filter::gc_mark();
00136 }

line_join& lestes::lang::cplus::lex::line_join::operator= ( const line_join &   )  [private]

Hides assignment operator.

Member Data Documentation

state_type lestes::lang::cplus::lex::line_join::state [private]

Current state of the processor.

Definition at line 73 of file line_join.hh.

Referenced by read().

srp<ucn_token> lestes::lang::cplus::lex::line_join::saved [private]

Buffered token.

Definition at line 75 of file line_join.hh.

Referenced by gc_mark(), and read().

The documentation for this class was generated from the following files:
Generated on Mon Feb 12 18:24:17 2007 for lestes by doxygen 1.5.1-20070107