Class: Aurum::LexicalSpecification

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

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(definition = {:initial => {}}, state = :initial) ⇒ LexicalSpecification

Returns a new instance of LexicalSpecification.



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

def initialize definition = {:initial => {}}, state = :initial 
  @definitions, @character_classes = definition, CharacterClassDefinition.new
  @lexical_definition, @patterns = @definitions[state], {}
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

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



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

def method_missing name, *patterns, &action 
  return __get_pattern(name) if patterns.empty?
  pattern = Pattern.concat *(patterns.collect {|x| x.kind_of?(Pattern) ? x : Pattern.from_string(x.to_s)})       
  @patterns[name] = pattern
  if name.to_s =~ /^_/ 
    recognize_action = RecognizeTokenAction.new(name.to_s)
    recognize_action.action = action
    @lexical_definition[pattern] = recognize_action
  end 
  pattern
end

Instance Attribute Details

#character_classes ⇒ Object (readonly)

Returns the value of attribute character_classes.



38
39
40
 
# File 'lib/aurum/grammar.rb', line 38

def character_classes
  @character_classes
end

#definitions ⇒ Object (readonly)

Returns the value of attribute definitions.



38
39
40
 
# File 'lib/aurum/grammar.rb', line 38

def definitions
  @definitions
end

Instance Method Details

#__create_pattern(action, *patterns) ⇒ Object 



103
104
105
106
107
 
# File 'lib/aurum/grammar.rb', line 103

def __create_pattern action, *patterns 
  pattern = Pattern.concat *(patterns.collect {|x| x.kind_of?(Pattern) ? x : Pattern.from_string(x.to_s)})
  @lexical_definition[pattern] = action
  pattern 
end

#__get_pattern(name) ⇒ Object 



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

def __get_pattern name
  return @patterns[name] if @patterns.has_key? name
  Pattern.from_char_set @character_classes.definitions[name]  
end

#cat(*patterns) ⇒ Object 



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

def cat *patterns
  Pattern.concat *(patterns.collect {|x| x.kind_of?(Pattern) ? x : Pattern.from_string(x.to_s)})
end

#enum(literal) ⇒ Object 



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

def enum literal
  Pattern.from_enum literal
end

#ignore(*patterns) ⇒ Object 



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

def ignore *patterns
  __create_pattern IgnoreAction, *patterns
end

#match(*patterns, &action) ⇒ Object 



67
68
69
 
# File 'lib/aurum/grammar.rb', line 67

def match *patterns, &action
  __create_pattern UserDefinedAction.new(action), *patterns
end

#range(a, b) ⇒ Object 



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

def range a, b
  Pattern.from_char_set CharacterSet::Interval.new(a, b).to_char_set
end

#recognize_and_shift_to(token, state, *patterns) ⇒ Object 



82
83
84
 
# File 'lib/aurum/grammar.rb', line 82

def recognize_and_shift_to token, state, *patterns
  __create_pattern RecognizeTokenAndChangeStateAction.new(token.to_s, state), *patterns
end

#shift_to(state, *patterns, &config) ⇒ Object 



61
62
63
64
65
 
# File 'lib/aurum/grammar.rb', line 61

def shift_to state, *patterns, &config
  pattern = __create_pattern ChangeStateAction.new(state), *patterns
  within state, &config if block_given?
  pattern
end

#string(literal) ⇒ Object 



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

def string literal
  Pattern.from_string literal
end

#within(*states, &config) ⇒ Object 



75
76
77
78
79
80
 
# File 'lib/aurum/grammar.rb', line 75

def within *states, &config
  for state in states
    @definitions[state] = {} unless @definitions[state] 
    LexicalSpecification.new(@definitions, state).instance_eval &config               
  end
end