Class: Kaiseki::Grammar

Inherits:
Object show all
Defined in:
lib/grammar.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(&block) ⇒ Grammar

Returns a new instance of Grammar.



6
7
8
9
10
11
12
13
14
 
# File 'lib/grammar.rb', line 6

def initialize &block
	@rules = Hash.new {|hash, key| raise "rule #{key.inspect} undefined" }
	@nodes = Hash.new {|hash, key| raise "node #{key.inspect} undefined" }
	@starting_rule = nil
	@skipping_rule = nil
	@simplify = true
	
	instance_eval &block if block_given?
end

Instance Attribute Details

#nodes ⇒ Object (readonly)

Returns the value of attribute nodes.



3
4
5
 
# File 'lib/grammar.rb', line 3

def nodes
  @nodes
end

#rules ⇒ Object (readonly)

Returns the value of attribute rules.



3
4
5
 
# File 'lib/grammar.rb', line 3

def rules
  @rules
end

#simplify(bool = true) ⇒ Object

Returns the value of attribute simplify.



4
5
6
 
# File 'lib/grammar.rb', line 4

def simplify
  @simplify
end

#skipping_rule ⇒ Object

Returns the value of attribute skipping_rule.



4
5
6
 
# File 'lib/grammar.rb', line 4

def skipping_rule
  @skipping_rule
end

#starting_rule ⇒ Object

Returns the value of attribute starting_rule.



4
5
6
 
# File 'lib/grammar.rb', line 4

def starting_rule
  @starting_rule
end

Instance Method Details

#[](rule) ⇒ Object 



16
17
18
 
# File 'lib/grammar.rb', line 16

def [] rule
	GrammarStub.new @rules[rule], self, rule
end

#action(name, &block) ⇒ Object 



70
71
72
73
74
75
76
 
# File 'lib/grammar.rb', line 70

def action name, &block
	if @rules.key? name
		raise "rule #{name.inspect} already defined"
	else
		@rules[name] = block.to_parseable
	end
end

#node(name, args, options = {}) ⇒ Object 



78
79
80
81
82
83
84
85
86
 
# File 'lib/grammar.rb', line 78

def node name, args, options = {}
	args.must_be Array
	if @nodes.key? name
		raise "node #{name.inspect} already defined"
	else
		parent = options[:class] || Node
		@nodes[name] = parent.subclass args, options
	end
end

#parse(stream, options = {}) ⇒ Object 



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/grammar.rb', line 20

def parse stream, options = {}
	raise 'starting rule undefined' unless @starting_rule
	result = ParseResult.new
	default_options = {
		:grammar => self,
		:result => result,
		:rule => '(main)',
		:skipping => @skipping_rule,
		:simplify => @simplify
	}
	options = default_options.merge options
	begin
		result.results[:main] = @starting_rule.parse stream.to_stream, options
	rescue ParseError => e
		result.errors[:main] = e
	end
	result
end

#rule(name, parseable = nil, &block) ⇒ Object 



54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/grammar.rb', line 54

def rule name, parseable = nil, &block
	if @rules.key? name
		raise "rule #{name.inspect} already defined"
	else
		if parseable and block_given?
			raise ArgumentError, "wrong number of arguments; the second argument is mutually exclusive with a block"
		elsif parseable
			@rules[name] = parseable.to_parseable
		elsif block_given?
			@rules[name] = Rule.new(name, self, &block).parseable
		else
			@rules[name] = nil
		end
	end
end

#skipping(parseable) ⇒ Object 



44
45
46
47
48
 
# File 'lib/grammar.rb', line 44

def skipping parseable
	raise "skipping rule already defined" if @skipping_rule
	raise "skipping rule must not be a predicate" if parseable.predicate?
	@skipping_rule = parseable.to_parseable
end

#starting(parseable) ⇒ Object 



39
40
41
42
 
# File 'lib/grammar.rb', line 39

def starting parseable
	raise "starting rule already defined" if @starting_rule
	@starting_rule = parseable.to_parseable
end