From 9ce34162d1d70586075da8e84ba930f671e203ce Mon Sep 17 00:00:00 2001 From: Charles Baker Date: Sat, 27 May 2023 20:24:21 +1200 Subject: [PATCH] Inline trivial methods in parser generator --- src/lalr/GrammarItem.hpp | 18 ++-- src/lalr/{GrammarItem.cpp => GrammarItem.ipp} | 27 ++++-- src/lalr/GrammarLookahead.hpp | 18 ++-- ...mmarLookahead.cpp => GrammarLookahead.ipp} | 9 +- src/lalr/GrammarProduction.hpp | 45 +++++----- ...arProduction.cpp => GrammarProduction.ipp} | 13 ++- src/lalr/GrammarProductionLess.hpp | 4 +- ...tionLess.cpp => GrammarProductionLess.ipp} | 6 +- src/lalr/GrammarStateLess.hpp | 8 +- ...mmarStateLess.cpp => GrammarStateLess.ipp} | 8 +- src/lalr/GrammarSymbol.cpp | 83 +---------------- src/lalr/GrammarSymbol.hpp | 35 ++++---- src/lalr/GrammarSymbol.ipp | 90 +++++++++++++++++++ src/lalr/lalr.forge | 5 -- 14 files changed, 207 insertions(+), 162 deletions(-) rename src/lalr/{GrammarItem.cpp => GrammarItem.ipp} (81%) rename src/lalr/{GrammarLookahead.cpp => GrammarLookahead.ipp} (94%) rename src/lalr/{GrammarProduction.cpp => GrammarProduction.ipp} (93%) rename src/lalr/{GrammarProductionLess.cpp => GrammarProductionLess.ipp} (92%) rename src/lalr/{GrammarStateLess.cpp => GrammarStateLess.ipp} (82%) create mode 100644 src/lalr/GrammarSymbol.ipp diff --git a/src/lalr/GrammarItem.hpp b/src/lalr/GrammarItem.hpp index d46b40d..13f64ad 100644 --- a/src/lalr/GrammarItem.hpp +++ b/src/lalr/GrammarItem.hpp @@ -16,14 +16,16 @@ class GrammarItem mutable int index_; public: - GrammarItem(); - GrammarItem( GrammarProduction* production, int position ); - int index() const; - int production() const; - int position() const; - bool dot_at_beginning() const; - bool operator<( const GrammarItem& item ) const; - void set_index( int index ) const; + inline GrammarItem(); + inline GrammarItem( GrammarProduction* production, int position ); + inline int index() const; + inline int production() const; + inline int position() const; + inline bool dot_at_beginning() const; + inline bool operator<( const GrammarItem& item ) const; + inline void set_index( int index ) const; }; } + +#include "GrammarItem.ipp" diff --git a/src/lalr/GrammarItem.cpp b/src/lalr/GrammarItem.ipp similarity index 81% rename from src/lalr/GrammarItem.cpp rename to src/lalr/GrammarItem.ipp index 801b532..059c1ff 100644 --- a/src/lalr/GrammarItem.cpp +++ b/src/lalr/GrammarItem.ipp @@ -1,7 +1,8 @@ // -// GrammarItem.cpp +// GrammarItem.ipp // Copyright (c) Charles Baker. All rights reserved. // +#pragma once #include "GrammarItem.hpp" #include "GrammarSymbol.hpp" @@ -10,11 +11,8 @@ #include #include -using std::find; -using std::string; -using std::vector; -using std::numeric_limits; -using namespace lalr; +namespace lalr +{ /** // Constructor. @@ -40,11 +38,18 @@ GrammarItem::GrammarItem( GrammarProduction* production, int position ) , position_( position ) , index_( 0 ) { + using std::numeric_limits; LALR_ASSERT( production_ >= 0 && production_ < numeric_limits::max() ); LALR_ASSERT( position_ >= 0 && position_ < numeric_limits::max() ); LALR_ASSERT( position_ >= 0 && position_ < production->length() + 1 ); } +/** +// Get the index of this item. +// +// @return +// The index of this item. +*/ int GrammarItem::index() const { return index_; @@ -88,7 +93,7 @@ bool GrammarItem::dot_at_beginning() const // The item to compare this item with. // // @return -// True if this items production is less than \e item's or if this item's +// True if this item's production is less than \e item's or if this item's // production is the same as \e item's then if this item's next nodes // are lexically less than item's otherwise false. */ @@ -100,7 +105,15 @@ bool GrammarItem::operator<( const GrammarItem& item ) const ; } +/** +// Set the index of this item. +// +// @param index +// The index to set this item (assumed >= 0). +*/ void GrammarItem::set_index( int index ) const { index_ = index; } + +} diff --git a/src/lalr/GrammarLookahead.hpp b/src/lalr/GrammarLookahead.hpp index d67f3f2..d081750 100644 --- a/src/lalr/GrammarLookahead.hpp +++ b/src/lalr/GrammarLookahead.hpp @@ -15,18 +15,20 @@ class GrammarLookahead GrammarSymbolSet lookaheads_; public: - GrammarLookahead( GrammarItem* item, size_t symbols ); - GrammarLookahead( GrammarLookahead&& item ); + inline GrammarLookahead( GrammarItem* item, size_t symbols ); + inline GrammarLookahead( GrammarLookahead&& item ); - GrammarItem* item() const; - const std::vector& propagate_to() const; - const GrammarSymbolSet& lookaheads() const; - void set_item( GrammarItem* item ); - void add_propagate_to( GrammarLookahead* propagate_to ); - size_t add_lookaheads( const GrammarSymbolSet& lookaheads ); + inline GrammarItem* item() const; + inline const std::vector& propagate_to() const; + inline const GrammarSymbolSet& lookaheads() const; + inline void set_item( GrammarItem* item ); + inline void add_propagate_to( GrammarLookahead* propagate_to ); + inline size_t add_lookaheads( const GrammarSymbolSet& lookaheads ); GrammarLookahead( const GrammarLookahead& item ) = delete; GrammarLookahead& operator=( const GrammarLookahead& item ) = delete; }; } + +#include "GrammarLookahead.ipp" diff --git a/src/lalr/GrammarLookahead.cpp b/src/lalr/GrammarLookahead.ipp similarity index 94% rename from src/lalr/GrammarLookahead.cpp rename to src/lalr/GrammarLookahead.ipp index 500dd13..7a0f527 100644 --- a/src/lalr/GrammarLookahead.cpp +++ b/src/lalr/GrammarLookahead.ipp @@ -1,15 +1,16 @@ // -// GrammarLookahead.cpp +// GrammarLookahead.ipp // Copyright (c) Charles Baker. All rights reserved. // +#pragma once #include "GrammarLookahead.hpp" #include "GrammarItem.hpp" #include "assert.hpp" #include -using std::vector; -using namespace lalr; +namespace lalr +{ GrammarLookahead::GrammarLookahead( GrammarItem* item, size_t symbols ) : item_( item ) @@ -58,3 +59,5 @@ size_t GrammarLookahead::add_lookaheads( const GrammarSymbolSet& lookaheads ) { return lookaheads_.insert( lookaheads ); } + +} diff --git a/src/lalr/GrammarProduction.hpp b/src/lalr/GrammarProduction.hpp index 00fb13e..cfd9e42 100644 --- a/src/lalr/GrammarProduction.hpp +++ b/src/lalr/GrammarProduction.hpp @@ -1,6 +1,7 @@ -#ifndef LALR_GRAMMARPRODUCTION_HPP_INCLUDED -#define LALR_GRAMMARPRODUCTION_HPP_INCLUDED +#pragma once +#include "GrammarSymbol.hpp" +#include "GrammarAction.hpp" #include #include #include @@ -26,31 +27,31 @@ class GrammarProduction const GrammarSymbol* precedence_symbol_; /// The symbol that defines precedence for this production or null to use the right most terminal. public: - GrammarProduction( int index, GrammarSymbol* symbol, int line, int column, const GrammarAction* action ); + inline GrammarProduction( int index, GrammarSymbol* symbol, int line, int column, const GrammarAction* action ); - int index() const; - GrammarSymbol* symbol() const; - int line() const; - int column() const; - int count_references_to_symbol( const GrammarSymbol* symbol ) const; - bool nullable_after( int position ) const; - const GrammarSymbol* find_rightmost_terminal_symbol() const; - const GrammarSymbol* symbol_by_position( int position ) const; - const std::vector& symbols() const; - int length() const; - const GrammarAction* action() const; - int action_index() const; - const GrammarSymbol* precedence_symbol() const; - int precedence() const; + inline int index() const; + inline GrammarSymbol* symbol() const; + inline int line() const; + inline int column() const; + inline int count_references_to_symbol( const GrammarSymbol* symbol ) const; + inline bool nullable_after( int position ) const; + inline const GrammarSymbol* find_rightmost_terminal_symbol() const; + inline const GrammarSymbol* symbol_by_position( int position ) const; + inline const std::vector& symbols() const; + inline int length() const; + inline const GrammarAction* action() const; + inline int action_index() const; + inline const GrammarSymbol* precedence_symbol() const; + inline int precedence() const; - void append_symbol( GrammarSymbol* symbol ); - void set_action( const GrammarAction* action ); - void set_precedence_symbol( const GrammarSymbol* symbol ); - void replace_references_to_symbol( GrammarSymbol* to_symbol, GrammarSymbol* with_symbol ); + inline void append_symbol( GrammarSymbol* symbol ); + inline void set_action( const GrammarAction* action ); + inline void set_precedence_symbol( const GrammarSymbol* symbol ); + inline void replace_references_to_symbol( GrammarSymbol* to_symbol, GrammarSymbol* with_symbol ); static const int INVALID_INDEX = -1; }; } -#endif +#include "GrammarProduction.ipp" diff --git a/src/lalr/GrammarProduction.cpp b/src/lalr/GrammarProduction.ipp similarity index 93% rename from src/lalr/GrammarProduction.cpp rename to src/lalr/GrammarProduction.ipp index 47498c5..497ee96 100644 --- a/src/lalr/GrammarProduction.cpp +++ b/src/lalr/GrammarProduction.ipp @@ -1,15 +1,16 @@ // -// GrammarProduction.cpp +// GrammarProduction.ipp // Copyright (c) Charles Baker. All rights reserved. // +#pragma once #include "GrammarProduction.hpp" #include "GrammarSymbol.hpp" #include "GrammarAction.hpp" #include "assert.hpp" -using std::vector; -using namespace lalr; +namespace lalr +{ /* // Constructor. @@ -95,6 +96,7 @@ int GrammarProduction::column() const */ int GrammarProduction::count_references_to_symbol( const GrammarSymbol* symbol ) const { + using std::vector; int references = 0; for ( vector::const_iterator i = symbols_.begin(); i != symbols_.end(); ++i ) { @@ -116,6 +118,7 @@ int GrammarProduction::count_references_to_symbol( const GrammarSymbol* symbol ) */ bool GrammarProduction::nullable_after( int position ) const { + using std::vector; LALR_ASSERT( position >= 0 && position <= length() ); if ( position >= 0 && position < length() ) { @@ -146,6 +149,7 @@ bool GrammarProduction::nullable_after( int position ) const */ const GrammarSymbol* GrammarProduction::find_rightmost_terminal_symbol() const { + using std::vector; vector::const_reverse_iterator i = symbols_.rbegin(); while ( i != symbols_.rend() && (*i)->symbol_type() != SYMBOL_TERMINAL ) { @@ -281,6 +285,7 @@ void GrammarProduction::replace_references_to_symbol( GrammarSymbol* to_symbol, precedence_symbol_ = with_symbol; } + using std::vector; for ( vector::iterator i = symbols_.begin(); i != symbols_.end(); ++i ) { if ( *i == to_symbol ) @@ -289,3 +294,5 @@ void GrammarProduction::replace_references_to_symbol( GrammarSymbol* to_symbol, } } } + +} diff --git a/src/lalr/GrammarProductionLess.hpp b/src/lalr/GrammarProductionLess.hpp index 5092573..ed5b1c7 100644 --- a/src/lalr/GrammarProductionLess.hpp +++ b/src/lalr/GrammarProductionLess.hpp @@ -11,7 +11,9 @@ class GrammarProduction; class GrammarProductionLess { public: - bool operator()( const GrammarProduction* lhs, const GrammarProduction* rhs ) const; + inline bool operator()( const GrammarProduction* lhs, const GrammarProduction* rhs ) const; }; } + +#include "GrammarProductionLess.ipp" diff --git a/src/lalr/GrammarProductionLess.cpp b/src/lalr/GrammarProductionLess.ipp similarity index 92% rename from src/lalr/GrammarProductionLess.cpp rename to src/lalr/GrammarProductionLess.ipp index 1d6d67b..7cf55c9 100644 --- a/src/lalr/GrammarProductionLess.cpp +++ b/src/lalr/GrammarProductionLess.ipp @@ -2,12 +2,14 @@ // GrammarProductionLess.cpp // Copyright (c) Charles Baker. All rights reserved. // +#pragma once #include "GrammarProductionLess.hpp" #include "GrammarProduction.hpp" #include "assert.hpp" -using namespace lalr; +namespace lalr +{ bool GrammarProductionLess::operator()( const GrammarProduction* lhs, const GrammarProduction* rhs ) const { @@ -15,3 +17,5 @@ bool GrammarProductionLess::operator()( const GrammarProduction* lhs, const Gram LALR_ASSERT( rhs->index() >= 0 ); return lhs->index() < rhs->index(); } + +} diff --git a/src/lalr/GrammarStateLess.hpp b/src/lalr/GrammarStateLess.hpp index a0e3fd8..c290972 100644 --- a/src/lalr/GrammarStateLess.hpp +++ b/src/lalr/GrammarStateLess.hpp @@ -1,6 +1,6 @@ -#ifndef LALR_GRAMMARSTATELESS_HPP_INCLUDED -#define LALR_GRAMMARSTATELESS_HPP_INCLUDED +#pragma once +#include "GrammarState.hpp" #include namespace lalr @@ -14,9 +14,9 @@ class GrammarState; class GrammarStateLess { public: - bool operator()( const std::shared_ptr& lhs, const std::shared_ptr& rhs ) const; + inline bool operator()( const std::shared_ptr& lhs, const std::shared_ptr& rhs ) const; }; } -#endif +#include "GrammarStateLess.ipp" diff --git a/src/lalr/GrammarStateLess.cpp b/src/lalr/GrammarStateLess.ipp similarity index 82% rename from src/lalr/GrammarStateLess.cpp rename to src/lalr/GrammarStateLess.ipp index 6ecfefc..b863d4e 100644 --- a/src/lalr/GrammarStateLess.cpp +++ b/src/lalr/GrammarStateLess.ipp @@ -1,14 +1,18 @@ // -// GrammarStateLess.hpp +// GrammarStateLess.ipp // Copyright (c) Charles Baker. All rights reserved. // +#pragma once #include "GrammarStateLess.hpp" #include "GrammarState.hpp" -using namespace lalr; +namespace lalr +{ bool GrammarStateLess::operator()( const std::shared_ptr& lhs, const std::shared_ptr& rhs ) const { return *lhs < *rhs; } + +} diff --git a/src/lalr/GrammarSymbol.cpp b/src/lalr/GrammarSymbol.cpp index 52efc8d..e0bba45 100644 --- a/src/lalr/GrammarSymbol.cpp +++ b/src/lalr/GrammarSymbol.cpp @@ -2,16 +2,11 @@ // GrammarSymbol.cpp // Copyright (c) Charles Baker. All rights reserved. // - #include "GrammarSymbol.hpp" #include "GrammarProduction.hpp" #include "assert.hpp" #include -using std::set; -using std::vector; -using std::shared_ptr; -using std::make_pair; using namespace lalr; GrammarSymbol::GrammarSymbol( const std::string& lexeme ) @@ -31,81 +26,6 @@ GrammarSymbol::GrammarSymbol( const std::string& lexeme ) { } -const std::string& GrammarSymbol::lexeme() const -{ - return lexeme_; -} - -const std::string& GrammarSymbol::identifier() const -{ - return identifier_; -} - -SymbolType GrammarSymbol::symbol_type() const -{ - return symbol_type_; -} - -LexemeType GrammarSymbol::lexeme_type() const -{ - return lexeme_type_; -} - -bool GrammarSymbol::literal() const -{ - return lexeme_type_ == LEXEME_LITERAL; -} - -Associativity GrammarSymbol::associativity() const -{ - return associativity_; -} - -int GrammarSymbol::precedence() const -{ - return precedence_; -} - -int GrammarSymbol::line() const -{ - return line_; -} - -int GrammarSymbol::index() const -{ - return index_; -} - -bool GrammarSymbol::nullable() const -{ - return nullable_; -} - -bool GrammarSymbol::referenced_in_precedence_directive() const -{ - return referenced_in_precedence_directive_; -} - -const GrammarSymbolSet& GrammarSymbol::first() const -{ - return first_; -} - -const GrammarSymbolSet& GrammarSymbol::follow() const -{ - return follow_; -} - -const std::vector& GrammarSymbol::productions() const -{ - return productions_; -} - -const std::multimap& GrammarSymbol::reachable_productions_by_first_symbol() const -{ - return reachable_productions_by_first_symbol_; -} - std::multimap::const_iterator GrammarSymbol::find_reachable_productions( const GrammarSymbol& first_symbol ) const { return reachable_productions_by_first_symbol_.find( &first_symbol ); @@ -218,6 +138,7 @@ void GrammarSymbol::append_reachable_production( GrammarProduction* production ) LALR_ASSERT( production ); const GrammarSymbol* first_symbol = production->symbol_by_position( 0 ); LALR_ASSERT( first_symbol ); + using std::make_pair; reachable_productions_by_first_symbol_.insert( make_pair(first_symbol, production) ); } @@ -502,6 +423,7 @@ int GrammarSymbol::calculate_first() int added = 0; if ( symbol_type_ == SYMBOL_NON_TERMINAL ) { + using std::vector; for ( vector::const_iterator i = productions_.begin(); i != productions_.end(); ++i ) { const GrammarProduction* production = *i; @@ -545,6 +467,7 @@ int GrammarSymbol::calculate_first() */ int GrammarSymbol::calculate_follow() { + using std::vector; int added = 0; for ( vector::const_iterator i = productions_.begin(); i != productions_.end(); ++i ) { diff --git a/src/lalr/GrammarSymbol.hpp b/src/lalr/GrammarSymbol.hpp index 6b63ca9..d999f86 100644 --- a/src/lalr/GrammarSymbol.hpp +++ b/src/lalr/GrammarSymbol.hpp @@ -1,5 +1,4 @@ -#ifndef LALR_GRAMMARSYMBOL_HPP_INCLUDED -#define LALR_GRAMMARSYMBOL_HPP_INCLUDED +#pragma once #include "GrammarSymbolSet.hpp" #include "SymbolType.hpp" @@ -35,21 +34,21 @@ class GrammarSymbol public: GrammarSymbol( const std::string& lexeme ); - const std::string& lexeme() const; - const std::string& identifier() const; - SymbolType symbol_type() const; - LexemeType lexeme_type() const; - bool literal() const; - Associativity associativity() const; - int precedence() const; - int line() const; - int index() const; - bool nullable() const; - bool referenced_in_precedence_directive() const; - const GrammarSymbolSet& first() const; - const GrammarSymbolSet& follow() const; - const std::vector& productions() const; - const std::multimap& reachable_productions_by_first_symbol() const; + inline const std::string& lexeme() const; + inline const std::string& identifier() const; + inline SymbolType symbol_type() const; + inline LexemeType lexeme_type() const; + inline bool literal() const; + inline Associativity associativity() const; + inline int precedence() const; + inline int line() const; + inline int index() const; + inline bool nullable() const; + inline bool referenced_in_precedence_directive() const; + inline const GrammarSymbolSet& first() const; + inline const GrammarSymbolSet& follow() const; + inline const std::vector& productions() const; + inline const std::multimap& reachable_productions_by_first_symbol() const; std::multimap::const_iterator find_reachable_productions( const GrammarSymbol& first_symbol ) const; GrammarSymbol* implicit_terminal() const; bool matches( const std::string& lexeme, SymbolType symbol_type ) const; @@ -78,4 +77,4 @@ public: } -#endif +#include "GrammarSymbol.ipp" diff --git a/src/lalr/GrammarSymbol.ipp b/src/lalr/GrammarSymbol.ipp new file mode 100644 index 0000000..86c6e79 --- /dev/null +++ b/src/lalr/GrammarSymbol.ipp @@ -0,0 +1,90 @@ +// +// GrammarSymbol.ipp +// Copyright (c) Charles Baker. All rights reserved. +// +#pragma once + +#include "GrammarSymbol.hpp" +#include "GrammarProduction.hpp" +#include "assert.hpp" +#include + +namespace lalr +{ + +const std::string& GrammarSymbol::lexeme() const +{ + return lexeme_; +} + +const std::string& GrammarSymbol::identifier() const +{ + return identifier_; +} + +SymbolType GrammarSymbol::symbol_type() const +{ + return symbol_type_; +} + +LexemeType GrammarSymbol::lexeme_type() const +{ + return lexeme_type_; +} + +bool GrammarSymbol::literal() const +{ + return lexeme_type_ == LEXEME_LITERAL; +} + +Associativity GrammarSymbol::associativity() const +{ + return associativity_; +} + +int GrammarSymbol::precedence() const +{ + return precedence_; +} + +int GrammarSymbol::line() const +{ + return line_; +} + +int GrammarSymbol::index() const +{ + return index_; +} + +bool GrammarSymbol::nullable() const +{ + return nullable_; +} + +bool GrammarSymbol::referenced_in_precedence_directive() const +{ + return referenced_in_precedence_directive_; +} + +const GrammarSymbolSet& GrammarSymbol::first() const +{ + return first_; +} + +const GrammarSymbolSet& GrammarSymbol::follow() const +{ + return follow_; +} + +const std::vector& GrammarSymbol::productions() const +{ + return productions_; +} + +const std::multimap& GrammarSymbol::reachable_productions_by_first_symbol() const +{ + return reachable_productions_by_first_symbol_; +} + +} diff --git a/src/lalr/lalr.forge b/src/lalr/lalr.forge index 6c67411..41a8921 100644 --- a/src/lalr/lalr.forge +++ b/src/lalr/lalr.forge @@ -16,13 +16,8 @@ for _, cc in toolsets('^cc.*') do 'GrammarAction.cpp', 'GrammarCompiler.cpp', 'GrammarGenerator.cpp', - 'GrammarItem.cpp', - 'GrammarLookahead.cpp', 'GrammarParser.cpp', - 'GrammarProduction.cpp', - 'GrammarProductionLess.cpp', 'GrammarState.cpp', - 'GrammarStateLess.cpp', 'GrammarSymbol.cpp', 'GrammarSymbolSet.cpp', 'GrammarTransition.cpp'