mkbison 0.0.1

data/lib/bison/rule.rb

@@ -0,0 +1,11 @@
+module Bison
+  class Rule
+    attr_reader :name, :components
+    attr_accessor :location
+    
+    def initialize(name, components=[])
+      @name, @components = name, components
+      components.each_with_index{ |x, i| x.index = i; x.rule = self }
+    end
+  end
+end

data/lib/bison/sequence.rb

@@ -0,0 +1,19 @@
+module Bison
+  class Sequence
+    attr_accessor :rule, :index
+    attr_reader :elements
+    
+    def initialize
+      @elements = []
+    end
+
+    def <<(element)
+      if Bison::Action === element
+        element.predecessors = elements.clone
+      end
+      element.sequence = self
+      elements << element
+      self
+    end
+  end
+end

data/lib/bison/token.rb

@@ -0,0 +1,20 @@
+module Bison
+  class Token
+    attr_accessor :name
+    attr_accessor :number
+    attr_accessor :associativity
+    
+    def initialize(name, assoc=nil)
+      self.name = name
+      self.associativity = assoc
+    end
+
+    def left?
+      associativity == :left
+    end
+
+    def right?
+      associativity == :right
+    end
+  end
+end

data/lib/bison/version.rb

@@ -0,0 +1,3 @@
+module Bison
+  VERSION = "0.0.1"
+end

data/lib/bison_parser.rb

@@ -0,0 +1,123 @@
+
+class BisonParser
+  attr_accessor :section
+
+  def lex
+    x = real_lex
+    Tokens.constants.each do |const|
+      if Tokens.const_get(const) == x
+        warn "Lex'd #{const}\t: #{lex_value.inspect}" if ENV['DEBUG_GRAMMAR']
+        return x
+      end
+    end
+
+    warn "Lex'd #{x.inspect}" if ENV['DEBUG_GRAMMAR']
+
+    x
+  end
+
+  def real_lex
+    self.section ||= 0
+    self.lex_value = nil
+
+    if section == 2
+      self.lex_value = io.read
+      self.section += 2
+      return Tokens::ACTIONS
+    end
+
+    # skip space
+    while true
+      while (c = self.read) && c =~ /\s/
+      end
+
+      if c == '#'
+        while (char = self.read) && char != "\n"
+        end
+      else
+        break
+      end
+    end
+
+    return nil unless c
+
+    case c
+    when ':'
+      return Tokens::COLON
+    when ';'
+      return Tokens::SEMICOLON
+    when '|'
+      return Tokens::PIPE
+    when '%'
+      if self.peak == '%'
+        self.read
+        self.section += 1
+        return Tokens::DOUBLE_HASH
+      end
+      return Tokens::HASH
+    when '['
+      return Tokens::LBRACK
+    when ']'
+      return Tokens::RBRACK
+    when '{'
+      nesting = 1
+      action = ''
+      while (c = self.read) && nesting > 0
+        nesting += 1 if c == '{'
+        nesting -= 1 if c == '}'
+        action << c unless nesting.zero?
+      end
+      self.lex_value = action
+      return Tokens::ACTIONS
+    when '0'..'9'
+      number = c
+      while (c = self.peak) && ('0'..'9').include?(c)
+        number << self.read
+      end
+      self.lex_value = number.to_i
+      return Tokens::NUMBER
+    when '"'
+      string = ''
+      while (c = self.read) && c != '"'
+        string << c
+      end
+      self.lex_value = string
+      return Tokens::STRING
+    when "'"
+      string = ''
+      while (c = self.read) && c != "'"
+        string << c
+      end
+      self.lex_value = string
+      return Tokens::STRING
+    end
+
+    if c =~ /\w/
+      string = c
+      while (c = self.peak) && c =~ /\w/
+        self.read
+        string << c
+      end
+
+      if section.zero? && string == 'token'
+        return Tokens::KW_TOKEN
+      elsif section.zero? && string == 'left'
+        return Tokens::KW_LEFT
+      elsif section.zero? && string == 'right'
+        return Tokens::KW_RIGHT
+      else
+        self.lex_value = string
+        return Tokens::IDENTIFIER
+      end
+    end
+
+    warn "Yielding literal #{c.inspect}"
+
+    return c.ord
+  end
+end
+
+
+require 'bison_parser/base'
+require 'bison_parser/actions'
+require 'bison_parser/bison_parser'

data/lib/bison_parser/actions.rb

@@ -0,0 +1,81 @@
+class BisonParser
+  class Actions
+    attr_accessor :parser, :result
+
+    def _0_grammar_file(tokens, rules, code)
+      self.result = Bison::GrammarFile.new(tokens, rules, code)
+    end
+
+    def _0_optional_code()
+      nil
+    end
+
+    def _1_optional_code(actions)
+      actions
+    end
+
+    def _0_token_list()
+      []
+    end
+
+    def _1_token_list(list, token)
+      list << token
+    end
+
+    def _0_token(name)
+      Bison::Token.new(name)
+    end
+
+    def _1_token(name)
+      Bison::Token.new(name, :left)
+    end
+
+    def _2_token(name)
+      Bison::Token.new(name, :right)
+    end
+
+    def _3_token(token, num)
+      token.tap{ |t| t.number = num }
+    end
+
+    def _0_grammar_rules()
+      []
+    end
+
+    def _1_grammar_rules(list, rule)
+      list << rule
+    end
+
+    def _0_grammar_rule(name, components)
+      Bison::Rule.new(name, components).tap{ |r| r.location = @name }
+    end
+
+    def _0_components(sequence)
+      [sequence]
+    end
+
+    def _1_components(sequences, sequence)
+      sequences << sequence
+    end
+
+    def _0_sequence()
+      Bison::Sequence.new
+    end
+
+    def _1_sequence(sequence, code)
+      sequence << Bison::Action.new(code).tap{ |a| a.location = @code }
+    end
+
+    def _2_sequence(sequence, follower)
+      sequence << Bison::Nonterminal.new(follower).tap{ |x| x.location = @follower }
+    end
+
+    def _3_sequence(sequence, follower, tag)
+      sequence << Bison::Nonterminal.new(follower, tag).tap{ |x| x.location = @follower }
+    end
+
+    def _4_sequence(sequence, follower)
+      sequence << Bison::String.new(follower).tap{ |x| x.location = @follower }
+    end
+  end
+end

data/lib/bison_parser/base.rb

@@ -0,0 +1,49 @@
+class BisonParser
+  attr_reader :io
+  attr_accessor :lex_value, :token_row, :token_col, :row, :col
+  attr_accessor :source, :result
+
+  module Base
+    def initialize(io)
+      if String === io
+        io = ::File.open(io, 'r')
+      end
+      @source = io.respond_to?(:path) ? io.path : nil
+      @io, @row, @col = io, 1, 0
+    end
+
+    def read
+      io.read(1).tap do |c|
+        if c == "\n"
+          self.row += 1
+          self.col = 0
+        elsif c
+          self.col += 1
+        end
+      end
+    end
+
+    def peak
+      io.read(1).tap{ |c| io.ungetc(c) if c }
+    end
+
+    def begin_token
+      self.token_row = row
+      self.token_col = col
+    end
+
+    def error(msg, row, col)
+      raise Error.new(msg, source, row, col)
+    end
+  end
+
+  include Base
+
+  class Error < ::Exception
+    attr_reader :message
+    def initialize(msg, source, row, col)
+      source ||= '-'
+      @message = "#{source}:#{row}.#{col} #{msg}"
+    end
+  end
+end

data/mkbison.gemspec

@@ -0,0 +1,24 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bison/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mkbison"
+  spec.version       = Bison::VERSION
+  spec.authors       = ["Peter Woo"]
+  spec.email         = ["peter@wioux.net"]
+  spec.summary       = %q{Tool to generate bison parser C extensions}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.extensions = %w[ext/bison_parser/extconf.rb]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake-compiler"
+end

data/templates/actions.rb.erb

@@ -0,0 +1,10 @@
+class <%= name %>
+  class Actions
+    attr_accessor :parser, :result
+<% rules.map(&:components).flatten.map(&:elements).flatten.grep(Bison::Action).each_with_index do |action, i| %>
+    def <%= action.name %>(<%= action.predecessor_tags.values.join(', ') %>)
+      <%= action.code.strip %>
+    end
+<% end -%>
+  end
+end

data/templates/base.rb.erb

@@ -0,0 +1,49 @@
+class <%= name %>
+  attr_reader :io
+  attr_accessor :lex_value, :token_row, :token_col, :row, :col
+  attr_accessor :source, :result
+
+  module Base
+    def initialize(io)
+      if String === io
+        io = ::File.open(io, 'r')
+      end
+      @source = io.respond_to?(:path) ? io.path : nil
+      @io, @row, @col = io, 1, 0
+    end
+
+    def read
+      io.read(1).tap do |c|
+        if c == "\n"
+          self.row += 1
+          self.col = 0
+        elsif c
+          self.col += 1
+        end
+      end
+    end
+
+    def peak
+      io.read(1).tap{ |c| io.ungetc(c) if c }
+    end
+
+    def begin_token
+      self.token_row = row
+      self.token_col = col
+    end
+
+    def error(msg, row, col)
+      raise Error.new(msg, source, row, col)
+    end
+  end
+
+  include Base
+
+  class Error < ::Exception
+    attr_reader :message
+    def initialize(msg, source, row, col)
+      source ||= '-'
+      @message = "#{source}:#{row}.#{col} #{msg}"
+    end
+  end
+end

data/templates/class.rb.erb

@@ -0,0 +1,10 @@
+<% if code %>
+<%= code.strip %>
+<% else %>
+class <%= name %>
+end
+<% end %>
+
+require '<%= uname %>/base'
+require '<%= uname %>/actions'
+require '<%= uname %>/<%= uname %>'

data/templates/extconf.rb.erb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+output = "#{File.dirname(__FILE__)}/<%= uname %>.c"
+bison_file = "#{File.dirname(__FILE__)}/<%= uname %>.y"
+
+bison = ENV['BISON_PATH'] || 'bison'
+system(bison, '-o', output, bison_file)
+
+create_makefile '<%= uname %>/<%= uname %>'

data/templates/parser.y.erb

@@ -0,0 +1,123 @@
+
+<% tokens.each do |token| -%>
+<% if token.number -%>
+%token	<%= token.name %><%= "\t" * (4 - token.name.length/8)%><%= token.number %>
+<% else -%>
+%token	<%= token.name %>
+<% end -%>
+<% end -%>
+
+<% tokens.select{|t| t.left? || t.right?}.each do |token| -%>
+<%= token.left? ? '%left' : '%right' %>	<%= token.name %>
+<% end -%>
+
+%define api.pure true
+%define parse.error verbose
+%parse-param { VALUE __actions }
+%lex-param { VALUE __actions }
+%locations
+
+%{
+#include <ruby.h>
+#define YYSTYPE VALUE
+%}
+
+%code provides {
+static int yylex(YYSTYPE *, YYLTYPE *, VALUE);
+static void yyerror(YYLTYPE *, VALUE, const char *);
+}
+
+%%
+
+<% rules.each do |rule| -%>
+<%= rule.name %>:
+<% rule.components.each_with_index do |seq, i| -%>
+<%= "|\n" unless i.zero? -%>
+<%= '  '+seq.elements.map(&:to_bison).join(' ') unless seq.elements.empty? %>
+<% if !(Bison::Action === seq.elements[-1]) -%>
+<% if seq.elements.grep(Bison::Nonterminal).empty? -%>
+  { $$ = Qnil; }
+<% else -%>
+  { $$ = $<%= seq.elements.find_index{ |x| Bison::Nonterminal === x } + 1%>; }
+<% end %>
+<% end -%>
+<% end -%>
+;
+
+<% end -%>
+
+%%
+
+static VALUE c<%= name %>;
+static VALUE c<%= name %>Tokens;
+static VALUE c<%= name %>Actions;
+
+static VALUE <%= uname %>_parse(VALUE);
+
+void Init_<%= uname %>(void) {
+  c<%= name %> = rb_define_class("<%= name %>", rb_cObject);
+  c<%= name %>Tokens = rb_define_module_under(c<%= name %>, "Tokens");
+  c<%= name %>Actions = rb_define_class_under(c<%= name %>, "Actions", rb_cObject);
+
+<% tokens.each do |token| -%>
+  rb_define_const(c<%= name %>Tokens, "<%= token.name %>", INT2FIX(<%= token.name %>));
+<% end -%>
+
+  rb_define_method(c<%= name %>, "parse", <%= uname %>_parse, 0);
+}
+
+VALUE <%= uname %>_parse(VALUE self) {
+  VALUE actions = rb_funcall(c<%= name %>Actions, rb_intern("new"), 0);
+  rb_funcall(actions, rb_intern("parser="), 1, self);
+  if (yyparse(actions))
+    return Qnil;
+  return rb_funcall(actions, rb_intern("result"), 0);
+}
+
+static void yyerror(YYLTYPE *loc, VALUE actions, const char *msg) {
+  VALUE parser = rb_funcall(actions, rb_intern("parser"), 0);
+  rb_funcall(parser, rb_intern("error"), 3,
+             rb_str_new_cstr(msg), 
+             INT2FIX(loc->first_line), 
+             INT2FIX(loc->first_column));
+}
+
+static int yylex(YYSTYPE *lval, YYLTYPE *lloc, VALUE actions) {
+  int c;
+  VALUE parser, value, vtok;
+
+  parser = rb_funcall(actions, rb_intern("parser"), 0);
+
+  rb_funcall(parser, rb_intern("lex_value="), 1, Qnil);
+  rb_funcall(parser, rb_intern("token_row="), 1, INT2FIX(lloc->last_line));
+  rb_funcall(parser, rb_intern("token_col="), 1, INT2FIX(lloc->last_column));
+
+  vtok = rb_funcall(parser, rb_intern("lex"), 0);
+  value = rb_funcall(parser, rb_intern("lex_value"), 0);
+
+  lloc->first_line = FIX2INT(rb_funcall(parser, rb_intern("token_row"), 0));
+  lloc->first_column = FIX2INT(rb_funcall(parser, rb_intern("token_col"), 0));
+  lloc->last_line = FIX2INT(rb_funcall(parser, rb_intern("row"), 0));
+  lloc->last_column = FIX2INT(rb_funcall(parser, rb_intern("col"), 0));
+
+  if (vtok == Qnil) {
+    *lval = Qnil;
+    //    fprintf(stderr, "parse is nil\n");
+    return 0;
+  }
+
+  if (vtok & 1) {
+    *lval = value;
+    //    fprintf(stderr, "parse is int: %d\n", FIX2INT(vtok));
+    return FIX2INT(vtok);
+  }
+
+  if (RBASIC(vtok)->klass == rb_cString) {
+    c = StringValueCStr(vtok)[0];
+    *lval = rb_sprintf("%c", c);
+    //    fprintf(stderr, "parse is char: '%c' (%d)\n", c, (int)c);
+    return c;
+  }
+
+  return 0;
+}