Class: Hivemind::Syntax

Inherits:

Object

• Object
• Hivemind::Syntax

Defined in:

lib/hivemind/syntax.rb

Class Method Summary

• .generate_syntax(bidirectional_grammar) ⇒ Object
• .load_rules(grammar) ⇒ Object

Instance Method Summary

• #generate ⇒ Object
• #initialize(grammar) ⇒ Syntax constructor

  A new instance of Syntax.

• #parse_rule(rule, types) ⇒ Object

Constructor Details

#initialize(grammar) ⇒ Syntax

Returns a new instance of Syntax.

# File 'lib/hivemind/syntax.rb', line 109

def initialize(grammar)
  @grammar_source = grammar
end

Class Method Details

.generate_syntax(bidirectional_grammar) ⇒ Object

# File 'lib/hivemind/syntax.rb', line 105

def self.generate_syntax(bidirectional_grammar)
  new(bidirectional_grammar).generate
end

.load_rules(grammar) ⇒ Object

# File 'lib/hivemind/syntax.rb', line 230

def self.load_rules(grammar)
  lines = grammar.split("\n")
  rules = {}
  current_rule = nil
  rule_body = []
  lines.each do |line|
    if line.start_with? '#'
      if not current_rule.nil?
        rule_body << "\n" if rule_body.length > 1
        rules[current_rule.to_sym] = rule_body.join("\n")
        rule_body = []
      end
      current_rule = line[1..-1].strip
    elsif line.strip != ''
      rule_body << line
    end
  end
  rule_body << "\n" if rule_body.length > 1
  rules[current_rule.to_sym] = rule_body.join("\n")
  rules
end

Instance Method Details

#generate ⇒ Object

# File 'lib/hivemind/syntax.rb', line 113

def generate
  # parse grammar
  # combine into base grammar
  rules = self.class.load_rules(@grammar_source)
  refs = {}

  rules.each do |name, rule|
    refs[:"_#{name}"] = parse_rule rule, TYPES[name]
  end

  [REFS[:image], REFS.merge(refs)]
end

#parse_rule(rule, types) ⇒ Object

# File 'lib/hivemind/syntax.rb', line 126

def parse_rule(rule, types)
  parsers = []
  tokens = []
  token = ''
  i = 0
  while i < rule.length
    z = rule[i]
    if '<>'.include?(z)
      tokens << token unless token.empty?
      token = ''
      if z == '>'
        if rule[i + 1] == '>'
          tokens << '>>'
          i += 1
        else
          tokens << '>'
        end
      elsif z == '<'
        if rule[i + 1] == '<'
          tokens << '<<'
          i += 1
        else
          tokens << '<'
        end
      end
    elsif z == "'"
      tokens << token unless token.empty?
      token = ''
      j = i
      i += 1
      while rule[i] != "'"
        i += 1
      end
      tokens << rule[j..i]
    elsif z == ' '
      tokens << token unless token.empty?
      token = ''
      j = i
      while rule[i] == ' '
        i += 1
      end
      tokens << rule[j..i - 1]
      i -= 1
    elsif z == "\n"
      tokens << token unless token.empty?
      tokens << "\n"
    elsif z.match /[a-zA-Z_0-9]/
      token += z
    else
      tokens << token unless token.empty?
      token = ''
      tokens << z
    end
    i += 1
  end
  tokens << token unless token.empty?

  r = 0
  in_var = false

  tokens.each_with_index do |token, i|
    if token == '>>'
      if tokens[i - 2] == ':'
        parsers << Join.new(
            Ref.new(types[tokens[i - 3].to_sym]),
            tokens[i - 1][1..-2], as: tokens[i - 3])
      else
        parsers << Join.new(Ref.new(types[tokens[i - 1].to_sym]), "\n#{'    ' * r}", as: tokens[i - 1])
        #Many.new(Ref.new(types[tokens[i - 1].to_sym]), as: tokens[i - 1])
      end
      in_var = false
    elsif token == '>'
      parsers << Ref.new(types[tokens[i - 1].to_sym])
      in_var = false
    elsif token == "\n"
      parsers << Ref.new(:nl)
      if tokens[i + 1] == "\n"
        e = 2
      elsif tokens[i + 1]
        match = tokens[i + 1].match /([    ]+)/
        if match.nil? || match.captures.empty?
          indent = 0
        else
          indent = match.captures.first.size / 4
        end
        if indent > r
          parsers << Ref.new(:indent)
        elsif indent < r
          parsers << Ref.new(:dedent)
        end
        r = indent
      end 
    elsif token.match(/\A +\z/) 
      parsers << Ref.new(:ws)
    elsif (token == '<<' || token == '<') && tokens[i + 1] >= 'a' && tokens[i + 1] <= 'z'
      in_var = true
    elsif !in_var 
      parsers << Lit.new(token)
    end
  end
  # parsers.map { |pa| puts pa.inspect }
  parsers.reduce(:&)
end