lestes: lestes::lang::cplus::lex::special

anonymous enum [private]

Enumerator:

ERRORS_LIMIT

Number of errors to cut the input.

Definition at line 65 of file special_tokens.hh.

00065              {
00066                 //! Number of errors to cut the input.
00067                 ERRORS_LIMIT = 8
00068         };

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

States of the automaton.

Enumerator:

START	Ordinary tokens.
END	Already encountered end of file.

Definition at line 74 of file special_tokens.hh.

00074                      {
00075                 //! Ordinary tokens.
00076                 START,
00077                 //! Already encountered end of file.
00078                 END
00079         } state_type;

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

Creates the object.

Postcondition:: errors == 0

Definition at line 51 of file special_tokens.cc.

Referenced by create().

00051                                   :
00052         state(START),
00053         errors(0)
00054 {
00055 }

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

Hides copy constructor.

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

Reads next token.

Returns next token, assigns token type. Saves the EOF token to return it again. Tries to stop the error flood from encoder by sending EOF.

Returns:: The token with assigned type.

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

Definition at line 63 of file special_tokens.cc.

00064 {
00065         if (state == END)
00066                 return saved;
00067 
00068         ptr<ucn_token> t = input_read();
00069         ucn_token_type utt = t->type_get();
00070         ucn u = t->value_get();
00071 
00072         switch (utt) {
00073                 case ucn_token::TOK_NOT_EOF:
00074                         if (character::is_basic(u)) {
00075                                 t = t->clone_type(ucn_token::TOK_BASIC);
00076                         } else if (character::is_translated(u)) {
00077                                 t = t->clone_type(ucn_token::TOK_TRANSLATED);
00078                         } else {
00079                                 // TODO pt report error: character value out of range
00080                                 t = ucn_token::create_error(::lestes::msg::message::create(0xdead,"TODO char out of range",::lestes::msg::message::FLG_ERROR));
00081                         }
00082                         break;
00083                 case ucn_token::TOK_ERROR:
00084                         ++errors;
00085                         if (errors < ERRORS_LIMIT)
00086                                 break;
00087 
00088                         // prepare fake EOF
00089                         saved = ucn_token::create(ucn_token::TOK_EOF,0,t->location_get());
00090                         // TODO pt report error: wrong encoding in source, stopping
00091                         t = ucn_token::create_error(
00092                                         ::lestes::msg::message::create(0xbeef,"TODO flood",::lestes::msg::message::FLG_ERROR));
00093                         state = END;
00094                         break;
00095                 case ucn_token::TOK_EOF:
00096                         saved = t;
00097                         state = END;
00098                         break;
00099                 default:
00100                         lassert2(false,"You should never get here");
00101         }
00102 
00103         return t;
00104 }

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

Returns new instance.

Postcondition:: state == BEGIN

Returns:: New instance of the class.

Definition at line 119 of file special_tokens.cc.

References special_tokens().

00120 {
00121         return new special_tokens();
00122 }

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

Marks the object.

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

Definition at line 109 of file special_tokens.cc.

References lestes::lang::cplus::lex::ucn_filter::gc_mark().

00110 {
00111         ucn_filter::gc_mark();
00112 }

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

Hides assignment operator.

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

Current state of the parser.

Definition at line 81 of file special_tokens.hh.

Referenced by read().

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

Saved token.

Definition at line 83 of file special_tokens.hh.

Referenced by read().

ulint lestes::lang::cplus::lex::special_tokens::errors [private]

Number of incoming errors.

Definition at line 85 of file special_tokens.hh.

Referenced by read().

lestes::lang::cplus::lex::special_tokens Class Reference

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


Public Member Functions
ptr< ucn_token >	read (void)
	Reads next token.
Static Public Member Functions
static ptr< special_tokens >	create (void)
	Returns new instance.
Protected Member Functions
	special_tokens (void)
	Creates the object.
virtual void	gc_mark (void)
	Marks the object.
Private Types
enum	{ ERRORS_LIMIT = 8 }
enum	state_type { START, END }
	States of the automaton. More...
Private Member Functions
	special_tokens (const special_tokens &copy)
	Hides copy constructor.
special_tokens &	operator= (const special_tokens &rhs)
	Hides assignment operator.
Private Attributes
state_type	state
	Current state of the parser.
srp< ucn_token >	saved
	Saved token.
ulint	errors
	Number of incoming errors.