From 16ebbc56831164d07d66afb51d32de7cec8243ad Mon Sep 17 00:00:00 2001 From: mingodad Date: Fri, 23 Jun 2023 20:20:32 +0200 Subject: [PATCH 1/4] Add column info to error messages in ErrorPolicy --- src/lalr/ErrorPolicy.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/lalr/ErrorPolicy.cpp b/src/lalr/ErrorPolicy.cpp index d458f0d..793ac8e 100644 --- a/src/lalr/ErrorPolicy.cpp +++ b/src/lalr/ErrorPolicy.cpp @@ -33,9 +33,9 @@ ErrorPolicy::~ErrorPolicy() // @param ... // Arguments as described by *format*. */ -void ErrorPolicy::lalr_error( int line, int /*column*/, int /*error*/, const char* format, va_list args ) +void ErrorPolicy::lalr_error( int line, int column, int /*error*/, const char* format, va_list args ) { - fprintf( stderr, "lalr (%d): ERROR: ", line ); + fprintf( stderr, "lalr (%d:%d): ERROR: ", line, column ); vfprintf( stderr, format, args ); fprintf( stderr, "\n" ); } From 29d91e8ec851f7b1d954c00ed58cb3fa5771b061 Mon Sep 17 00:00:00 2001 From: mingodad Date: Mon, 26 Jun 2023 11:01:04 +0200 Subject: [PATCH 2/4] Add column info to GrammarSymbol and error messages --- src/lalr/Grammar.cpp | 86 +++++++++++++++++++------------------- src/lalr/Grammar.hpp | 24 +++++------ src/lalr/GrammarParser.cpp | 46 ++++++++++++-------- src/lalr/GrammarParser.hpp | 4 +- src/lalr/GrammarSymbol.cpp | 7 ++++ src/lalr/GrammarSymbol.hpp | 3 ++ src/lalr/GrammarSymbol.ipp | 5 +++ 7 files changed, 102 insertions(+), 73 deletions(-) diff --git a/src/lalr/Grammar.cpp b/src/lalr/Grammar.cpp index 7adc17a..360a8e0 100644 --- a/src/lalr/Grammar.cpp +++ b/src/lalr/Grammar.cpp @@ -39,10 +39,10 @@ Grammar::Grammar() , error_symbol_( nullptr ) , whitespace_symbol_( nullptr ) { - start_symbol_ = add_symbol( ".start", 0, LEXEME_NULL, SYMBOL_NON_TERMINAL ); - end_symbol_ = add_symbol( ".end", 0, LEXEME_NULL, SYMBOL_END ); - error_symbol_ = add_symbol( "error", 0, LEXEME_NULL, SYMBOL_NULL ); - whitespace_symbol_ = add_symbol( ".whitespace", 0, LEXEME_NULL, SYMBOL_NULL ); + start_symbol_ = add_symbol( ".start", 0, 0, LEXEME_NULL, SYMBOL_NON_TERMINAL ); + end_symbol_ = add_symbol( ".end", 0, 0, LEXEME_NULL, SYMBOL_END ); + error_symbol_ = add_symbol( "error", 0, 0, LEXEME_NULL, SYMBOL_NULL ); + whitespace_symbol_ = add_symbol( ".whitespace", 0, 0, LEXEME_NULL, SYMBOL_NULL ); } Grammar::~Grammar() @@ -153,14 +153,14 @@ Grammar& Grammar::precedence() return *this; } -Grammar& Grammar::production( const char* identifier, int line ) +Grammar& Grammar::production( const char* identifier, int line, int column ) { LALR_ASSERT( identifier ); associativity_ = ASSOCIATE_NULL; active_whitespace_directive_ = false; active_precedence_directive_ = false; active_production_ = nullptr; - active_symbol_ = non_terminal_symbol( identifier, line ); + active_symbol_ = non_terminal_symbol(identifier, line , column); return *this; } @@ -175,44 +175,44 @@ Grammar& Grammar::end_production() return *this; } -Grammar& Grammar::end_expression( int line ) +Grammar& Grammar::end_expression(int line, int column) { LALR_ASSERT( line >= 1 ); // If there is an active symbol but no active production then an empty - // production is being specified (the nil action marks the end of a + // production is being specified (the nil action marks the end of a // production for which no symbols have been specified). if ( active_symbol_ ) { if ( !active_production_ ) { - active_production_ = add_production( active_symbol_, line ); + active_production_ = add_production( active_symbol_, line , column); } } active_production_ = nullptr; return *this; } -Grammar& Grammar::error( int line ) +Grammar& Grammar::error(int line, int column) { LALR_ASSERT( line >= 1 ); if ( associativity_ != ASSOCIATE_NULL ) { GrammarSymbol* symbol = error_symbol(); - symbol->set_associativity( associativity_ ); - symbol->set_precedence( precedence_ ); + symbol->set_associativity( associativity_ ); + symbol->set_precedence( precedence_ ); } else if ( active_symbol_ ) { if ( !active_production_ ) { - active_production_ = add_production( active_symbol_, line ); + active_production_ = add_production( active_symbol_, line , column ); } - active_production_->append_symbol( error_symbol() ); + active_production_->append_symbol( error_symbol() ); } return *this; } -Grammar& Grammar::action( const char* identifier, int line ) +Grammar& Grammar::action(const char* identifier, int line, int column) { LALR_ASSERT( identifier ); LALR_ASSERT( line >= 1 ); @@ -221,7 +221,7 @@ Grammar& Grammar::action( const char* identifier, int line ) { if ( !active_production_ ) { - active_production_ = add_production( active_symbol_, line ); + active_production_ = add_production(active_symbol_, line , column); } active_production_->set_action( add_action(identifier) ); active_production_ = nullptr; @@ -229,7 +229,7 @@ Grammar& Grammar::action( const char* identifier, int line ) return *this; } -Grammar& Grammar::literal( const char* literal, int line ) +Grammar& Grammar::literal(const char* literal, int line, int column) { LALR_ASSERT( literal ); LALR_ASSERT( line >= 0 ); @@ -240,7 +240,7 @@ Grammar& Grammar::literal( const char* literal, int line ) } else if ( associativity_ != ASSOCIATE_NULL ) { - GrammarSymbol* symbol = literal_symbol( literal, line ); + GrammarSymbol* symbol = literal_symbol(literal, line , column); symbol->set_associativity( associativity_ ); symbol->set_precedence( precedence_ ); } @@ -248,24 +248,24 @@ Grammar& Grammar::literal( const char* literal, int line ) { if ( !active_production_ ) { - active_production_ = add_production( active_symbol_, line ); - } + active_production_ = add_production( active_symbol_, line, column ); + } if ( active_precedence_directive_ ) { - GrammarSymbol* symbol = literal_symbol( literal, line ); + GrammarSymbol* symbol = literal_symbol(literal, line , column); active_production_->set_precedence_symbol( symbol ); symbol->set_referenced_in_precedence_directive( true ); active_precedence_directive_ = false; } else { - active_production_->append_symbol( literal_symbol(literal, line) ); + active_production_->append_symbol( literal_symbol(literal, line, column) ); } } return *this; } -Grammar& Grammar::regex( const char* regex, int line ) +Grammar& Grammar::regex( const char* regex, int line, int column ) { LALR_ASSERT( regex ); LALR_ASSERT( line >= 0 ); @@ -276,7 +276,7 @@ Grammar& Grammar::regex( const char* regex, int line ) } else if ( associativity_ != ASSOCIATE_NULL ) { - GrammarSymbol* symbol = regex_symbol( regex, line ); + GrammarSymbol* symbol = regex_symbol(regex, line , column); symbol->set_associativity( associativity_ ); symbol->set_precedence( precedence_ ); } @@ -284,31 +284,31 @@ Grammar& Grammar::regex( const char* regex, int line ) { if ( !active_production_ ) { - active_production_ = add_production( active_symbol_, line ); + active_production_ = add_production(active_symbol_, line , column); } if ( active_precedence_directive_ ) { - GrammarSymbol* symbol = regex_symbol( regex, line ); + GrammarSymbol* symbol = regex_symbol(regex, line , column); symbol->set_referenced_in_precedence_directive( true ); active_production_->set_precedence_symbol( symbol ); active_precedence_directive_ = false; } else { - active_production_->append_symbol( regex_symbol(regex, line) ); + active_production_->append_symbol( regex_symbol(regex, line , column) ); } } return *this; } -Grammar& Grammar::identifier( const char* identifier, int line ) +Grammar& Grammar::identifier( const char* identifier, int line, int column ) { LALR_ASSERT( identifier ); LALR_ASSERT( line >= 0 ); LALR_ASSERT( active_symbol_ || associativity_ != ASSOCIATE_NULL ); if ( associativity_ != ASSOCIATE_NULL ) { - GrammarSymbol* symbol = non_terminal_symbol( identifier, line ); + GrammarSymbol* symbol = non_terminal_symbol(identifier, line , column); symbol->set_associativity( associativity_ ); symbol->set_precedence( precedence_ ); } @@ -316,45 +316,46 @@ Grammar& Grammar::identifier( const char* identifier, int line ) { if ( !active_production_ ) { - active_production_ = add_production( active_symbol_, line ); + active_production_ = add_production(active_symbol_, line , column); } if ( active_precedence_directive_ ) { - GrammarSymbol* symbol = non_terminal_symbol( identifier, line ); + GrammarSymbol* symbol = non_terminal_symbol(identifier, line , column); symbol->set_referenced_in_precedence_directive( true ); active_production_->set_precedence_symbol( symbol ); active_precedence_directive_ = false; } else { - active_production_->append_symbol( non_terminal_symbol(identifier, line) ); + GrammarSymbol* symbol = non_terminal_symbol( identifier, line, column ); + active_production_->append_symbol( symbol ); } } return *this; } -GrammarSymbol* Grammar::literal_symbol( const char* lexeme, int line ) +GrammarSymbol* Grammar::literal_symbol( const char* lexeme, int line, int column) { LALR_ASSERT( lexeme ); LALR_ASSERT( line >= 0 ); - return add_symbol( lexeme, line, LEXEME_LITERAL, SYMBOL_TERMINAL ); + return add_symbol(lexeme, line, column, LEXEME_LITERAL, SYMBOL_TERMINAL ); } -GrammarSymbol* Grammar::regex_symbol( const char* lexeme, int line ) +GrammarSymbol* Grammar::regex_symbol(const char* lexeme, int line, int column) { LALR_ASSERT( lexeme ); LALR_ASSERT( line >= 0 ); - return add_symbol( lexeme, line, LEXEME_REGULAR_EXPRESSION, SYMBOL_TERMINAL ); + return add_symbol(lexeme, line, column, LEXEME_REGULAR_EXPRESSION, SYMBOL_TERMINAL ); } -GrammarSymbol* Grammar::non_terminal_symbol( const char* lexeme, int line ) +GrammarSymbol* Grammar::non_terminal_symbol(const char* lexeme, int line, int column) { LALR_ASSERT( lexeme ); LALR_ASSERT( line >= 0 ); - return add_symbol( lexeme, line, LEXEME_NULL, SYMBOL_NON_TERMINAL ); + return add_symbol(lexeme, line, column, LEXEME_NULL, SYMBOL_NON_TERMINAL ); } -GrammarSymbol* Grammar::add_symbol( const char* lexeme, int line, LexemeType lexeme_type, SymbolType symbol_type ) +GrammarSymbol* Grammar::add_symbol(const char* lexeme, int line, int column, LexemeType lexeme_type, SymbolType symbol_type ) { LALR_ASSERT( lexeme ); LALR_ASSERT( line >= 0 ); @@ -362,11 +363,12 @@ GrammarSymbol* Grammar::add_symbol( const char* lexeme, int line, LexemeType lex while ( i != symbols_.end() && !(*i)->matches(lexeme, symbol_type) ) { ++i; - } + } if ( i == symbols_.end() ) { unique_ptr symbol( new GrammarSymbol(lexeme) ); symbol->set_line( line ); + symbol->set_column( column ); symbol->set_lexeme_type( lexeme_type ); symbol->set_symbol_type( symbol_type ); symbols_.push_back( std::move(symbol) ); @@ -379,7 +381,7 @@ GrammarSymbol* Grammar::add_symbol( const char* lexeme, int line, LexemeType lex return symbol; } -GrammarProduction* Grammar::add_production( GrammarSymbol* symbol, int line ) +GrammarProduction* Grammar::add_production(GrammarSymbol* symbol, int line, int column) { LALR_ASSERT( symbol ); LALR_ASSERT( line > 0 ); @@ -392,7 +394,7 @@ GrammarProduction* Grammar::add_production( GrammarSymbol* symbol, int line ) productions_.push_back( std::move(production) ); } - unique_ptr production( new GrammarProduction(int(productions_.size()), symbol, line, -1, nullptr) ); + unique_ptr production( new GrammarProduction(int(productions_.size()), symbol, line, column, nullptr) ); symbol->append_production( production.get() ); productions_.push_back( std::move(production) ); return productions_.back().get(); diff --git a/src/lalr/Grammar.hpp b/src/lalr/Grammar.hpp index c76648e..ea9dc60 100644 --- a/src/lalr/Grammar.hpp +++ b/src/lalr/Grammar.hpp @@ -56,21 +56,21 @@ class Grammar Grammar& none( int line ); Grammar& whitespace(); Grammar& precedence(); - Grammar& production( const char* identifier, int line ); + Grammar& production( const char* identifier, int line, int column ); Grammar& end_production(); - Grammar& end_expression( int line ); - Grammar& error( int line ); - Grammar& action( const char* identifier, int line ); - Grammar& literal( const char* literal, int line ); - Grammar& regex( const char* regex, int line ); - Grammar& identifier( const char* identifier, int line ); + Grammar& end_expression( int line, int column ); + Grammar& error( int line, int column ); + Grammar& action( const char* identifier, int line, int column ); + Grammar& literal( const char* literal, int line, int column ); + Grammar& regex( const char* regex, int line, int column ); + Grammar& identifier( const char* identifier, int line, int column ); private: - GrammarSymbol* literal_symbol( const char* lexeme, int line ); - GrammarSymbol* regex_symbol( const char* lexeme, int line ); - GrammarSymbol* non_terminal_symbol( const char* lexeme, int line ); - GrammarSymbol* add_symbol( const char* lexeme, int line, LexemeType lexeme_type, SymbolType symbol_type ); - GrammarProduction* add_production( GrammarSymbol* symbol, int line ); + GrammarSymbol* literal_symbol(const char* lexeme, int line , int column); + GrammarSymbol* regex_symbol(const char* lexeme, int line , int column); + GrammarSymbol* non_terminal_symbol(const char* lexeme, int line , int column); + GrammarSymbol* add_symbol(const char* lexeme, int line, int column, LexemeType lexeme_type, SymbolType symbol_type ); + GrammarProduction* add_production(GrammarSymbol* symbol, int line , int column); GrammarAction* add_action( const char* id ); }; diff --git a/src/lalr/GrammarParser.cpp b/src/lalr/GrammarParser.cpp index a1a53e6..5fed611 100644 --- a/src/lalr/GrammarParser.cpp +++ b/src/lalr/GrammarParser.cpp @@ -19,6 +19,7 @@ GrammarParser::GrammarParser() , grammar_( nullptr ) , position_( nullptr ) , end_( nullptr ) +, line_position_( nullptr ) , line_( 1 ) , lexeme_() , errors_( 0 ) @@ -34,13 +35,13 @@ int GrammarParser::parse( const char* start, const char* finish, ErrorPolicy* er LALR_ASSERT( grammar ); error_policy_ = error_policy; grammar_ = grammar; - position_ = start; + line_position_ = position_ = start; end_ = finish; line_ = 1; errors_ = 0; if ( !match_grammar() ) { - error( 1, LALR_ERROR_SYNTAX, "parsing grammar failed" ); + error(line_, get_line_column(position_), LALR_ERROR_SYNTAX, "parsing grammar failed" ); } return errors_; } @@ -63,12 +64,12 @@ bool GrammarParser::match_statements() while ( match_statement() ) { } - return true; + return true; } bool GrammarParser::match_statement() { - return + return match_associativity_statement() || match_whitespace_statement() || match_production_statement() @@ -93,7 +94,7 @@ bool GrammarParser::match_whitespace_statement() grammar_->whitespace(); if ( match_regex() ) { - grammar_->regex( lexeme_.c_str(), line_ ); + grammar_->regex( lexeme_.c_str(), line_, get_line_column(position_) ); } expect( ";" ); return true; @@ -105,7 +106,7 @@ bool GrammarParser::match_production_statement() { if ( match_identifier() ) { - grammar_->production( lexeme_.c_str(), line_ ); + grammar_->production( lexeme_.c_str(), line_, get_line_column(position_) ); expect( ":" ); match_expressions(); expect( ";" ); @@ -127,22 +128,22 @@ bool GrammarParser::match_symbol() { if ( match_error() ) { - grammar_->error( line_ ); + grammar_->error( line_, get_line_column(position_) ); return true; } else if ( match_literal() ) { - grammar_->literal( lexeme_.c_str(), line_ ); + grammar_->literal( lexeme_.c_str(), line_, get_line_column(position_) ); return true; } else if ( match_regex() ) { - grammar_->regex( lexeme_.c_str(), line_ ); + grammar_->regex( lexeme_.c_str(), line_, get_line_column(position_) ); return true; } else if ( match_identifier() ) { - grammar_->identifier( lexeme_.c_str(), line_ ); + grammar_->identifier( lexeme_.c_str(), line_, get_line_column(position_) ); return true; } return false; @@ -202,12 +203,12 @@ bool GrammarParser::match_action() { if ( match_identifier() ) { - grammar_->action( lexeme_.c_str(), line_ ); + grammar_->action( lexeme_.c_str(), line_, get_line_column(position_) ); } expect( "]" ); return true; } - grammar_->end_expression( line_ ); + grammar_->end_expression(line_, get_line_column(position_)); return false; } @@ -235,7 +236,7 @@ bool GrammarParser::match_literal() expect( "'" ); return true; } - error( line_, LALR_ERROR_UNTERMINATED_LITERAL, "unterminated literal" ); + error(line_, get_line_column(position), LALR_ERROR_UNTERMINATED_LITERAL, "unterminated literal" ); return false; } return false; @@ -297,11 +298,12 @@ bool GrammarParser::match_whitespace() if ( is_new_line(position) ) { ++line_; + line_position_ = position; } ++position; } position_ = position; - return true; + return true; } return false; } @@ -348,7 +350,7 @@ bool GrammarParser::match_block_comment() } } position_ = position; - return true; + return true; } return false; } @@ -388,11 +390,11 @@ bool GrammarParser::expect( const char* lexeme ) return true; } position_ = end_; - error( line_, LALR_ERROR_SYNTAX, "expected '%s' not found", lexeme ); + error(line_, get_line_column(position_), LALR_ERROR_SYNTAX, "expected '%s' not found", lexeme ); return false; } -void GrammarParser::error( int line, int error, const char* format, ... ) +void GrammarParser::error(int line, int column, int error, const char* format, ... ) { LALR_ASSERT( format ); ++errors_; @@ -400,7 +402,7 @@ void GrammarParser::error( int line, int error, const char* format, ... ) { va_list args; va_start( args, format ); - error_policy_->lalr_error( line, 0, error, format, args ); + error_policy_->lalr_error( line, column, error, format, args ); va_end( args ); } } @@ -417,6 +419,7 @@ const char* GrammarParser::new_line( const char* position ) ++position; } ++line_; + line_position_ = position; } else if ( *position == '\r' ) { @@ -426,6 +429,7 @@ const char* GrammarParser::new_line( const char* position ) ++position; } ++line_; + line_position_ = position; } } return position; @@ -435,3 +439,9 @@ bool GrammarParser::is_new_line( const char* position ) { return *position == '\n' || *position == '\r'; } + +int GrammarParser::get_line_column(const char* position) +{ + return position - line_position_; + +} diff --git a/src/lalr/GrammarParser.hpp b/src/lalr/GrammarParser.hpp index b77d364..02d60f7 100644 --- a/src/lalr/GrammarParser.hpp +++ b/src/lalr/GrammarParser.hpp @@ -16,6 +16,7 @@ class GrammarParser Grammar* grammar_; ///< Grammar to build from parsing input. const char* position_; ///< Current input position. const char* end_; ///< One past the last character of input to parse. + const char* line_position_; ///< Current line position. int line_; ///< Current line number. std::string lexeme_; ///< Currently parsed lexeme. int errors_; ///< The number of errors that occured during parsing and generation. @@ -50,9 +51,10 @@ class GrammarParser bool match( const char* lexeme ); bool match_without_skipping_whitespace( const char* lexeme ); bool expect( const char* lexeme ); - void error( int line, int error, const char* format, ... ); + void error(int line, int column, int error, const char* format, ... ); const char* new_line( const char* position ); static bool is_new_line( const char* position ); + int get_line_column(const char* position); }; } diff --git a/src/lalr/GrammarSymbol.cpp b/src/lalr/GrammarSymbol.cpp index 779379b..487f0e2 100644 --- a/src/lalr/GrammarSymbol.cpp +++ b/src/lalr/GrammarSymbol.cpp @@ -17,6 +17,7 @@ GrammarSymbol::GrammarSymbol( const char* lexeme ) , associativity_( ASSOCIATE_NULL ) , precedence_( 0 ) , line_( 0 ) +, column_( 0 ) , index_( -1 ) , nullable_( false ) , referenced_in_precedence_directive_( false ) @@ -112,6 +113,12 @@ void GrammarSymbol::set_line( int line ) line_ = line; } +void GrammarSymbol::set_column( int column ) +{ + LALR_ASSERT( column >= 0 ); + column_ = column; +} + void GrammarSymbol::set_index( int index ) { LALR_ASSERT( index >= 0 ); diff --git a/src/lalr/GrammarSymbol.hpp b/src/lalr/GrammarSymbol.hpp index 57fd79d..e8d109e 100644 --- a/src/lalr/GrammarSymbol.hpp +++ b/src/lalr/GrammarSymbol.hpp @@ -23,6 +23,7 @@ class GrammarSymbol Associativity associativity_; ///< The associativity of this symbol. int precedence_; ///< The precedence of this symbol. int line_; ///< The line that this symbol is defined on. + int column_; ///< The line column that this symbol is defined on. int index_; ///< The index of this symbol among all symbols. bool nullable_; ///< True if this symbol is nullable otherwise false. bool referenced_in_precedence_directive_; ///< True if this symbol is referenced by a %precedence directive. @@ -42,6 +43,7 @@ class GrammarSymbol inline Associativity associativity() const; inline int precedence() const; inline int line() const; + inline int column() const; inline int index() const; inline bool nullable() const; inline bool referenced_in_precedence_directive() const; @@ -60,6 +62,7 @@ class GrammarSymbol void set_associativity( Associativity associativity ); void set_precedence( int precedence ); void set_line( int line ); + void set_column( int column ); void set_index( int index ); void set_nullable( bool nullable ); void set_referenced_in_precedence_directive( bool referenced_in_precedence_directive ); diff --git a/src/lalr/GrammarSymbol.ipp b/src/lalr/GrammarSymbol.ipp index 86c6e79..5cec4d9 100644 --- a/src/lalr/GrammarSymbol.ipp +++ b/src/lalr/GrammarSymbol.ipp @@ -52,6 +52,11 @@ int GrammarSymbol::line() const return line_; } +int GrammarSymbol::column() const +{ + return column_; +} + int GrammarSymbol::index() const { return index_; From eb228024dba5bdf7803a36c94980c770f2b14dea Mon Sep 17 00:00:00 2001 From: Charles Baker Date: Sat, 15 Jul 2023 14:48:43 +1200 Subject: [PATCH 3/4] Calculate line and column inside GrammarParser::error() for simplicity --- src/lalr/GrammarParser.cpp | 33 +++++++++++++++++---------------- src/lalr/GrammarParser.hpp | 4 ++-- 2 files changed, 19 insertions(+), 18 deletions(-) diff --git a/src/lalr/GrammarParser.cpp b/src/lalr/GrammarParser.cpp index 5fed611..7c369f3 100644 --- a/src/lalr/GrammarParser.cpp +++ b/src/lalr/GrammarParser.cpp @@ -41,7 +41,7 @@ int GrammarParser::parse( const char* start, const char* finish, ErrorPolicy* er errors_ = 0; if ( !match_grammar() ) { - error(line_, get_line_column(position_), LALR_ERROR_SYNTAX, "parsing grammar failed" ); + error( LALR_ERROR_SYNTAX, "parsing grammar failed" ); } return errors_; } @@ -94,7 +94,7 @@ bool GrammarParser::match_whitespace_statement() grammar_->whitespace(); if ( match_regex() ) { - grammar_->regex( lexeme_.c_str(), line_, get_line_column(position_) ); + grammar_->regex( lexeme_.c_str(), line_, column() ); } expect( ";" ); return true; @@ -106,7 +106,7 @@ bool GrammarParser::match_production_statement() { if ( match_identifier() ) { - grammar_->production( lexeme_.c_str(), line_, get_line_column(position_) ); + grammar_->production( lexeme_.c_str(), line_, column() ); expect( ":" ); match_expressions(); expect( ";" ); @@ -128,22 +128,22 @@ bool GrammarParser::match_symbol() { if ( match_error() ) { - grammar_->error( line_, get_line_column(position_) ); + grammar_->error( line_, column() ); return true; } else if ( match_literal() ) { - grammar_->literal( lexeme_.c_str(), line_, get_line_column(position_) ); + grammar_->literal( lexeme_.c_str(), line_, column() ); return true; } else if ( match_regex() ) { - grammar_->regex( lexeme_.c_str(), line_, get_line_column(position_) ); + grammar_->regex( lexeme_.c_str(), line_, column() ); return true; } else if ( match_identifier() ) { - grammar_->identifier( lexeme_.c_str(), line_, get_line_column(position_) ); + grammar_->identifier( lexeme_.c_str(), line_, column() ); return true; } return false; @@ -203,12 +203,12 @@ bool GrammarParser::match_action() { if ( match_identifier() ) { - grammar_->action( lexeme_.c_str(), line_, get_line_column(position_) ); + grammar_->action( lexeme_.c_str(), line_, column() ); } expect( "]" ); return true; } - grammar_->end_expression(line_, get_line_column(position_)); + grammar_->end_expression( line_, column() ); return false; } @@ -236,7 +236,7 @@ bool GrammarParser::match_literal() expect( "'" ); return true; } - error(line_, get_line_column(position), LALR_ERROR_UNTERMINATED_LITERAL, "unterminated literal" ); + error( LALR_ERROR_UNTERMINATED_LITERAL, "unterminated literal" ); return false; } return false; @@ -390,11 +390,11 @@ bool GrammarParser::expect( const char* lexeme ) return true; } position_ = end_; - error(line_, get_line_column(position_), LALR_ERROR_SYNTAX, "expected '%s' not found", lexeme ); + error( LALR_ERROR_SYNTAX, "expected '%s' not found", lexeme ); return false; } -void GrammarParser::error(int line, int column, int error, const char* format, ... ) +void GrammarParser::error( int error, const char* format, ... ) { LALR_ASSERT( format ); ++errors_; @@ -402,7 +402,7 @@ void GrammarParser::error(int line, int column, int error, const char* format, . { va_list args; va_start( args, format ); - error_policy_->lalr_error( line, column, error, format, args ); + error_policy_->lalr_error( line_, column(), error, format, args ); va_end( args ); } } @@ -440,8 +440,9 @@ bool GrammarParser::is_new_line( const char* position ) return *position == '\n' || *position == '\r'; } -int GrammarParser::get_line_column(const char* position) +int GrammarParser::column() { - return position - line_position_; - + LALR_ASSERT( position_ ); + LALR_ASSERT( position_ >= line_position_ ); + return int(position_ - line_position_); } diff --git a/src/lalr/GrammarParser.hpp b/src/lalr/GrammarParser.hpp index 02d60f7..142e1d8 100644 --- a/src/lalr/GrammarParser.hpp +++ b/src/lalr/GrammarParser.hpp @@ -51,10 +51,10 @@ class GrammarParser bool match( const char* lexeme ); bool match_without_skipping_whitespace( const char* lexeme ); bool expect( const char* lexeme ); - void error(int line, int column, int error, const char* format, ... ); + void error( int error, const char* format, ... ); const char* new_line( const char* position ); static bool is_new_line( const char* position ); - int get_line_column(const char* position); + int column(); }; } From d0baae1ccd18ca9412ada1eb17bc0bf204b1c265 Mon Sep 17 00:00:00 2001 From: Charles Baker Date: Sat, 15 Jul 2023 14:43:50 +1200 Subject: [PATCH 4/4] LINT: Formatting around adding columns to errors in Grammar.[ch]pp --- src/lalr/Grammar.cpp | 38 +++++++++++++++++++------------------- src/lalr/Grammar.hpp | 10 +++++----- 2 files changed, 24 insertions(+), 24 deletions(-) diff --git a/src/lalr/Grammar.cpp b/src/lalr/Grammar.cpp index 360a8e0..1a146e9 100644 --- a/src/lalr/Grammar.cpp +++ b/src/lalr/Grammar.cpp @@ -160,7 +160,7 @@ Grammar& Grammar::production( const char* identifier, int line, int column ) active_whitespace_directive_ = false; active_precedence_directive_ = false; active_production_ = nullptr; - active_symbol_ = non_terminal_symbol(identifier, line , column); + active_symbol_ = non_terminal_symbol( identifier, line, column ); return *this; } @@ -185,14 +185,14 @@ Grammar& Grammar::end_expression(int line, int column) { if ( !active_production_ ) { - active_production_ = add_production( active_symbol_, line , column); + active_production_ = add_production( active_symbol_, line, column ); } } active_production_ = nullptr; return *this; } -Grammar& Grammar::error(int line, int column) +Grammar& Grammar::error( int line, int column ) { LALR_ASSERT( line >= 1 ); if ( associativity_ != ASSOCIATE_NULL ) @@ -205,7 +205,7 @@ Grammar& Grammar::error(int line, int column) { if ( !active_production_ ) { - active_production_ = add_production( active_symbol_, line , column ); + active_production_ = add_production( active_symbol_, line, column ); } active_production_->append_symbol( error_symbol() ); } @@ -221,7 +221,7 @@ Grammar& Grammar::action(const char* identifier, int line, int column) { if ( !active_production_ ) { - active_production_ = add_production(active_symbol_, line , column); + active_production_ = add_production(active_symbol_, line, column ); } active_production_->set_action( add_action(identifier) ); active_production_ = nullptr; @@ -240,7 +240,7 @@ Grammar& Grammar::literal(const char* literal, int line, int column) } else if ( associativity_ != ASSOCIATE_NULL ) { - GrammarSymbol* symbol = literal_symbol(literal, line , column); + GrammarSymbol* symbol = literal_symbol( literal, line, column ); symbol->set_associativity( associativity_ ); symbol->set_precedence( precedence_ ); } @@ -252,7 +252,7 @@ Grammar& Grammar::literal(const char* literal, int line, int column) } if ( active_precedence_directive_ ) { - GrammarSymbol* symbol = literal_symbol(literal, line , column); + GrammarSymbol* symbol = literal_symbol( literal, line, column ); active_production_->set_precedence_symbol( symbol ); symbol->set_referenced_in_precedence_directive( true ); active_precedence_directive_ = false; @@ -276,7 +276,7 @@ Grammar& Grammar::regex( const char* regex, int line, int column ) } else if ( associativity_ != ASSOCIATE_NULL ) { - GrammarSymbol* symbol = regex_symbol(regex, line , column); + GrammarSymbol* symbol = regex_symbol( regex, line, column ); symbol->set_associativity( associativity_ ); symbol->set_precedence( precedence_ ); } @@ -284,18 +284,18 @@ Grammar& Grammar::regex( const char* regex, int line, int column ) { if ( !active_production_ ) { - active_production_ = add_production(active_symbol_, line , column); + active_production_ = add_production( active_symbol_, line, column ); } if ( active_precedence_directive_ ) { - GrammarSymbol* symbol = regex_symbol(regex, line , column); + GrammarSymbol* symbol = regex_symbol( regex, line, column ); symbol->set_referenced_in_precedence_directive( true ); active_production_->set_precedence_symbol( symbol ); active_precedence_directive_ = false; } else { - active_production_->append_symbol( regex_symbol(regex, line , column) ); + active_production_->append_symbol( regex_symbol(regex, line, column) ); } } return *this; @@ -308,7 +308,7 @@ Grammar& Grammar::identifier( const char* identifier, int line, int column ) LALR_ASSERT( active_symbol_ || associativity_ != ASSOCIATE_NULL ); if ( associativity_ != ASSOCIATE_NULL ) { - GrammarSymbol* symbol = non_terminal_symbol(identifier, line , column); + GrammarSymbol* symbol = non_terminal_symbol( identifier, line, column ); symbol->set_associativity( associativity_ ); symbol->set_precedence( precedence_ ); } @@ -316,11 +316,11 @@ Grammar& Grammar::identifier( const char* identifier, int line, int column ) { if ( !active_production_ ) { - active_production_ = add_production(active_symbol_, line , column); + active_production_ = add_production( active_symbol_, line, column ); } if ( active_precedence_directive_ ) { - GrammarSymbol* symbol = non_terminal_symbol(identifier, line , column); + GrammarSymbol* symbol = non_terminal_symbol( identifier, line, column ); symbol->set_referenced_in_precedence_directive( true ); active_production_->set_precedence_symbol( symbol ); active_precedence_directive_ = false; @@ -334,28 +334,28 @@ Grammar& Grammar::identifier( const char* identifier, int line, int column ) return *this; } -GrammarSymbol* Grammar::literal_symbol( const char* lexeme, int line, int column) +GrammarSymbol* Grammar::literal_symbol( const char* lexeme, int line, int column ) { LALR_ASSERT( lexeme ); LALR_ASSERT( line >= 0 ); return add_symbol(lexeme, line, column, LEXEME_LITERAL, SYMBOL_TERMINAL ); } -GrammarSymbol* Grammar::regex_symbol(const char* lexeme, int line, int column) +GrammarSymbol* Grammar::regex_symbol( const char* lexeme, int line, int column ) { LALR_ASSERT( lexeme ); LALR_ASSERT( line >= 0 ); return add_symbol(lexeme, line, column, LEXEME_REGULAR_EXPRESSION, SYMBOL_TERMINAL ); } -GrammarSymbol* Grammar::non_terminal_symbol(const char* lexeme, int line, int column) +GrammarSymbol* Grammar::non_terminal_symbol( const char* lexeme, int line, int column ) { LALR_ASSERT( lexeme ); LALR_ASSERT( line >= 0 ); return add_symbol(lexeme, line, column, LEXEME_NULL, SYMBOL_NON_TERMINAL ); } -GrammarSymbol* Grammar::add_symbol(const char* lexeme, int line, int column, LexemeType lexeme_type, SymbolType symbol_type ) +GrammarSymbol* Grammar::add_symbol( const char* lexeme, int line, int column, LexemeType lexeme_type, SymbolType symbol_type ) { LALR_ASSERT( lexeme ); LALR_ASSERT( line >= 0 ); @@ -381,7 +381,7 @@ GrammarSymbol* Grammar::add_symbol(const char* lexeme, int line, int column, Lex return symbol; } -GrammarProduction* Grammar::add_production(GrammarSymbol* symbol, int line, int column) +GrammarProduction* Grammar::add_production( GrammarSymbol* symbol, int line, int column ) { LALR_ASSERT( symbol ); LALR_ASSERT( line > 0 ); diff --git a/src/lalr/Grammar.hpp b/src/lalr/Grammar.hpp index ea9dc60..090d1b1 100644 --- a/src/lalr/Grammar.hpp +++ b/src/lalr/Grammar.hpp @@ -66,11 +66,11 @@ class Grammar Grammar& identifier( const char* identifier, int line, int column ); private: - GrammarSymbol* literal_symbol(const char* lexeme, int line , int column); - GrammarSymbol* regex_symbol(const char* lexeme, int line , int column); - GrammarSymbol* non_terminal_symbol(const char* lexeme, int line , int column); - GrammarSymbol* add_symbol(const char* lexeme, int line, int column, LexemeType lexeme_type, SymbolType symbol_type ); - GrammarProduction* add_production(GrammarSymbol* symbol, int line , int column); + GrammarSymbol* literal_symbol( const char* lexeme, int line , int column ); + GrammarSymbol* regex_symbol( const char* lexeme, int line , int column ); + GrammarSymbol* non_terminal_symbol( const char* lexeme, int line , int column ); + GrammarSymbol* add_symbol( const char* lexeme, int line, int column, LexemeType lexeme_type, SymbolType symbol_type ); + GrammarProduction* add_production( GrammarSymbol* symbol, int line , int column ); GrammarAction* add_action( const char* id ); };