Class: Aurum::Grammar::DSL::LexicalRulesBuilder

Inherits:
Object
  • Object
show all
Defined in:
lib/aurum/grammar/dsl/lexical_definition.rb

Instance Method Summary collapse

Constructor Details

#initialize(lexical_rules, character_classes) ⇒ LexicalRulesBuilder

Returns a new instance of LexicalRulesBuilder.



34
35
36
37
 
# File 'lib/aurum/grammar/dsl/lexical_definition.rb', line 34

def initialize lexical_rules, character_classes
  @lexical_rules, @character_classes = lexical_rules, character_classes
  @named_patterns, @current_states = {}, [['initial']]
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *patterns, &semantic_action) ⇒ Object 



81
82
83
84
85
86
87
88
89
90
 
# File 'lib/aurum/grammar/dsl/lexical_definition.rb', line 81

def method_missing name, *patterns, &semantic_action
  name, pattern = name.to_s, concat(*patterns)
  return match(pattern, :recognize => name, &semantic_action) if name =~ /^_/
  if patterns.empty?
    return @named_patterns[name] if @named_patterns.has_key? name
    return Aurum::Grammar::LexicalRules::Pattern.character_set(@character_classes.__named_character_classes__[name]) if @character_classes.__named_character_classes__.has_key? name
    raise "can not find pattern named '#{name}'"
  end
  @named_patterns[name] = concat(*patterns)
end

Instance Method Details

#concat(*patterns) ⇒ Object 



51
52
53
54
55
 
# File 'lib/aurum/grammar/dsl/lexical_definition.rb', line 51

def concat *patterns
  Aurum::Grammar::LexicalRules::Pattern.concat(patterns.map do
    |pattern| pattern.is_a?(Aurum::Grammar::LexicalRules::Pattern) ? pattern : string(pattern.to_s)
  end)
end

#enum(literal) ⇒ Object 



43
44
45
 
# File 'lib/aurum/grammar/dsl/lexical_definition.rb', line 43

def enum literal
  Aurum::Grammar::LexicalRules::Pattern.enum(literal)
end

#ignore(pattern, options = {}, &semantic_action) ⇒ Object 



65
66
67
68
 
# File 'lib/aurum/grammar/dsl/lexical_definition.rb', line 65

def ignore pattern, options = {}, &semantic_action
  options[:recognize] = '$ignored'
  match(pattern, options, &semantic_action)
end

#match(pattern, options = {}, &semantic_action) ⇒ Object 



70
71
72
73
74
75
76
77
78
79
 
# File 'lib/aurum/grammar/dsl/lexical_definition.rb', line 70

def match pattern, options = {}, &semantic_action
  event = options[:event].to_s if options.has_key?(:event)
  token = options[:recognize].to_s if options.has_key?(:recognize)
  lexical_state = options[:shift_to].to_s if options.has_key?(:shift_to)
  action = Aurum::LexicalTable::Action.new(token, lexical_state, event, semantic_action)
  pattern = string(pattern.to_s) unless pattern.is_a?(Aurum::Grammar::LexicalRules::Pattern)
  for state in @current_states.last
    @lexical_rules.add_lexical_action(state, pattern, action)
  end
end

#range(first, last = first) ⇒ Object 



39
40
41
 
# File 'lib/aurum/grammar/dsl/lexical_definition.rb', line 39

def range first, last = first
  Aurum::Grammar::LexicalRules::Pattern.character_set(Grammar.range(first, last))
end

#string(literal) ⇒ Object 



47
48
49
 
# File 'lib/aurum/grammar/dsl/lexical_definition.rb', line 47

def string literal
  Aurum::Grammar::LexicalRules::Pattern.string literal
end

#within(*states, &definition) ⇒ Object 



57
58
59
60
61
62
63
 
# File 'lib/aurum/grammar/dsl/lexical_definition.rb', line 57

def within *states, &definition
  @saved_named_patterns = @named_patterns.dup
  @current_states << states.map {|state| state.to_s}
  instance_eval(&definition)
  @current_states.pop
  @named_patterns = @saved_named_patterns
end