Class: JSGF::Parser

Inherits:
Racc::Parser
  • Object
show all
Defined in:
lib/jsgf/parser.rb

Constant Summary collapse

Racc_arg = 
[
racc_action_table,
racc_action_check,
racc_action_default,
racc_action_pointer,
racc_goto_table,
racc_goto_check,
racc_goto_default,
racc_goto_pointer,
racc_nt_base,
racc_reduce_table,
racc_token_table,
racc_shift_n,
racc_reduce_n,
racc_use_result_var ]
Racc_token_to_s_table = 
[
"$end",
"error",
"GRAMMAR",
"HEADER",
"IMPORT",
"PUBLIC",
"TAG",
"TOKEN",
"WEIGHT",
"\";\"",
"\"<\"",
"\">\"",
"\"=\"",
"\"|\"",
"\"(\"",
"\")\"",
"\"[\"",
"\"]\"",
"\"*\"",
"\"+\"",
"$start",
"grammar",
"header",
"rule_list",
"import_header",
"jsgf_header",
"grammar_header",
"import_statement",
"rule_name",
"rule",
"alternation",
"atom_list",
"alternation_item",
"rule_atom",
"weighted_item",
"tagged_atom",
"group_list",
"rule_group",
"rule_optional" ]
Racc_debug_parser = 
false

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(tokenizer) ⇒ Parser

Returns a new instance of Parser.



24
25
26
27
28
29
30
31
 
# File 'lib/jsgf/parser.rb', line 24

def initialize(tokenizer)
    @private_rules = {}
    @public_rules = {}
    @rules = {}
    tokenizer = JSGF::Tokenizer.new(tokenizer) if tokenizer.is_a?(String)
    @tokenizer = tokenizer
    super()
end

Instance Attribute Details

#grammar_name ⇒ Object (readonly)

Returns the value of attribute grammar_name.



21
22
23
 
# File 'lib/jsgf/parser.rb', line 21

def grammar_name
  @grammar_name
end

#handler ⇒ Object (readonly)

Returns the value of attribute handler.



22
23
24
 
# File 'lib/jsgf/parser.rb', line 22

def handler
  @handler
end

Instance Method Details

#_reduce_15(val, _values, result) ⇒ Object

reduce 14 omitted



316
317
318
319
 
# File 'lib/jsgf/parser.rb', line 316

def _reduce_15(val, _values, result)
 result = val[1] 
    result
end

#_reduce_16(val, _values, result) ⇒ Object 



321
322
323
324
 
# File 'lib/jsgf/parser.rb', line 321

def _reduce_16(val, _values, result)
 result = define_rule(val[0], :private, *(val[2..-2])) 
    result
end

#_reduce_17(val, _values, result) ⇒ Object 



326
327
328
329
 
# File 'lib/jsgf/parser.rb', line 326

def _reduce_17(val, _values, result)
 result = define_rule(val[0], :private, *(val[2..-2])) 
    result
end

#_reduce_18(val, _values, result) ⇒ Object 



331
332
333
334
 
# File 'lib/jsgf/parser.rb', line 331

def _reduce_18(val, _values, result)
 val[1][:visibility] = :public 
    result
end

#_reduce_19(val, _values, result) ⇒ Object 



336
337
338
339
 
# File 'lib/jsgf/parser.rb', line 336

def _reduce_19(val, _values, result)
 result = val.first 
    result
end

#_reduce_20(val, _values, result) ⇒ Object 



341
342
343
344
 
# File 'lib/jsgf/parser.rb', line 341

def _reduce_20(val, _values, result)
 result = define_alternation(*val) 
    result
end

#_reduce_24(val, _values, result) ⇒ Object

reduce 23 omitted



352
353
354
355
 
# File 'lib/jsgf/parser.rb', line 352

def _reduce_24(val, _values, result)
 val[0].tags.push(val[1]); result = val[0] 
    result
end

#_reduce_26(val, _values, result) ⇒ Object

reduce 25 omitted



359
360
361
362
 
# File 'lib/jsgf/parser.rb', line 359

def _reduce_26(val, _values, result)
 result = val; 
    result
end

#_reduce_27(val, _values, result) ⇒ Object 



364
365
366
367
 
# File 'lib/jsgf/parser.rb', line 364

def _reduce_27(val, _values, result)
 val[1].respond_to?(:weight) ? (val[1].weight = val.first[1..-2].to_f) : (val[1][:weight] = val.first[1..-2].to_f); result = val[1] 
    result
end

#_reduce_30(val, _values, result) ⇒ Object

reduce 29 omitted



373
374
375
376
 
# File 'lib/jsgf/parser.rb', line 373

def _reduce_30(val, _values, result)
 result = val[1] 
    result
end

#_reduce_31(val, _values, result) ⇒ Object 



378
379
380
381
 
# File 'lib/jsgf/parser.rb', line 378

def _reduce_31(val, _values, result)
 result = define_optional(val[1]) 
    result
end

#_reduce_32(val, _values, result) ⇒ Object 



383
384
385
386
 
# File 'lib/jsgf/parser.rb', line 383

def _reduce_32(val, _values, result)
 result = JSGF::Atom.new(val.first) 
    result
end

#_reduce_33(val, _values, result) ⇒ Object 



388
389
390
391
 
# File 'lib/jsgf/parser.rb', line 388

def _reduce_33(val, _values, result)
 result = rule_reference(val[0]) 
    result
end

#_reduce_36(val, _values, result) ⇒ Object

reduce 35 omitted



397
398
399
400
 
# File 'lib/jsgf/parser.rb', line 397

def _reduce_36(val, _values, result)
 result = JSGF::Repetition.new(val[0], 0) 
    result
end

#_reduce_37(val, _values, result) ⇒ Object 



402
403
404
405
 
# File 'lib/jsgf/parser.rb', line 402

def _reduce_37(val, _values, result)
 result = JSGF::Repetition.new(val[0], 1) 
    result
end

#_reduce_6(val, _values, result) ⇒ Object

reduce 5 omitted



286
287
288
289
 
# File 'lib/jsgf/parser.rb', line 286

def _reduce_6(val, _values, result)
 @version = val[1]; 
    result
end

#_reduce_7(val, _values, result) ⇒ Object 



291
292
293
294
 
# File 'lib/jsgf/parser.rb', line 291

def _reduce_7(val, _values, result)
 @version = val[1]; @charset = val[2]; 
    result
end

#_reduce_8(val, _values, result) ⇒ Object 



296
297
298
299
 
# File 'lib/jsgf/parser.rb', line 296

def _reduce_8(val, _values, result)
 @version = val[1]; @charset = val[2]; @locale = val[3]; 
    result
end

#_reduce_9(val, _values, result) ⇒ Object 



301
302
303
304
 
# File 'lib/jsgf/parser.rb', line 301

def _reduce_9(val, _values, result)
 @grammar_name = val[1] 
    result
end

#_reduce_none(val, _values, result) ⇒ Object 



407
408
409
 
# File 'lib/jsgf/parser.rb', line 407

def _reduce_none(val, _values, result)
  val[0]
end

#define_alternation(*args) ⇒ Object 



33
34
35
36
37
38
39
40
 
# File 'lib/jsgf/parser.rb', line 33

def define_alternation(*args)
    if args.first.is_a?(JSGF::Alternation)
  args.first.push *(args.drop(2))
  args.first
    else
  JSGF::Alternation.new(*(args.each_slice(2).map {|a,b| a}))
    end
end

#define_optional(*args) ⇒ Object 



42
43
44
45
46
47
48
49
 
# File 'lib/jsgf/parser.rb', line 42

def define_optional(*args)
    if args.first.respond_to?(:optional)
  args.first.optional = true
  args.first
    else
  JSGF::Optional.new(*args)
    end
end

#define_rule(name, visibility = :private, *args) ⇒ Object 



51
52
53
54
55
 
# File 'lib/jsgf/parser.rb', line 51

def define_rule(name, visibility=:private, *args)
    r = {name: name, visibility:visibility, atoms:args.flatten}
    @rules[name] = r
    r
end

#next_token ⇒ Object 



61
62
63
 
# File 'lib/jsgf/parser.rb', line 61

def next_token
  @tokenizer.next_token
end

#parse ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/jsgf/parser.rb', line 65

def parse
    do_parse

    @rules.each do |(k,v)|
  if v[:visibility] == :private
      @private_rules[k] = JSGF::Rule.new(v[:atoms])
  else
      @public_rules[k] = JSGF::Rule.new(v[:atoms])
  end
    end

    JSGF::Grammar.new(  name:@grammar_name,
      character_encoding:@charset,
      locale:@locale,
      private_rules:@private_rules,
      public_rules:@public_rules,
      version:@version)
end

#rule_reference(name) ⇒ Object 



57
58
59
 
# File 'lib/jsgf/parser.rb', line 57

def rule_reference(name)
    JSGF::Atom.new(name, reference:true)
end