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

Returns a new instance of ParseEntry.

Parameters:



26
27
28
29
30
 
# File 'lib/rley/parser/parse_entry.rb', line 26

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

Instance Attribute Details

#antecedents ⇒ Array<ParseEntry> (readonly)

Returns Links to preceding parse entries.

Returns:

  • (Array<ParseEntry>) —

    Links to preceding parse entries



17
18
19
 
# File 'lib/rley/parser/parse_entry.rb', line 17

def antecedents
  @antecedents
end

#origin ⇒ Integer (readonly)

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

Returns:

  • (Integer) 


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

def origin
  @origin
end

#vertex ⇒ GFG::Vertex (readonly)

Returns Link to a vertex of the GFG.

Returns:



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

def vertex
  @vertex
end

Instance Method Details

#==(other) ⇒ Object

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



53
54
55
56
57
58
 
# File 'lib/rley/parser/parse_entry.rb', line 53

def ==(other)
  return true if equal? other

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

#add_antecedent(anAntecedent) ⇒ Object

Add a link to an antecedent parse entry

Parameters:



48
49
50
 
# File 'lib/rley/parser/parse_entry.rb', line 48

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

Returns:

  • (Boolean) 


79
80
81
 
# File 'lib/rley/parser/parse_entry.rb', line 79

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.)

Returns:

  • (Boolean) 


89
90
91
 
# File 'lib/rley/parser/parse_entry.rb', line 89

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

Returns:

  • (Boolean) 


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

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.)

Returns:

  • (Boolean) 


84
85
86
 
# File 'lib/rley/parser/parse_entry.rb', line 84

def exit_entry?()
  return vertex.complete?
end

#hash ⇒ Object 



60
61
62
 
# File 'lib/rley/parser/parse_entry.rb', line 60

def hash
  @hash ||= "#{vertex.object_id}-#{origin}".hash
end

#inspect ⇒ String

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

Returns:

  • (String) 


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

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)



99
100
101
 
# File 'lib/rley/parser/parse_entry.rb', line 99

def next_symbol()
  return vertex.next_symbol
end

#orphan? ⇒ Boolean

Return true if the entry has no antecedent entry

Returns:

  • (Boolean) 


104
105
106
 
# File 'lib/rley/parser/parse_entry.rb', line 104

def orphan?()
  return antecedents.empty?
end

#prev_symbol ⇒ Object

Return the symbol before the dot (if any)



94
95
96
 
# File 'lib/rley/parser/parse_entry.rb', line 94

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)

Returns:

  • (Boolean) 


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

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

Returns:

  • (String) 


148
149
150
 
# File 'lib/rley/parser/parse_entry.rb', line 148

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