Package ghidra.app.plugin.assembler.sleigh.grammars

Class AbstractAssemblyGrammar<NT extends AssemblyNonTerminal,P extends AbstractAssemblyProduction<NT>>

java.lang.Object

ghidra.app.plugin.assembler.sleigh.grammars.AbstractAssemblyGrammar<NT,P>

Type Parameters:

NT - the type of non-terminals

T - the type of terminals

P - the type of productions, which must have the same types of (non-)terminals.

All Implemented Interfaces:

java.lang.Iterable<P>

Direct Known Subclasses:

AssemblyExtendedGrammar, AssemblyGrammar

public abstract class AbstractAssemblyGrammar<NT extends AssemblyNonTerminal,P extends AbstractAssemblyProduction<NT>>
extends java.lang.Object
implements java.lang.Iterable<P>

Defines a context-free grammar, usually for the purpose of parsing mnemonic assembly instructions As in classic computer science, a CFG consists of productions of non-terminals and terminals. The left-hand side of the a production must be a single non-terminal, but the right-hand side may be any string of symbols. To avoid overloading the term "String," here we call it a "Sentential." To define a grammar, simply construct an appropriate subclass (probably AssemblyGrammar) and call addProduction(AbstractAssemblyProduction) or {@link #addProduction(AssemblyNonTerminal, AssemblySentential). The grammar object will collect the non-terminals and terminals. By default, the start symbol is taken from the left-hand side of the first production added to the grammar.

Field Summary

Fields

Change	Modifier and Type	Field	Description
NEW	protected java.util.Map<java.lang.String,NT>	nonterminals
NEW	protected java.util.List<P>	prodList
NEW	protected org.apache.commons.collections4.MultiValuedMap<java.lang.String,P>	productions
NEW	protected java.lang.String	startName
NEW	protected java.util.Map<java.lang.String,AssemblySymbol>	symbols
NEW	protected java.util.Map<java.lang.String,AssemblyTerminal>	terminals

Constructor Summary

Constructors

Change	Constructor	Description
AbstractAssemblyGrammar()

Method Summary

Change	Modifier and Type	Method	Description
	void	addProduction(NT lhs, AssemblySentential<NT> rhs)	Add a production to the grammar
	void	addProduction(P prod)	Add a production to the grammar
	void	combine(AbstractAssemblyGrammar<NT,P> that)	Add all the productions of a given grammar to this one
	boolean	contains(java.lang.String name)	Check if the grammar contains any symbol with the given name
	NT	getNonTerminal(java.lang.String name)	Get the named non-terminal
	NT	getStart()	Get the start symbol for the grammar
	java.lang.String	getStartName()	Get the name of the start symbol for the grammar
	AssemblyTerminal	getTerminal(java.lang.String name)	Get the named terminal
NEW	protected boolean	isPureRecursive(P prod)	Check if the given production is purely recursive, i.e., of the form I => I
	java.util.Iterator<P>	iterator()	Traverse the productions
	protected abstract P	newProduction(NT lhs, AssemblySentential<NT> rhs)	Because a subclass may have a different type of production, it must provide a mechanism for constructing an appropriate production given just the LHS and RHS.
	java.util.Collection<NT>	nonTerminals()	Get the non-terminals
	void	print(java.io.PrintStream out)	Print the productions of this grammar to the given stream
	java.util.Collection<P>	productionsOf(AssemblyNonTerminal nt)	Get all productions where the left-hand side is the given non-terminal
	java.util.Collection<P>	productionsOf(java.lang.String name)	Get all productions where the left-hand side non-terminal has the given name
	void	setStart(AssemblyNonTerminal nt)	Change the start symbol for the grammar
	void	setStartName(java.lang.String startName)	Change the start symbol for the grammar
	java.util.Collection<AssemblyTerminal>	terminals()	Get the terminals
	void	verify()	Check that the grammar is consistent The grammar is consistent if every non-terminal appearing in the grammar, also appears as the left-hand side of some production.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Field Detail

productions NEW

protected final org.apache.commons.collections4.MultiValuedMap<java.lang.String,P extends AbstractAssemblyProduction<NT>> productions

prodList NEW

protected final java.util.List<P extends AbstractAssemblyProduction<NT>> prodList

nonterminals NEW

protected final java.util.Map<java.lang.String,NT extends AssemblyNonTerminal> nonterminals

terminals NEW

protected final java.util.Map<java.lang.String,AssemblyTerminal> terminals

symbols NEW

protected final java.util.Map<java.lang.String,AssemblySymbol> symbols

startName NEW

protected java.lang.String startName

Constructor Detail

AbstractAssemblyGrammar

public AbstractAssemblyGrammar()

Method Detail

newProduction

protected abstract P newProduction(NT lhs,
                                   AssemblySentential<NT> rhs)

Because a subclass may have a different type of production, it must provide a mechanism for constructing an appropriate production given just the LHS and RHS.

Parameters:

lhs - the left-hand side of the production

rhs - the right-hand side of the production

Returns:

the constructed production

addProduction

public void addProduction(NT lhs,
                          AssemblySentential<NT> rhs)

Add a production to the grammar

Parameters:

lhs - the left-hand side

rhs - the right-hand side

addProduction

public void addProduction(P prod)

Add a production to the grammar

Parameters:

prod - the production

isPureRecursive NEW

protected boolean isPureRecursive(P prod)

Check if the given production is purely recursive, i.e., of the form I => I

Parameters:

prod - the production to check

Returns:

true iff the production is purely recursive

setStart

public void setStart(AssemblyNonTerminal nt)

Change the start symbol for the grammar

Parameters:

nt - the new start symbol

setStartName

public void setStartName(java.lang.String startName)

Change the start symbol for the grammar

Parameters:

startName - the name of the new start symbol

getStart

public NT getStart()

Get the start symbol for the grammar

Returns:

the start symbol

getStartName

public java.lang.String getStartName()

Get the name of the start symbol for the grammar

Returns:

the name of the start symbol

getNonTerminal

public NT getNonTerminal(java.lang.String name)

Get the named non-terminal

Parameters:

name - the name of the desired non-terminal

Returns:

the non-terminal, or null if it is not in this grammar

getTerminal

public AssemblyTerminal getTerminal(java.lang.String name)

Get the named terminal

Parameters:

name - the name of the desired terminal

Returns:

the terminal, or null if it is not in this grammar

combine

public void combine(AbstractAssemblyGrammar<NT,P> that)

Add all the productions of a given grammar to this one

Parameters:

that - the grammar whose productions to add

print

public void print(java.io.PrintStream out)

Print the productions of this grammar to the given stream

Parameters:

out - the stream

verify

public void verify()
            throws AssemblyGrammarException

Check that the grammar is consistent The grammar is consistent if every non-terminal appearing in the grammar, also appears as the left-hand side of some production. If not, such non-terminals are said to be undefined.

Throws:

AssemblyGrammarException - the grammar is inconsistent, i.e., contains undefined non-terminals.

iterator

public java.util.Iterator<P> iterator()

Traverse the productions

Specified by:

iterator in interface java.lang.Iterable<NT extends AssemblyNonTerminal>

nonTerminals

public java.util.Collection<NT> nonTerminals()

Get the non-terminals

Returns:

terminals

public java.util.Collection<AssemblyTerminal> terminals()

Get the terminals

Returns:

productionsOf

public java.util.Collection<P> productionsOf(java.lang.String name)

Get all productions where the left-hand side non-terminal has the given name

Parameters:

name - the name of the non-terminal

Returns:

all productions "defining" the named non-terminal

productionsOf

public java.util.Collection<P> productionsOf(AssemblyNonTerminal nt)

Get all productions where the left-hand side is the given non-terminal

Parameters:

nt - the non-terminal whose defining productions to find

Returns:

all productions "defining" the given non-terminal

contains

public boolean contains(java.lang.String name)

Check if the grammar contains any symbol with the given name

Parameters:

name - the name to find

Returns:

true iff a terminal or non-terminal has the given name