lestes::lang::cplus::syn::one_manager Class Reference

Inheritance diagram for lestes::lang::cplus::syn::one_manager:

List of all members.

Public Member Functions
ptr< bison_token >	yylex ()
ptr< bison_token >	prev_yylex ()
ptr< bison_token >	peek ()
void	back_up ()
void	start (int)
void	commit (int)
void	rollback ()
ptr< bison_pack_token >	pack (int, const ptr< source_location > &)
void	unpack ()
bool	in_disambiguation () const
void	install_undo_action (ptr< action > a)
bool	failing_get () const
void	failing_set_true ()
Static Public Member Functions
static ptr< one_manager >	create (const ptr< streamer > &a_src)
static void	init ()
	Initializes the maps.
Protected Member Functions
	one_manager (const ptr< streamer > &)
void	gc_mark ()
	Marks the keystone.
void	find_closing (int closing, int opening, const ptr< source_location > &loc)
	Finds closing token (e.g. parenthesis); opening token must be specified too.
Protected Attributes
bool	run_hinter
bool	failing
srp< token_list_type >	token_list
token_list_iterator	token_list_pos
srp< list< srp< transaction > > >	open_transactions
static::std::set< int >	error_stmt_end_set
	Contains a set of skeletal tokens used in error recovery.
Private Attributes
srp< streamer >	src
srp< bison_token >	last_token

---

Detailed Description

Definition at line 238 of file manager.cc.

---

Constructor & Destructor Documentation

lestes::lang::cplus::syn::one_manager::one_manager

(

const ptr< streamer > &

s

)

[protected]

Immediately adds first token from the tokeniser into token_list.

Definition at line 313 of file manager.cc.

References create(), failing, last_token, open_transactions, run_hinter, src, token_list, and token_list_pos.

{
        src = s;
        last_token = NULL;
        run_hinter = true;
        failing = false;
        token_list = token_list_type::create();
        token_list->push_back( s->first() );
        token_list_pos = token_list->begin();
        open_transactions = list< srp<transaction> >::create();
}

---

Member Function Documentation

void lestes::lang::cplus::syn::one_manager::gc_mark

(

void

)

[inline, protected, virtual]

Marks the keystone.

Marks all directly reachable parts of the class. The method must be overriden for each inherited class. It should contain abc.gc_mark() for each field abc of the inherited class and call to gc_mark() of the direct ancestor of the class. Does nothing for keystone, only stops processing of ancestors.

Reimplemented from lestes::std::mem::keystone.

Definition at line 251 of file manager.cc.

        {
                src.gc_mark();
                last_token.gc_mark();
                token_list.gc_mark();
                open_transactions.gc_mark();
                object::gc_mark();
        }

void lestes::lang::cplus::syn::one_manager::find_closing	(	int	closing,
		int	opening,
		const ptr< source_location > &	loc
	)			[protected]

Finds closing token (e.g. parenthesis); opening token must be specified too.

Reads tokens using yylex() to find closing parenthesis/bracket/brace.

Tokens are read until one with closing type is found. Each occurence of token with opening type requires its counterpart with closing type to be read before a token with the closing type is considered to be terminating.

When EOF is read before all occurences of opening tokens are closed, errors are reported.

The position in the stream is left to point just after the terminating token. This is needed for pack() to work. This method is called exclusively from there.

When closing == opening nesting is not done and very first occurence of a token with such value is considered closing.

A location must be provided for cases when the unclosed opening token lies before tokens read by the method. It is used for error reporting only.

Parameters:

	closing	type of token considered to be closing [parenthesis]
	opening	type of token considered to be opening [parenthesis]
	loc	location used to error reports that are out of "scope"

Definition at line 560 of file manager.cc.

References failing_set_true(), lassert, lestes::report, TOK_EOF, lestes::lang::cplus::syn::unmatched_open, and yylex().

Referenced by pack().

{
        lassert( loc );
        typedef list< srp<bison_token> > stack_type;
        ptr<stack_type> st = stack_type::create();
        while (true) {
                ptr<bison_token> t = yylex();
                int ttype = t->type_get();
                if (ttype == bison_token::TOK_EOF) {
                        // BOOM
                        if (st->empty())
                                report << unmatched_open << loc;
                        else
                                report << unmatched_open << st->back()->location_get();
                        // do not report errors when we return back to the parser
                        failing_set_true();
                        break;
                }
                if (ttype == closing) {
                        if (st->empty())
                                break;  // closing one found
                        else
                                st->pop_back();
                } else if (ttype == opening)
                        st->push_back( t );
        }
}

static ptr<one_manager> lestes::lang::cplus::syn::one_manager::create

(

const ptr< streamer > &

a_src

)

[inline, static]

Definition at line 265 of file manager.cc.

Referenced by lestes::lang::cplus::syn::manager::init(), one_manager(), and lestes::lang::cplus::syn::manager::spawn().

        {
                return new one_manager(a_src);
        }

void lestes::lang::cplus::syn::one_manager::init

(

)

[static]

Initializes the maps.

Definition at line 289 of file manager.cc.

References error_stmt_end_set, TOK_BREAK, TOK_CATCH, TOK_CONTINUE, TOK_DO, TOK_ELSE, TOK_EOF, TOK_FOR, TOK_GOTO, TOK_IF, TOK_LEFT_BRACE, TOK_RETURN, TOK_RIGHT_BRACE, TOK_SEMICOLON, TOK_SWITCH, TOK_TRY, and TOK_WHILE.

Referenced by lestes::lang::cplus::syn::manager::init().

{
        error_stmt_end_set.insert( bison_token::TOK_BREAK );
        error_stmt_end_set.insert( bison_token::TOK_CATCH );
        error_stmt_end_set.insert( bison_token::TOK_CONTINUE );
        error_stmt_end_set.insert( bison_token::TOK_DO );
        error_stmt_end_set.insert( bison_token::TOK_ELSE );
        error_stmt_end_set.insert( bison_token::TOK_FOR );
        error_stmt_end_set.insert( bison_token::TOK_GOTO );
        error_stmt_end_set.insert( bison_token::TOK_IF );
        error_stmt_end_set.insert( bison_token::TOK_RETURN );
        error_stmt_end_set.insert( bison_token::TOK_SWITCH );
        error_stmt_end_set.insert( bison_token::TOK_TRY );
        error_stmt_end_set.insert( bison_token::TOK_WHILE );
        error_stmt_end_set.insert( bison_token::TOK_SEMICOLON );
        error_stmt_end_set.insert( bison_token::TOK_EOF );
        error_stmt_end_set.insert( bison_token::TOK_LEFT_BRACE );
        error_stmt_end_set.insert( bison_token::TOK_RIGHT_BRACE );
}

ptr< bison_token > lestes::lang::cplus::syn::one_manager::yylex

(

)

Definition at line 330 of file manager.cc.

References lestes::lang::cplus::syn::hinter::hint(), in_disambiguation(), last_token, peek(), run_hinter, TOK_IDENT, token_list, and token_list_pos.

Referenced by find_closing(), and pack().

{
        ptr<bison_token> t = peek();
        // discard unneeded tokens; this only happens at top-level
        if (!in_disambiguation() && token_list_pos != token_list->begin())
                token_list->pop_front();
        ++token_list_pos;

        // run the hinter, if needed
        // note that the old (not-hinted) token is stored in token_list
        if (run_hinter && t->type_get() == bison_token::TOK_IDENT)
                t = hinter::hint( t, peek() );
        last_token = t;
        return t;
}

ptr< bison_token > lestes::lang::cplus::syn::one_manager::prev_yylex

(

)

Definition at line 346 of file manager.cc.

References lassert2, and last_token.

Referenced by pack().

{
        lassert2( last_token, "yylex() was not called previously." );
        return last_token;
}

ptr< bison_token > lestes::lang::cplus::syn::one_manager::peek

(

)

Definition at line 352 of file manager.cc.

References src, token_list, and token_list_pos.

Referenced by start(), and yylex().

{
        ptr<bison_token> t;
        if (token_list_pos == token_list->end()) {
                t = src->next();
                token_list_pos = token_list->insert( token_list_pos, t );
        } else
                t = *token_list_pos;
        return t;
}

void lestes::lang::cplus::syn::one_manager::back_up

(

)

Definition at line 363 of file manager.cc.

References lassert, llog, open_transactions, token_list, and token_list_pos.

{
        // make sure there is room to back up
        // this ensures that only one backing up is allowed between two successive calls to yylex()
        lassert( token_list_pos != token_list->begin() );
        // make sure we do not back up over current start token
        lassert( open_transactions->empty() ||
                        token_list_pos != open_transactions->back()->start_pos_get() );

        --token_list_pos;

        llog(ml) << "backing up " << ptr<bison_token>(*token_list_pos) << "\n";
}

void lestes::lang::cplus::syn::one_manager::start

(

int

)

Definition at line 377 of file manager.cc.

References _START_FIRST, _START_LAST, lestes::lang::cplus::syn::transaction::create(), lestes::intercode::intercode::create(), lassert, llog, open_transactions, peek(), lestes::lang::cplus::syn::manager::start_event, token_list, and token_list_pos.

Referenced by pack().

{
        lassert( type > bison_token::_START_FIRST && type < bison_token::_START_LAST );

        ptr<bison_token> t = bison_madeup_token::create( peek()->location_get(), type );
        token_list_pos = token_list->insert( token_list_pos, t );
        open_transactions->push_back( transaction::create(token_list_pos) );
        llog(ml) << "starting with " << t << "\n";

        manager::start_event->trigger();
}

void lestes::lang::cplus::syn::one_manager::commit

(

int

)

Definition at line 389 of file manager.cc.

References _PAD_FIRST, _PAD_LAST, lestes::lang::cplus::syn::manager::commit_event, lestes::lang::cplus::syn::undo_delete_token::create(), lestes::intercode::intercode::create(), in_disambiguation(), lassert, llog, open_transactions, token_list, and token_list_pos.

Referenced by pack().

{
        lassert( in_disambiguation() );
        lassert( type > bison_token::_PAD_FIRST && type < bison_token::_PAD_LAST );

        ptr<transaction> this_tx = open_transactions->back();
        open_transactions->pop_back();

        token_list_pos = this_tx->start_pos_get();

        // create the pad, take location from the start-token
        ptr<bison_token> pad = bison_madeup_token::create( (*token_list_pos)->location_get(), type );

        llog(ml) << "committing " << pad << " over " <<
                ptr<bison_token>(*this_tx->start_pos_get()) << "\n";

        // do overwrite (commit) the token
        *token_list_pos = pad;

        // hand over undo actions from nested diambiguation(s), if needed
        if (in_disambiguation()) {
                ptr<transaction> prev_tx = open_transactions->back();
                prev_tx->add_undo_action( undo_delete_token::create( token_list, token_list_pos ) );
                this_tx->submit_undo( prev_tx );
        }

        manager::commit_event->trigger();
}

void lestes::lang::cplus::syn::one_manager::rollback

(

)

Definition at line 418 of file manager.cc.

References in_disambiguation(), lassert, llog, llog_plain, open_transactions, lestes::lang::cplus::syn::manager::rollback_event, token_list, and token_list_pos.

{
        lassert( in_disambiguation() );

        ptr<transaction> this_tx = open_transactions->back();
        open_transactions->pop_back();

        llog(ml) << "rolling back " << ptr<bison_token>(*this_tx->start_pos_get());
        ulint count = this_tx->undo();
        token_list_pos = token_list->erase( this_tx->start_pos_get() );

        llog_plain(ml) << " (" << count << " undo actions)\n";

        manager::rollback_event->trigger();
}

ptr< bison_pack_token > lestes::lang::cplus::syn::one_manager::pack	(	int	pack_type,
		const ptr< source_location > &	start_loc
	)

Packs tokens from the stream to form a pack token with given type. The actual packing method used depends on the type of the desired token.

Some packing methods need to report the error as being located before the first token of the pack. It is passed in start_loc in these cases. Note that we cannot rely on prev_yylex() here, because there may have been no previous calls to yylex(). However, the parser (which usually calls us) can be pretty sure.

Parameters:

	pack_type	Type of desired token pack. Determines the packing method used.
	start_loc	Location that is passed to some of the packing method for error reporting.

Definition at line 447 of file manager.cc.

References _PACK_FIRST, _PACK_LAST, commit(), lestes::lang::cplus::syn::undo_unpack::create(), lestes::intercode::intercode::create(), error_stmt_end_set, find_closing(), in_disambiguation(), lassert, lassert2, llog, open_transactions, prev_yylex(), run_hinter, start(), TOK_LEFT_BRACE, TOK_LEFT_PAR, TOK_PACK_BODY, TOK_PACK_ERROR_COND, TOK_PACK_ERROR_FOR_COND, TOK_PACK_ERROR_STMT, TOK_PAD_TO_BE_DISCARDED, TOK_RIGHT_BRACE, TOK_RIGHT_PAR, TOK_SEMICOLON, TOK_START_TO_BE_DISCARDED, token_list, token_list_pos, unpack(), and yylex().

{
        lassert( pack_type > bison_token::_PACK_FIRST && pack_type < bison_token::_PACK_LAST );
        // save state and disable running the hinter
        bool run_hinter_old = run_hinter;
        run_hinter = false;
        // insert a dommy token, it will be overwritten by a pack token in commit()
        start( bison_token::TOK_START_TO_BE_DISCARDED );
        // skip it
        yylex();
        switch (pack_type) {
                case bison_token::TOK_PACK_BODY:
                        find_closing( bison_token::TOK_RIGHT_BRACE,
                                        bison_token::TOK_LEFT_BRACE, start_loc );
                        break;
                case bison_token::TOK_PACK_ERROR_COND:
                        find_closing( bison_token::TOK_RIGHT_PAR,
                                        bison_token::TOK_LEFT_PAR, start_loc );
                        break;
                case bison_token::TOK_PACK_ERROR_FOR_COND:
                        find_closing( bison_token::TOK_SEMICOLON,
                                        bison_token::TOK_SEMICOLON, start_loc );
                        break;
                case bison_token::TOK_PACK_ERROR_STMT:
                        // skip all tokens until one in the terminator set is read
                        while (error_stmt_end_set.find( yylex()->type_get() ) == error_stmt_end_set.end())
                                ;
                        /* if the terminating token was ';', skip it too; this solves "if(1)int;else;" */
                        if (prev_yylex()->type_get() == bison_token::TOK_SEMICOLON)
                                yylex();
                        break;
                default:
                        lassert2( false, "This type of packing is not implemented yet." );
        }
        // 'to' will point just after the terminating token (which we do *not* want in the pack)
        token_list_iterator to = token_list_pos;
        commit( bison_token::TOK_PAD_TO_BE_DISCARDED );
        token_list_iterator from = token_list_pos;

        // remember not to pack the pack token nor the terminating token
        ++from;
        --to;

        // location of the pack token is the location of the first token in the pack
        // its end_location is the location of the token that terminated this pack
        //   (it is *not* included in the pack)
        ptr<bison_pack_token> pack_tok = bison_pack_token::create(
                        (*from)->location_get(), pack_type, (*to)->location_get() );
        // the actual packing:
        ptr<token_list_type> the_pack = pack_tok->pack_get();
        the_pack->splice( the_pack->end(), *token_list, from, to );
        // when rolling back, unpack the pack just before the terminating token
        ptr<action> unpack = undo_unpack::create( token_list, to, the_pack );
        if (in_disambiguation())
                open_transactions->back()->add_undo_action( unpack );

        llog(ml) << "replacing " << ptr<bison_token>(*token_list_pos) <<
                " with " << ptr<bison_token>(pack_tok) << "\n";
        *token_list_pos = pack_tok;
        // restore state
        run_hinter = run_hinter_old;

        return pack_tok;
}

void lestes::lang::cplus::syn::one_manager::unpack

(

)

Definition at line 512 of file manager.cc.

References _PACK_FIRST, _PACK_LAST, lassert, llog, token_list, and token_list_pos.

Referenced by pack().

{
        const ptr<bison_token> & next_tok = *token_list_pos;
        lassert( next_tok->type_get() > bison_token::_PACK_FIRST &&
                        next_tok->type_get() < bison_token::_PACK_LAST );
        llog(ml) << "unpacking " << next_tok << "\n";

        const ptr<bison_pack_token> & pack_tok = next_tok.dncast<bison_pack_token>();

        // We cannot use token_list_pos, as splice "moves the iterator away"...
        token_list_iterator pos_after_pack = token_list_pos;
        ++pos_after_pack;
        token_list->splice( pos_after_pack, *(pack_tok->pack_get()) );
        // ...now pos_after_pack points to token following the last unpacked one, not to the first of the pack.
        token_list_pos = token_list->erase( token_list_pos );
}

bool lestes::lang::cplus::syn::one_manager::in_disambiguation

(

)

const

Definition at line 325 of file manager.cc.

References open_transactions.

Referenced by commit(), install_undo_action(), pack(), rollback(), and yylex().

{
        return !open_transactions->empty();
}

void lestes::lang::cplus::syn::one_manager::install_undo_action

(

ptr< action >

a

)

Definition at line 529 of file manager.cc.

References in_disambiguation(), lassert, and open_transactions.

{
        lassert( in_disambiguation() );
        open_transactions->back()->add_undo_action(a);
}

bool lestes::lang::cplus::syn::one_manager::failing_get

(

)

const

Definition at line 588 of file manager.cc.

References failing.

{
        return failing;
}

void lestes::lang::cplus::syn::one_manager::failing_set_true

(

)

Definition at line 593 of file manager.cc.

References failing.

Referenced by find_closing().

{
        failing = true;
}

---

Member Data Documentation

srp<streamer> lestes::lang::cplus::syn::one_manager::src [private]

Definition at line 240 of file manager.cc.

Referenced by one_manager(), and peek().

srp<bison_token> lestes::lang::cplus::syn::one_manager::last_token [private]

Definition at line 241 of file manager.cc.

Referenced by one_manager(), prev_yylex(), and yylex().

bool lestes::lang::cplus::syn::one_manager::run_hinter [protected]

Definition at line 243 of file manager.cc.

Referenced by one_manager(), pack(), and yylex().

bool lestes::lang::cplus::syn::one_manager::failing [protected]

Definition at line 244 of file manager.cc.

Referenced by failing_get(), failing_set_true(), and one_manager().

srp<token_list_type> lestes::lang::cplus::syn::one_manager::token_list [protected]

Definition at line 245 of file manager.cc.

Referenced by back_up(), commit(), one_manager(), pack(), peek(), rollback(), start(), unpack(), and yylex().

token_list_iterator lestes::lang::cplus::syn::one_manager::token_list_pos [protected]

Definition at line 246 of file manager.cc.

Referenced by back_up(), commit(), one_manager(), pack(), peek(), rollback(), start(), unpack(), and yylex().

srp< list< srp<transaction> > > lestes::lang::cplus::syn::one_manager::open_transactions [protected]

Definition at line 248 of file manager.cc.

Referenced by back_up(), commit(), in_disambiguation(), install_undo_action(), one_manager(), pack(), rollback(), and start().

std::set< int > lestes::lang::cplus::syn::one_manager::error_stmt_end_set [protected]

Contains a set of skeletal tokens used in error recovery.

Definition at line 263 of file manager.cc.

Referenced by init(), and pack().

---

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

• manager.cc

---