# State of the parser automata as stored in the parser stack.
private class State
# The internal state number
- var _state: Int
+ var state: Int
# The node stored with the state in the stack
- var _nodes: nullable Object
+ var nodes: nullable Object
init(state: Int, nodes: nullable Object)
do
end
end
+# The parser of the Nit language.
class Parser
super TablesCapable
# Associated lexer
- var _lexer: Lexer
+ var lexer: Lexer
# Stack of pushed states and productions
- var _stack: Array[State]
+ private var stack: Array[State]
# Position in the stack
- var _stack_pos: Int
+ private var stack_pos: Int
# Create a new parser based on a given lexer
init(lexer: Lexer)
end
end
- var _reduce_table: Array[ReduceAction]
+ private var reduce_table: Array[ReduceAction]
private fun build_reduce_table is abstract
end
redef class Prod
# Location on the first token after the start of a production
- # So outside the production for epilon production
- var _first_location: nullable Location
+ # So outside the production for epsilon production
+ var first_location: nullable Location
end
# Find location of production nodes
# Uses existing token locations to infer location of productions.
private class ComputeProdLocationVisitor
super Visitor
- # Currenlty visited productions that need a first token
- var _need_first_prods: Array[Prod] = new Array[Prod]
+ # Currently visited productions that need a first token
+ var need_first_prods = new Array[Prod]
# Already visited epsilon productions that waits something after them
- var _need_after_epsilons: Array[Prod] = new Array[Prod]
+ var need_after_epsilons = new Array[Prod]
# Location of the last visited token in the current production
- var _last_location: nullable Location = null
+ var last_location: nullable Location = null
redef fun visit(n: ANode)
do
init do end
end
-# Each reduca action has its own class, this one is the root of the hierarchy.
+# Each reduce action has its own class, this one is the root of the hierarchy.
private abstract class ReduceAction
fun action(p: Parser) is abstract
fun concat(l1, l2 : Array[Object]): Array[Object]
l1.append(l2)
return l1
end
- var _goto: Int
+ var goto: Int
init(g: Int) do _goto = g
end