← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/racc/intrepid

« back to all changes in this revision

Viewing changes to packages/racc/src/build

  • Committer: Bazaar Package Importer
  • Author(s): akira yamada
  • Date: 2005-04-09 17:54:44 UTC
  • mfrom: (1.2.1 upstream) (2.1.1 warty)
  • Revision ID: james.westby@ubuntu.com-20050409175444-fvtir838ypkn7a58
Tags: 1.4.4-1
http://bugs.debian.org/301768
* new upstream version.  (closes: #301768)
* added racc2y.1 and y2racc.1.
* modified racc2y and y2racc to use optparse instead of deprecated getopts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
packages/racc/src/build
1
 
#!/usr/local/bin/ruby
2
 
 
3
 
require 'racc/info'
4
 
require 'racc/grammar'
5
 
require 'racc/state'
6
 
require 'racc/output'
7
 
 
8
 
 
9
 
def openread( fn )
10
 
  fn = File.expand_path( fn )
11
 
  f = File.open( fn )
12
 
  ret = f.read
13
 
  f.close
14
 
  ret
15
 
end
16
 
 
17
 
module Racc
18
 
 
19
 
 
20
 
class LALRstate
21
 
  def sr_conflict( *args )
22
 
    bug! 'sr conflict in build'
23
 
  end
24
 
  def rr_conflict( *args )
25
 
    bug! 'sr conflict in build'
26
 
  end
27
 
end
28
 
    
29
 
class Compiler
30
 
 
31
 
  attr :ruletable
32
 
  attr :symboltable
33
 
  attr :statetable
34
 
 
35
 
  def filename() '(build)' end
36
 
 
37
 
  def debug_parser() @dflag end
38
 
  def convert_line() true end
39
 
  def omit_action()  true end
40
 
  def result_var()   true end
41
 
 
42
 
  def debug()   false end
43
 
  def d_parse() false end
44
 
  def d_rule()  false end
45
 
  def d_token() false end
46
 
  def d_state() false end
47
 
  def d_la()    false end
48
 
  def d_prec()  false end
49
 
 
50
 
 
51
 
  def r( targ, symlist, act )
52
 
    targ = @symboltable.get( targ ) if targ
53
 
 
54
 
    symlist.collect! do |i|
55
 
      bug! 'nil in symlist' unless i
56
 
      @symboltable.get(i)
57
 
    end
58
 
    act.sub!( /\A\s*\n/, '' )
59
 
    act.sub!( /\s+\z/, '' )
60
 
 
61
 
    /:(\d+)(?:\z|:)/ === caller(1)[0]
62
 
    lineno = $1.to_i + 1
63
 
    symlist.push UserAction.new( act, lineno )
64
 
 
65
 
    @ruletable.register_rule( targ, symlist )
66
 
  end
67
 
 
68
 
 
69
 
  def build( debugflag )
70
 
    @dflag = debugflag
71
 
 
72
 
    @symboltable = SymbolTable.new( self )
73
 
    @ruletable   = RuleTable.new( self )
74
 
    @statetable  = StateTable.new( self )
75
 
 
76
 
############
77
 
    # 1
78
 
    r :xclass, [ :XCLASS, :class, :params, :XRULE, :rules, :XEND ], %{
79
 
      @ruletable.end_register_rule
80
 
    }
81
 
############
82
 
    r :class, [ :rubyconst ], %{
83
 
      @class_name = val[0]
84
 
    }
85
 
    r nil, [ :rubyconst, '<', :rubyconst ], %{
86
 
      @class_name = val[0]
87
 
      @super_class = val[2]
88
 
    }
89
 
############
90
 
    r :rubyconst, [ :XSYMBOL ], %{
91
 
      result = result.id2name
92
 
    }
93
 
    r nil, [ :rubyconst, ':', ':', :XSYMBOL ], %{
94
 
      result << '::' << val[3].id2name
95
 
    }
96
 
############
97
 
    # 2
98
 
    r :params, [], ''
99
 
    # 3
100
 
    r nil, [ :params, :param_seg ], ''
101
 
############
102
 
    # 4
103
 
    r :param_seg, [ :XCONV, :convdefs, :XEND ], %{
104
 
      @symboltable.end_register_conv
105
 
    }
106
 
    # 5
107
 
    r nil, [ :xprec ], ''
108
 
    # 6
109
 
    r nil, [ :XSTART, :symbol ], %{
110
 
      @ruletable.register_start val[1]
111
 
    }
112
 
    # 7
113
 
    r nil, [ :XTOKEN, :symbol_list ], %{
114
 
      @symboltable.register_token val[1]
115
 
    }
116
 
    # 8
117
 
    r nil, [ :XOPTION, :bare_symlist ], %{
118
 
      val[1].each do |s|
119
 
        @ruletable.register_option s.to_s
120
 
      end
121
 
    }
122
 
    r nil, [ :XEXPECT, :DIGIT ], %{
123
 
      @ruletable.expect val[1]
124
 
    }
125
 
############
126
 
    # 7
127
 
    r :convdefs, [ :symbol, :STRING ], %{
128
 
      @symboltable.register_conv( val[0], val[1] )
129
 
    }
130
 
    # 8
131
 
    r nil, [ :convdefs, :symbol, :STRING ], %{
132
 
      @symboltable.register_conv( val[1], val[2] )
133
 
    }
134
 
############
135
 
    # 9
136
 
    r :xprec, [ :XPRECHIGH, :preclines, :XPRECLOW ], %{
137
 
      @symboltable.end_register_prec( true )
138
 
    }
139
 
    # 10
140
 
    r nil, [ :XPRECLOW, :preclines, :XPRECHIGH ], %{
141
 
      @symboltable.end_register_prec( false )
142
 
    }
143
 
############
144
 
    # 11
145
 
    r :preclines, [ :precline ], ''
146
 
    # 12
147
 
    r nil, [ :preclines, :precline ], ''
148
 
############
149
 
    # 13
150
 
    r :precline, [ :XLEFT, :symbol_list ], %{
151
 
      @symboltable.register_prec( :Left, val[1] )
152
 
    }
153
 
    # 14
154
 
    r nil, [ :XRIGHT, :symbol_list ], %{
155
 
      @symboltable.register_prec( :Right, val[1] )
156
 
    }
157
 
    # 15
158
 
    r nil, [ :XNONASSOC, :symbol_list ], %{
159
 
      @symboltable.register_prec( :Nonassoc, val[1] )
160
 
    }
161
 
############
162
 
    # 16
163
 
    r :symbol_list, [ :symbol ], %{
164
 
      result = val
165
 
    }
166
 
    # 17
167
 
    r nil, [ :symbol_list, :symbol ], %{
168
 
      result.push val[1]
169
 
    }
170
 
    r nil, [ :symbol_list, '|' ], ''
171
 
############
172
 
    # 18
173
 
    r :symbol, [ :XSYMBOL ], %{
174
 
      result = @symboltable.get( result )
175
 
    }
176
 
    # 19
177
 
    r nil,    [ :STRING ], %{
178
 
      result = @symboltable.get( eval '"' + val[0] + '"' )
179
 
    }
180
 
############
181
 
    # 20
182
 
    r :rules, [ :rules_core ], %{
183
 
      unless result.empty? then
184
 
        @ruletable.register_rule_from_array result
185
 
      end
186
 
    }
187
 
    # 21
188
 
    r nil, [], ''
189
 
############
190
 
    # 22
191
 
    r :rules_core, [ :symbol ], %{
192
 
      result = val
193
 
    }
194
 
    # 23
195
 
    r nil,         [ :rules_core, :rule_item ], %{
196
 
      result.push val[1]
197
 
    }
198
 
    # 24
199
 
    r nil,         [ :rules_core, ';' ], %{
200
 
      unless result.empty? then
201
 
        @ruletable.register_rule_from_array result
202
 
      end
203
 
      result.clear
204
 
    }
205
 
    # 25
206
 
    r nil,         [ :rules_core, ':' ], %{
207
 
      pre = result.pop
208
 
      unless result.empty? then
209
 
        @ruletable.register_rule_from_array result
210
 
      end
211
 
      result = [pre]
212
 
    }
213
 
############
214
 
    # 26
215
 
    r :rule_item, [ :symbol ], ''
216
 
    # 27
217
 
    r nil,        [ '|' ], %{
218
 
      result = OrMark.new( @scanner.lineno )
219
 
    }
220
 
    # 28
221
 
    r nil,        [ '=', :symbol ], %{
222
 
      result = Prec.new( val[1], @scanner.lineno )
223
 
    }
224
 
    # 29
225
 
    r nil,        [ :ACTION ], %{
226
 
      result = UserAction.new( *result )
227
 
    }
228
 
############
229
 
    r :bare_symlist, [ :XSYMBOL ], %{
230
 
      result = [ result.id2name ]
231
 
    }
232
 
    r nil,           [ :bare_symlist, :XSYMBOL ], %{
233
 
      result.push val[1].id2name
234
 
    }
235
 
############
236
 
 
237
 
    @ruletable.init
238
 
    @statetable.init
239
 
    @statetable.determine
240
 
 
241
 
    File.open( 'raccp.rb', 'w' ) do |f|
242
 
      f.write <<'HEADER_END'
243
 
#
244
 
# This file is automatically generated. DO NOT MODIFY!!
245
 
#
246
 
# raccp.rb
247
 
#
248
 
#   Copyright (c) 1999-2001 Minero Aoki <aamine@loveruby.net>
249
 
#
250
 
#   This program is free software.
251
 
#   You can distribute/modify this program under the terms of
252
 
#   the GNU Lesser General Public License version 2.
253
 
#
254
 
 
255
 
require 'racc/parser'
256
 
require 'racc/raccs'
257
 
require 'racc/ucodep'
258
 
 
259
 
 
260
 
module Racc
261
 
 
262
 
  class GrammarFileParser < Parser
263
 
 
264
 
    def initialize( racc )
265
 
      @yydebug     = racc.d_parse && Racc_debug_parser
266
 
      @ruletable   = racc.ruletable
267
 
      @symboltable = racc.symboltable
268
 
 
269
 
      @class_name = nil
270
 
      @super_class = nil
271
 
    end
272
 
 
273
 
    attr :class_name
274
 
    attr :super_class
275
 
 
276
 
    def parse( str )
277
 
      @scanner = GrammarFileScanner.new( str )
278
 
      @scanner.debug = @yydebug
279
 
 
280
 
      do_parse
281
 
    end
282
 
 
283
 
 
284
 
    private
285
 
 
286
 
    def next_token
287
 
      @scanner.scan
288
 
    end
289
 
 
290
 
    def on_error( tok, val, _values )
291
 
      if val.respond_to? :id2name then
292
 
        v = val.id2name
293
 
      elsif String === val then
294
 
        v = val
295
 
      else
296
 
        v = val.inspect
297
 
      end
298
 
      raise ParseError, "#{@scanner.lineno}: unexpected token '#{v}'"
299
 
    end
300
 
 
301
 
HEADER_END
302
 
      fmt = CodeGenerator.new( self )
303
 
      fmt.output( f )
304
 
      f.write <<'FOOTER_END'
305
 
  end
306
 
 
307
 
end   # module Racc
308
 
FOOTER_END
309
 
    end
310
 
 
311
 
    ver = VerboseOutputter.new( self )
312
 
    File.open( 'b.output', 'w' ) do |f|
313
 
      ver.output( f )
314
 
    end
315
 
  end
316
 
 
317
 
end
318
 
 
319
 
end
320
 
 
321
 
 
322
 
de = false
323
 
ARGV.each do |i|
324
 
  case i
325
 
  when '-g' then de = true
326
 
  end
327
 
end
328
 
Racc::Compiler.new.build de