Class: RLTK::Parser::State

Inherits:
Object show all
Defined in:
lib/rltk/parser.rb

Overview

The State class is used to represent sets of items and actions to be used during parsing.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(tokens, items = []) ⇒ State

Instantiate a new State object.

Parameters:

  • tokens (Array<Token>) —

    Tokens that represent this state.

  • items (Array<CFG::Item>) (defaults to: []) —

    Items that make up this state.



1399
1400
1401
1402
1403
 
# File 'lib/rltk/parser.rb', line 1399

def initialize(tokens, items = [])
	@id		= nil
	@items	= items
	@actions	= tokens.inject(Hash.new) { |h, t| h[t] = Array.new; h }
end

Instance Attribute Details

#actions ⇒ Array<Action> (readonly)

Returns Action objects that represent the actions that should be taken when various inputs are observed.

Returns:

  • (Array<Action>) —

    Action objects that represent the actions that should be taken when various inputs are observed.



1393
1394
1395
 
# File 'lib/rltk/parser.rb', line 1393

def actions
  @actions
end

#id ⇒ Integer

Returns State’s ID.

Returns:



1387
1388
1389
 
# File 'lib/rltk/parser.rb', line 1387

def id
  @id
end

#items ⇒ Array<CFG::Item> (readonly)

Returns Item objects that comprise this state.

Returns:

  • (Array<CFG::Item>) —

    Item objects that comprise this state.



1390
1391
1392
 
# File 'lib/rltk/parser.rb', line 1390

def items
  @items
end

Instance Method Details

#==(other) ⇒ Boolean

Compare one State to another. Two States are equal if they have the same items or, if the items have been cleaned, if the States have the same ID.

Parameters:

  • other (State) —

    Another State to compare to.

Returns:

  • (Boolean) 


1412
1413
1414
 
# File 'lib/rltk/parser.rb', line 1412

def ==(other)
	if self.items and other.items then self.items == other.items else self.id == other.id end
end

#add_reduction(production_id) ⇒ void

This method returns an undefined value.

Add a Reduce action to the state.

Parameters:

  • production_id (Integer) —

    ID of production to add to this state.



1421
1422
1423
1424
1425
1426
 
# File 'lib/rltk/parser.rb', line 1421

def add_reduction(production_id)
	action = Reduce.new(production_id)
	
	# Reduce actions are not allowed for the ERROR terminal.
	@actions.each { |k, v| if CFG::is_terminal?(k) and k != :ERROR then v << action end }
end

#append(item) ⇒ Object Also known as: <<

Parameters:

  • item (CFG::Item) —

    Item to add to this state.



1429
1430
1431
 
# File 'lib/rltk/parser.rb', line 1429

def append(item)
	if item.is_a?(CFG::Item) and not @items.include?(item) then @items << item end
end

#clean ⇒ void

This method returns an undefined value.

Clean this State by removing the list of CFG::Item objects.



1437
1438
1439
 
# File 'lib/rltk/parser.rb', line 1437

def clean
	@items = nil
end

#close(productions) ⇒ vod

Close this state using productions.

Parameters:

  • productions (Array<CFG::Production>) —

    Productions used to close this state.

Returns:

  • (vod) 


1446
1447
1448
1449
1450
1451
1452
 
# File 'lib/rltk/parser.rb', line 1446

def close(productions)
	self.each do |item|
		if (next_symbol = item.next_symbol) and CFG::is_nonterminal?(next_symbol)
			productions[next_symbol].each { |p| self << p.to_item }
		end
	end
end

#conflict_on?(sym) ⇒ :SR, ...

Checks to see if there is a conflict in this state, given a input of sym. Returns :SR if a shift/reduce conflict is detected and :RR if a reduce/reduce conflict is detected. If no conflict is detected nil is returned.

Parameters:

  • sym (Symbol) —

    Symbol to check for conflicts on.

Returns:

  • (:SR, :RR, nil) 


1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
 
# File 'lib/rltk/parser.rb', line 1462

def conflict_on?(sym)
	
	reductions	= 0
	shifts		= 0
	
	@actions[sym].each do |action|
		if action.is_a?(Reduce)
			reductions += 1
			
		elsif action.is_a?(Shift)
			shifts += 1
			
		end
	end
	
	if shifts == 1 and reductions > 0
		:SR
	elsif reductions > 1
		:RR
	else
		nil
	end
end

#each ⇒ void

This method returns an undefined value.

Iterate over the state’s items.



1489
1490
1491
 
# File 'lib/rltk/parser.rb', line 1489

def each
	@items.each {|item| yield item}
end

#on(symbol, action) ⇒ void

This method returns an undefined value.

Specify an Action to perform when the input token is symbol.

Parameters:

  • symbol (Symbol) —

    Symbol to add action for.

  • action (Action) —

    Action for symbol.



1499
1500
1501
1502
1503
1504
1505
 
# File 'lib/rltk/parser.rb', line 1499

def on(symbol, action)
	if @actions.key?(symbol)
		@actions[symbol] << action
	else
		raise ParserConstructionException, "Attempting to set action for token (#{symbol}) not seen in grammar definition."
	end
end

#on?(symbol) ⇒ Array<Action>

Returns that actions that should be taken when the input token is symbol.

Parameters:

  • symbol (Symbol) —

    Symbol we want the actions for.

Returns:

  • (Array<Action>) —

    Actions that should be taken.



1513
1514
1515
 
# File 'lib/rltk/parser.rb', line 1513

def on?(symbol)
	@actions[symbol].clone
end