wip

Steepfile

@@ -7,6 +7,7 @@ target :lib do
  check "lib/lrama/grammar/code/printer_code.rb"
  check "lib/lrama/grammar/code.rb"
  check "lib/lrama/grammar/counter.rb"
+ check "lib/lrama/grammar/parser_state.rb"
  check "lib/lrama/grammar/percent_code.rb"
  check "lib/lrama/grammar/precedence.rb"
  check "lib/lrama/grammar/printer.rb"
@@ -15,6 +16,9 @@ target :lib do
  check "lib/lrama/lexer/token/char.rb"
  check "lib/lrama/lexer/token/ident.rb"
  check "lib/lrama/lexer/token/parameterizing.rb"
+ check "lib/lrama/lexer/token/parser_state_pop.rb"
+ check "lib/lrama/lexer/token/parser_state_push.rb"
+ check "lib/lrama/lexer/token/parser_state_set.rb"
  check "lib/lrama/lexer/token/tag.rb"
  check "lib/lrama/lexer/token/user_code.rb"
  check "lib/lrama/lexer/location.rb"

lib/lrama/grammar.rb

@@ -2,6 +2,7 @@
 require "lrama/grammar/code"
 require "lrama/grammar/counter"
 require "lrama/grammar/error_token"
+require "lrama/grammar/parser_state"
 require "lrama/grammar/percent_code"
 require "lrama/grammar/precedence"
 require "lrama/grammar/printer"
@@ -16,7 +17,7 @@
 module Lrama
  # Grammar is the result of parsing an input grammar file
  class Grammar
- attr_reader :percent_codes, :eof_symbol, :error_symbol, :undef_symbol, :accept_symbol, :aux
+ attr_reader :percent_codes, :parser_states, :eof_symbol, :error_symbol, :undef_symbol, :accept_symbol, :aux
  attr_accessor :union, :expect,
  :printers, :error_tokens,
  :lex_param, :parse_param, :initial_action,
@@ -31,6 +32,7 @@ def initialize(rule_counter)
  @percent_codes = []
  @printers = []
  @error_tokens = []
+ @parser_states = []
  @symbols = []
  @types = []
  @rule_builders = []
@@ -58,6 +60,10 @@ def add_error_token(ident_or_tags:, token_code:, lineno:)
  @error_tokens << ErrorToken.new(ident_or_tags: ident_or_tags, token_code: token_code, lineno: lineno)
  end
 
+ def add_parser_state(state_id, state_list)
+ @parser_states << ParserState.new(state_id: state_id, state_list: state_list)
+ end
+
  def add_term(id:, alias_name: nil, tag: nil, token_id: nil, replace: false)
  if token_id && (sym = @symbols.find {|s| s.token_id == token_id })
  if replace
@@ -186,7 +192,7 @@ def find_symbol_by_id(id)
  end
 
  def find_symbol_by_id!(id)
- find_symbol_by_id(id) || (raise "Symbol not found: #{id}")
+ find_symbol_by_id(id) || (raise "Symbol not found: #{id.s_value}")
  end
 
  def find_symbol_by_number!(number)

lib/lrama/grammar/parser_state.rb

@@ -0,0 +1,123 @@
+module Lrama
+ class Grammar
+ class ParserState
+ attr_reader :state_id, :state_list
+
+ def initialize(state_id:, state_list:)
+ @state_id = state_id
+ @state_list = state_list
+ end
+
+ def enum_definition
+ <<~ENUM
+ enum #{enum_name}
+ {
+ #{enum_body}
+ };
+ typedef enum #{enum_name} #{enum_type};
+
+ static const char *const #{enum_name_table_name}[] = {
+ #{int_to_name.join(", ")}
+ };
+
+ YY_ATTRIBUTE_UNUSED
+ static const char *
+ #{enum_name}_name (#{enum_type} num)
+ {
+ return #{enum_name_table_name}[num];
+ }
+
+ # define #{state_name_macro}(value) #{enum_name}_name (value)
+ # define #{current_state_name_macro} #{state_name_macro} (*#{stack_prefix}_p)
+ ENUM
+ end
+
+ def state_name_macro
+ "YY_STATE_#{state_name.upcase}_NAME"
+ end
+
+ def current_state_name_macro
+ "YY_CURRENT_STATE_#{state_name.upcase}_NAME"
+ end
+
+ def states_functions
+ # TODO: Stack check for push
+ <<~FUNC
+ # define YYPUSH_STATE_#{state_name.upcase}(value) \\
+ do \\
+ { \\
+ YYDPRINTF ((stderr, "Push %s to #{state_name}\\n", #{state_name_macro} (value))); \\
+ *++#{stack_prefix}_p = value; \\
+ } \\
+ while (0)
+
+ # define YYPOP_STATE_#{state_name.upcase}() \\
+ do \\
+ { \\
+ YYDPRINTF ((stderr, "Pop #{state_name}\\n")); \\
+ if (#{stack_prefix}_p != #{stack_prefix}) \\
+ { \\
+ #{stack_prefix}_p -= 1; \\
+ } \\
+ else \\
+ { \\
+ YYDPRINTF ((stderr, "Try to pop empty #{state_name} stack\\n")); \\
+ } \\
+ } \\
+ while (0)
+
+ # define YYSET_STATE_#{state_name.upcase}(value) \\
+ do \\
+ { \\
+ YYDPRINTF ((stderr, "Set %s to #{state_name}\\n", #{state_name_macro} (value))); \\
+ *#{stack_prefix}_p = value; \\
+ } \\
+ while (0)
+
+ # define YY_STATE_#{state_name.upcase} #{stack_prefix}_p
+ FUNC
+ end
+
+ def states_stacks
+ <<~STACKS
+ /* The parser state stack (#{stack_prefix}): array, bottom, top. */
+ int #{stack_prefix}_a[YYINITDEPTH];
+ int *#{stack_prefix} = #{stack_prefix}_a;
+ int *#{stack_prefix}_p = #{stack_prefix};
+ STACKS
+ end
+
+ def state_name
+ state_id.s_value
+ end
+
+ def enum_name
+ "yyparser_state_#{state_name}"
+ end
+
+ def enum_type
+ "#{enum_name}_t"
+ end
+
+ def enum_body
+ state_list.map do |state|
+ state.s_value
+ end.join(",\n ")
+ end
+
+ def int_to_name
+ state_list.map do |state|
+ "\"#{state.s_value}\""
+ end << "YY_NULLPTR"
+ end
+
+ def enum_name_table_name
+ "#{enum_name}_names"
+ end
+
+ def stack_prefix
+ "yyparser_state_#{state_name}"
+ end
+ end
+ end
+end

lib/lrama/grammar/rule_builder.rb

@@ -117,6 +117,12 @@ def process_rhs
  when Lrama::Lexer::Token::Parameterizing
  @parameterizing_rules = ParameterizingRules::Builder.new(token, @rule_counter, lhs, user_code, precedence_sym, line).build
  @replaced_rhs << token
+ when Lrama::Lexer::Token::ParserStatePop
+ process_parser_state_token(token, "parser_state_pop_", "YYPOP_STATE_#{token.s_value.upcase}();", i)
+ when Lrama::Lexer::Token::ParserStatePush
+ process_parser_state_token(token, "parser_state_push_", "YYPUSH_STATE_#{token.s_value.upcase}(#{token.state.s_value});", i)
+ when Lrama::Lexer::Token::ParserStateSet
+ process_parser_state_token(token, "parser_state_set_", "YYSET_STATE_#{token.s_value.upcase}(#{token.state.s_value});", i)
  when Lrama::Lexer::Token::UserCode
  prefix = token.referred ? "@" : "$@"
  new_token = Lrama::Lexer::Token::Ident.new(s_value: prefix + @midrule_action_counter.increment.to_s)
@@ -135,6 +141,20 @@ def process_rhs
  end
  end
 
+ def process_parser_state_token(token, prefix, code, position_in_original_rule_rhs)
+ new_token = Lrama::Lexer::Token::Ident.new(s_value: prefix + token.s_value + @midrule_action_counter.increment.to_s)
+ user_code = Lrama::Lexer::Token::UserCode.new(s_value: code, location: token.location)
+
+ @replaced_rhs << new_token
+ rule_builder = RuleBuilder.new(@rule_counter, @midrule_action_counter, position_in_original_rule_rhs, skip_preprocess_references: true)
+ rule_builder.lhs = new_token
+ rule_builder.user_code = user_code
+ rule_builder.complete_input
+ rule_builder.setup_rules
+
+ @rule_builders_for_derived_rules << rule_builder
+ end
+
  def numberize_references
  # Bison n'th component is 1-origin
  (rhs + [user_code]).compact.each.with_index(1) do |token, i|

lib/lrama/lexer.rb

@@ -28,6 +28,10 @@ class Lexer
  %error-token
  %empty
  %code
+ %parser-state
+ %push
+ %pop
+ %set
  )
 
  def initialize(text)

lib/lrama/lexer/token.rb

@@ -40,5 +40,8 @@ def last_column
 require 'lrama/lexer/token/char'
 require 'lrama/lexer/token/ident'
 require 'lrama/lexer/token/parameterizing'
+require 'lrama/lexer/token/parser_state_pop'
+require 'lrama/lexer/token/parser_state_push'
+require 'lrama/lexer/token/parser_state_set'
 require 'lrama/lexer/token/tag'
 require 'lrama/lexer/token/user_code'

lib/lrama/lexer/token/parser_state_pop.rb

@@ -0,0 +1,8 @@
+module Lrama
+ class Lexer
+ class Token
+ class ParserStatePop < Token
+ end
+ end
+ end
+end

lib/lrama/lexer/token/parser_state_push.rb

@@ -0,0 +1,9 @@
+module Lrama
+ class Lexer
+ class Token
+ class ParserStatePush < Token
+ attr_accessor :state
+ end
+ end
+ end
+end

lib/lrama/lexer/token/parser_state_set.rb

@@ -0,0 +1,9 @@
+module Lrama
+ class Lexer
+ class Token
+ class ParserStateSet < Token
+ attr_accessor :state
+ end
+ end
+ end
+end

lib/lrama/output.rb

@@ -358,6 +358,24 @@ def percent_code(name)
  end.join
  end
 
+ def parser_states_enums
+ @grammar.parser_states.map do |ps|
+ ps.enum_definition
+ end
+ end
+
+ def parser_states_stacks
+ @grammar.parser_states.map do |ps|
+ ps.states_stacks
+ end
+ end
+
+ def parser_states_functions
+ @grammar.parser_states.map do |ps|
+ ps.states_functions
+ end
+ end
+
  private
 
  def eval_template(file, path)