Class: Rley::Parser::ParseEntry

Inherits:
Object
  • Object
show all
Defined in:
lib/rley/parser/parse_entry.rb

Overview

Responsibilities:

  • To know whether the vertex is a start, end or item vertex
  • To know the next symbol to expect

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(aVertex, theOrigin) ⇒ ParseEntry 



24
25
26
27
28
 
# File 'lib/rley/parser/parse_entry.rb', line 24

def initialize(aVertex, theOrigin)
  @vertex = valid_vertex(aVertex)
  @origin = theOrigin
  @antecedents = []
end

Instance Attribute Details

#antecedents ⇒ Array<ParseEntry> (readonly) 



15
16
17
 
# File 'lib/rley/parser/parse_entry.rb', line 15

def antecedents
  @antecedents
end

#origin ⇒ Integer (readonly)

the position in the input that matches the beginning of the rhs of the production.



20
21
22
 
# File 'lib/rley/parser/parse_entry.rb', line 20

def origin
  @origin
end

#vertex ⇒ GFG::Vertex (readonly) 



12
13
14
 
# File 'lib/rley/parser/parse_entry.rb', line 12

def vertex
  @vertex
end

Instance Method Details

#==(other) ⇒ Object

Equality comparison. A parse entry behaves as a value object.



50
51
52
53
54
55
 
# File 'lib/rley/parser/parse_entry.rb', line 50

def ==(other)
  return true if object_id == other.object_id

  result = (vertex == other.vertex) && (origin == other.origin)
  return result
end

#add_antecedent(anAntecedent) ⇒ Object

Add a link to an antecedent parse entry



45
46
47
 
# File 'lib/rley/parser/parse_entry.rb', line 45

def add_antecedent(anAntecedent)
  antecedents << anAntecedent unless antecedents.include?(anAntecedent)
end

#dotted_entry? ⇒ Boolean

Returns true iff the vertex corresponds to a dotted item X => Y



72
73
74
 
# File 'lib/rley/parser/parse_entry.rb', line 72

def dotted_entry?
  return vertex.kind_of?(GFG::ItemVertex)
end

#end_entry? ⇒ Boolean

Returns true iff the vertex is an end vertex (i.e. of the form: X.)



82
83
84
 
# File 'lib/rley/parser/parse_entry.rb', line 82

def end_entry?()
  return vertex.kind_of?(GFG::EndVertex)
end

#entry_entry? ⇒ Boolean

Returns true iff the vertex is at the start of rhs (i.e. of the form: X => .Y



64
65
66
67
68
 
# File 'lib/rley/parser/parse_entry.rb', line 64

def entry_entry?()
  return false unless vertex.kind_of?(GFG::ItemVertex)

  return vertex.dotted_item.at_start?
end

#exit_entry? ⇒ Boolean

Returns true iff the vertex is at end of rhs (i.e. of the form: X => Y.)



77
78
79
 
# File 'lib/rley/parser/parse_entry.rb', line 77

def exit_entry?()
  return vertex.complete?
end

#inspect ⇒ String

Returns a string containing a human-readable representation of the production.



33
34
35
36
37
38
39
40
41
42
 
# File 'lib/rley/parser/parse_entry.rb', line 33

def inspect()
  result = selfie
  result << ' @antecedents=['
  antecedents.each do |antec|
    result << antec.selfie
  end
  result << ']>'

  return result
end

#next_symbol ⇒ Object

Return the symbol after the dot (if any)



92
93
94
 
# File 'lib/rley/parser/parse_entry.rb', line 92

def next_symbol()
  return vertex.next_symbol
end

#orphan? ⇒ Boolean

Return true if the entry has no antecedent entry



97
98
99
 
# File 'lib/rley/parser/parse_entry.rb', line 97

def orphan?()
  return antecedents.empty?
end

#prev_symbol ⇒ Object

Return the symbol before the dot (if any)



87
88
89
 
# File 'lib/rley/parser/parse_entry.rb', line 87

def prev_symbol()
  return vertex.prev_symbol
end

#start_entry? ⇒ Boolean

Returns true iff the vertex is a start vertex (i.e. of the form: .X)



58
59
60
 
# File 'lib/rley/parser/parse_entry.rb', line 58

def start_entry?()
  return vertex.kind_of?(GFG::StartVertex)
end

#to_s ⇒ String

Give a String representation of itself. The format of the text representation is "format of dotted rule" + " | " + origin



141
142
143
 
# File 'lib/rley/parser/parse_entry.rb', line 141

def to_s()
  return vertex.label + " | #{origin}"
end