lestes::lang::cplus::lex::string_translator

lestes::lang::cplus::lex::string_translator Class Reference

Encoder into execution character set. More...

#include <string_translator.hh>

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

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

Public Member Functions

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

Static Public Member Functions

static ptr< string_translator > create (const ptr< pp_filter > &a_input)
 Returns new instance.

Protected Member Functions

 string_translator (const ptr< pp_filter > &a_input)
 Creates the translator.

Private Member Functions

ptr< token_value > translate (const ucn_string &str, const ptr< source_location > &loc)
 Translates literal into execution character set.
 string_translator (const string_translator &)
 Hides copy constructor.
string_translator & operator= (const string_translator &)
 Hides assignment operator.

Detailed Description

Encoder into execution character set.

Encodes string and character literals into execution character set.

Definition at line 58 of file string_translator.hh.

Constructor & Destructor Documentation

lestes::lang::cplus::lex::string_translator::string_translator ( const ptr< pp_filter > &  a_input  )  [protected]

Creates the translator.

Creates the translator.

Precondition:
a_input != NULL
Parameters:
a_input The input for the filter.

Definition at line 52 of file string_translator.cc.

Referenced by create().

00052                                                                  :
00053         pp_filter(checked(a_input))
00054 {
00055 }

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

Hides copy constructor.

Member Function Documentation

ptr< pp_token > lestes::lang::cplus::lex::string_translator::read ( void   )  [virtual]

Reads next token.

Reads next token, encodes character and string literals into execution character set.

Returns:
The next token.

Implements lestes::lang::cplus::lex::pp_filter.

Definition at line 61 of file string_translator.cc.

References lestes::lang::cplus::lex::pp_token::create(), lestes::lang::cplus::lex::pp_filter::input_read(), lestes::lang::cplus::lex::pp_token::TOK_CHAR_LIT, lestes::lang::cplus::lex::pp_token::TOK_STRING_LIT, lestes::lang::cplus::lex::pp_token::TOK_WCHAR_LIT, lestes::lang::cplus::lex::pp_token::TOK_WSTRING_LIT, and translate().

00062 {
00063         ptr<pp_token> t = input_read();
00064         pp_token_type ptt = t->type_get();
00065         ptr<source_location> loc;
00066 
00067         switch (ptt) {
00068                 case pp_token::TOK_STRING_LIT:
00069                 case pp_token::TOK_WSTRING_LIT:
00070                 case pp_token::TOK_CHAR_LIT:
00071                 case pp_token::TOK_WCHAR_LIT:
00072                         // TODO pt change the TOK*LIT for TOK*TRN
00073                         loc = t->location_get();
00074                         t = pp_token::create(loc,ptt,translate(t->value_get()->content_get(),loc));
00075                         break;
00076                 default:
00077                         break;
00078         }
00079 
00080         return t;
00081 }

ptr< string_translator > lestes::lang::cplus::lex::string_translator::create ( const ptr< pp_filter > &  a_input  )  [static]

Returns new instance.

Returns new translator.

Precondition:
a_input != NULL
Parameters:
a_input The input for the filter.
Returns:
New instance of the translator.

Definition at line 246 of file string_translator.cc.

References string_translator().

00247 {
00248         return new string_translator(a_input);
00249 }

ptr< token_value > lestes::lang::cplus::lex::string_translator::translate ( const ucn_string &  str,
const ptr< source_location > &  loc 
) [private]

Translates literal into execution character set.

Translates string or character literal to execution character set.

Precondition:
loc != NULL
Parameters:
str The literal representation to translate.
loc The location of the literal.
Returns:
The literal in execution character set.

Definition at line 90 of file string_translator.cc.

References BEGIN, lestes::lang::cplus::lex::token_value::create(), lassert, lassert2, and u.

Referenced by read().

00091 {
00092         // state of the function
00093         enum {
00094                 BEGIN,
00095                 PASS,
00096                 BACK,
00097                 OCT,
00098                 HEX,
00099                 TRANSLATE
00100         } fstate = BEGIN;
00101 
00102         ucn_string::size_type len = str.length();
00103         ulint count = 0xbad;
00104         ulint value = 0xbad;
00105         ucn u = 0xbad;
00106         
00107         // reserve space
00108         ucn_string us(len,0xbeef);
00109         
00110         ucn_string::const_iterator it = str.begin();
00111         ucn_string::const_iterator end = str.end();
00112         ucn_string::iterator sit = us.begin();
00113         while (true) {
00114                 if (fstate == PASS) {
00115                         fstate = BEGIN;
00116                 } else if (it != end) {
00117                         u = *it;
00118                         ++it;
00119                 } else break;
00120 
00121                 switch (fstate) {
00122                         case BEGIN:
00123                                 if (u == character::ascii_backslash) {
00124                                         fstate = BACK;
00125                                 } else {
00126                                         fstate = TRANSLATE;
00127                                 }
00128                                 break;
00129                         case BACK:
00130                                 switch (u) {
00131                                         case character::ascii_lower_x:
00132                                                 count = 1;
00133                                                 value = 0;
00134                                                 fstate = HEX;
00135                                                 break;
00136                                         case character::ascii_quote:
00137                                         case character::ascii_dquote:
00138                                         case character::ascii_qmark:
00139                                         case character::ascii_backslash:
00140                                                 fstate = TRANSLATE;
00141                                                 break;
00142                                         case character::ascii_lower_a:
00143                                                 u = character::ascii_bell;
00144                                                 break;
00145                                         case character::ascii_lower_b:
00146                                                 u = character::ascii_backspace;
00147                                                 fstate = TRANSLATE;
00148                                                 break;
00149                                         case character::ascii_lower_f:
00150                                                 u = character::ascii_form_feed;
00151                                                 fstate = TRANSLATE;
00152                                                 break;
00153                                         case character::ascii_lower_n:
00154                                                 u = character::ascii_new_line;
00155                                                 fstate = TRANSLATE;
00156                                                 break;
00157                                         case character::ascii_lower_r:
00158                                                 u = character::ascii_carriage_return;
00159                                                 fstate = TRANSLATE;
00160                                                 break;
00161                                         case character::ascii_lower_t:
00162                                                 u = character::ascii_tab;
00163                                                 fstate = TRANSLATE;
00164                                                 break;
00165                                         case character::ascii_lower_v:
00166                                                 u = character::ascii_vtab;
00167                                                 fstate = TRANSLATE;
00168                                                 break;
00169                                         default:
00170                                           lassert(character::is_odigit(u));
00171                                           value = character::extract_odigit(u);
00172                                           count = 2;
00173                                           fstate = OCT;
00174                                           break;
00175                                 }
00176                                 break;
00177                         case OCT:
00178                                 if (character::is_odigit(u)) {
00179                                         value = (value << 3) + character::extract_odigit(u);
00180                                         if (--count == 0) {
00181                                                 *sit = character::create_external(value);
00182                                                 ++sit;
00183                                                 fstate = BEGIN;
00184                                         }
00185                                 } else {
00186                                         *sit = character::create_external(value);
00187                                         ++sit;
00188                                         fstate = PASS;
00189                                 }
00190                                 break;
00191                         case HEX:
00192                                 if (character::is_xdigit(u)) {
00193                                         value = (value << 4) + character::extract_xdigit(u);
00194                                 } else {
00195                                         lassert(count);
00196                                         *sit = character::create_external(value);
00197                                         ++sit;
00198                                         fstate = PASS;
00199                                 }
00200                                 break;
00201                         default:
00202                                 lassert(false);
00203                                 break;
00204                 }
00205 
00206                 if (fstate == TRANSLATE) {
00207                         // TODO not hardcoded ASCII
00208                         if (!character::is_ascii7(u)) {
00209                                 // TODO pt report error: unknown character
00210                                 (void)loc;
00211                                 u = character::ascii_qmark;
00212                         }
00213                         *sit = character::extract_value(u);
00214                         ++sit;
00215 
00216                         fstate = BEGIN;
00217                 }
00218         }
00219 
00220         switch (fstate) {
00221                 case BEGIN:
00222                         break;
00223                 case OCT:
00224                         *sit = character::create_external(value);
00225                         ++sit;
00226                         break;
00227                 case HEX:
00228                         lassert(count);
00229                         *sit = character::create_external(value);
00230                         ++sit;
00231                         break;
00232                 default:
00233                         lassert2(false,"You should never get here");
00234         }
00235         
00236         // use only filled part of the string
00237         return token_value::create(ucn_string(us.begin(),sit));
00238 }

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

Hides assignment operator.

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