Class: Racc::Grammar

Inherits:
Object show all
Extended by:
Forwardable
Defined in:
lib/racc/grammar.rb

Defined Under Namespace

Classes: DefinitionEnv, PrecedenceDefinitionEnv

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(debug_flags = DebugFlags.new) ⇒ Grammar

Returns a new instance of Grammar.



23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/racc/grammar.rb', line 23

def initialize(debug_flags = DebugFlags.new)
  @symboltable = SymbolTable.new
  @debug_symbol = debug_flags.token
  @rules   = []  # :: [Rule]
  @start   = nil
  @n_expected_srconflicts = nil
  @prec_table = []
  @prec_table_closed = false
  @closed = false
  @states = nil
end

Instance Attribute Details

#n_expected_srconflicts ⇒ Object

Returns the value of attribute n_expected_srconflicts.



37
38
39
 
# File 'lib/racc/grammar.rb', line 37

def n_expected_srconflicts
  @n_expected_srconflicts
end

#start ⇒ Object (readonly)

Returns the value of attribute start.



35
36
37
 
# File 'lib/racc/grammar.rb', line 35

def start
  @start
end

#symboltable ⇒ Object (readonly)

Returns the value of attribute symboltable.



36
37
38
 
# File 'lib/racc/grammar.rb', line 36

def symboltable
  @symboltable
end

Class Method Details

.define(&block) ⇒ Object

Dynamic Generation Interface



198
199
200
201
202
 
# File 'lib/racc/grammar.rb', line 198

def Grammar.define(&block)
  env = DefinitionEnv.new
  env.instance_eval(&block)
  env.grammar
end

Instance Method Details

#[](x) ⇒ Object 



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

def [](x)
  @rules[x]
end

#add(rule) ⇒ Object

Grammar Definition Interface

Raises:

  • (ArgumentError) 


163
164
165
166
 
# File 'lib/racc/grammar.rb', line 163

def add(rule)
  raise ArgumentError, "rule added after the Grammar closed" if @closed
  @rules.push rule
end

#added?(sym) ⇒ Boolean

Returns:

  • (Boolean) 


168
169
170
 
# File 'lib/racc/grammar.rb', line 168

def added?(sym)
  @rules.detect {|r| r.target == sym }
end

#declare_precedence(assoc, syms) ⇒ Object

Raises:



177
178
179
180
 
# File 'lib/racc/grammar.rb', line 177

def declare_precedence(assoc, syms)
  raise CompileError, "precedence table defined twice" if @prec_table_closed
  @prec_table.push [assoc, syms]
end

#dfa ⇒ Object Also known as: states 



117
118
119
 
# File 'lib/racc/grammar.rb', line 117

def dfa
  (@states ||= States.new(self)).dfa
end

#each_index(&block) ⇒ Object 



49
50
51
 
# File 'lib/racc/grammar.rb', line 49

def each_index(&block)
  @rules.each_index(&block)
end

#each_rule(&block) ⇒ Object Also known as: each 



43
44
45
 
# File 'lib/racc/grammar.rb', line 43

def each_rule(&block)
  @rules.each(&block)
end

#each_with_index(&block) ⇒ Object 



53
54
55
 
# File 'lib/racc/grammar.rb', line 53

def each_with_index(&block)
  @rules.each_with_index(&block)
end

#end_precedence_declaration(reverse) ⇒ Object 



182
183
184
185
186
187
188
189
190
191
192
 
# File 'lib/racc/grammar.rb', line 182

def end_precedence_declaration(reverse)
  @prec_table_closed = true
  return if @prec_table.empty?
  table = reverse ? @prec_table.reverse : @prec_table
  table.each_with_index do |(assoc, syms), idx|
    syms.each do |sym|
      sym.assoc = assoc
      sym.precedence = idx
    end
  end
end

#init ⇒ Object

Computation

Raises:



406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
 
# File 'lib/racc/grammar.rb', line 406

def init
  return if @closed
  @closed = true
  @start ||= @rules.map {|r| r.target }.detect {|sym| not sym.dummy? }
  raise CompileError, 'no rule in input' if @rules.empty?
  add_start_rule
  @rules.freeze
  fix_ident
  compute_hash
  compute_heads
  determine_terminals
  compute_nullable_0
  @symboltable.fix
  compute_locate
  @symboltable.each_nonterminal {|t| compute_expand t }
  compute_nullable
  compute_useless
end

#intern(value, dummy = false) ⇒ Object 



71
72
73
 
# File 'lib/racc/grammar.rb', line 71

def intern(value, dummy = false)
  @symboltable.intern(value, dummy)
end

#n_useless_nonterminals ⇒ Object 



87
88
89
90
91
92
93
94
95
96
 
# File 'lib/racc/grammar.rb', line 87

def n_useless_nonterminals
  @n_useless_nonterminals ||=
      begin
        n = 0
        @symboltable.each_nonterminal do |sym|
          n += 1 if sym.useless?
        end
        n
      end
end

#n_useless_rules ⇒ Object 



102
103
104
105
106
107
108
109
110
111
 
# File 'lib/racc/grammar.rb', line 102

def n_useless_rules
  @n_useless_rules ||=
      begin
        n = 0
        each do |r|
          n += 1 if r.useless?
        end
        n
      end
end

#nfa ⇒ Object 



113
114
115
 
# File 'lib/racc/grammar.rb', line 113

def nfa
  (@states ||= States.new(self)).nfa
end

#nonterminal_base ⇒ Object 



79
80
81
 
# File 'lib/racc/grammar.rb', line 79

def nonterminal_base
  @symboltable.nt_base
end

#parser_class ⇒ Object 



127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/racc/grammar.rb', line 127

def parser_class
  states = states()   # cache
  if $DEBUG
    srcfilename = caller(1).first.slice(/\A(.*?):/, 1)
    begin
      write_log srcfilename + ".output"
    rescue SystemCallError
    end
    report = lambda {|s| $stderr.puts "racc: #{srcfilename}: #{s}" }
    if states.should_report_srconflict?
      report["#{states.n_srconflicts} shift/reduce conflicts"]
    end
    if states.rrconflict_exist?
      report["#{states.n_rrconflicts} reduce/reduce conflicts"]
    end
    g = states.grammar
    if g.useless_nonterminal_exist?
      report["#{g.n_useless_nonterminals} useless nonterminals"]
    end
    if g.useless_rule_exist?
      report["#{g.n_useless_rules} useless rules"]
    end
  end
  states.state_transition_table.parser_class
end

#size ⇒ Object 



57
58
59
 
# File 'lib/racc/grammar.rb', line 57

def size
  @rules.size
end

#start_symbol=(s) ⇒ Object

Raises:



172
173
174
175
 
# File 'lib/racc/grammar.rb', line 172

def start_symbol=(s)
  raise CompileError, "start symbol set twice'" if @start
  @start = s
end

#state_transition_table ⇒ Object 



123
124
125
 
# File 'lib/racc/grammar.rb', line 123

def state_transition_table
  states().state_transition_table
end

#symbols ⇒ Object 



75
76
77
 
# File 'lib/racc/grammar.rb', line 75

def symbols
  @symboltable.symbols
end

#to_s ⇒ Object 



61
62
63
 
# File 'lib/racc/grammar.rb', line 61

def to_s
  "<Racc::Grammar>"
end

#useless_nonterminal_exist? ⇒ Boolean

Returns:

  • (Boolean) 


83
84
85
 
# File 'lib/racc/grammar.rb', line 83

def useless_nonterminal_exist?
  n_useless_nonterminals() != 0
end

#useless_rule_exist? ⇒ Boolean

Returns:

  • (Boolean) 


98
99
100
 
# File 'lib/racc/grammar.rb', line 98

def useless_rule_exist?
  n_useless_rules() != 0
end

#write_log(path) ⇒ Object 



153
154
155
156
157
 
# File 'lib/racc/grammar.rb', line 153

def write_log(path)
  File.open(path, 'w') {|f|
    LogFileGenerator.new(states()).output f
  }
end