lalr_parsing.grammar.Grammar Class Reference

Public Member Functions
	__init__ (self, nonterms, start_nonterminal=None)
	first_set (self, x)
	stringify (self, indexes=True)
	__str__ (self)

Public Attributes
	nonterms
	terminals
	symbols
	productions
	nonterm_offset

Constructor & Destructor Documentation

__init__()

lalr_parsing.grammar.Grammar.__init__	(		self,
			nonterms,
			start_nonterminal = None )

    def __init__(self, nonterms, start_nonterminal=None):
        # Grammar start symbol
        if start_nonterminal is None or start_nonterminal not in nonterms:
            start_nonterminal = nonterms[0]
 
        # Tuple of non-terminals
        self.nonterms = tuple([NonTerminal(START_SYMBOL, [[start_nonterminal.name]])] +
                              nonterms)
        # Tuple of terminals
        self.terminals = ()
        # Tuple of symbols (non-terminals + terminals)
        self.symbols = ()
        # Tuple of enumerated NT's productions
        self.productions = ()
        # Enumeration offset for a given NT
        self.nonterm_offset = {}
        # First sets for every grammar symbol
        self.__first_sets = {}
 
        # Update the references of each production and, while at it, recognize terminal symbols
        nonterminal_by_name = {nt.name: nt for nt in self.nonterms}
        for nt in self.nonterms:
            for prod in nt.productions:
                for idx in range(len(prod)):
                    symbol = prod[idx]
 
                    if isinstance(symbol, str):
                        if symbol in nonterminal_by_name:
                            prod[idx] = nonterminal_by_name[symbol]
                        else:
                            self.terminals += tuple([symbol])
                    elif isinstance(symbol, NonTerminal):
                        if symbol not in self.nonterms:
                            msg = 'Non-terminal %s is not in the grammar' % repr(symbol)
                            raise KeyError(msg)
                    else:
                        msg = "Unsupported type '%s' inside of production" % type(symbol).__name__
                        raise TypeError(msg)
 
        self.terminals = tuple(set(self.terminals))
        self.symbols = self.nonterms + self.terminals
 
        # Enumerate grammar productions
        for nt in self.nonterms:
            self.nonterm_offset[nt] = len(self.productions)
            self.productions += tuple((nt.name, prod) for prod in nt.productions)
 
        self.__build_first_sets()
 

Member Function Documentation

__str__()

lalr_parsing.grammar.Grammar.__str__

(

self

)

    def __str__(self):
        return self.stringify()
 
 

first_set()

lalr_parsing.grammar.Grammar.first_set	(		self,
			x )

    def first_set(self, x):
        result = set()
 
        if isinstance(x, str):
            result.add(x)
        elif isinstance(x, NonTerminal):
            result = self.__first_sets[x]
        else:
            skippable_symbols = 0
            for sym in x:
                fs = self.first_set(sym)
                result.update(fs - {None})
                if None in fs:
                    skippable_symbols += 1
                else:
                    break
 
            if skippable_symbols == len(x):
                result.add(None)
 
        return frozenset(result)
 

stringify()

lalr_parsing.grammar.Grammar.stringify	(		self,
			indexes = True )

    def stringify(self, indexes=True):
        lines = '\n'.join(nt.stringify() for nt in self.nonterms)
        if indexes:
            lines = '\n'.join(RULE_INDEXING_PATTERN % (x, y)
                              for x, y in enumerate(lines.split('\n')))
        return lines
 

Member Data Documentation

nonterm_offset

lalr_parsing.grammar.Grammar.nonterm_offset

nonterms

lalr_parsing.grammar.Grammar.nonterms

productions

lalr_parsing.grammar.Grammar.productions

symbols

lalr_parsing.grammar.Grammar.symbols

terminals

lalr_parsing.grammar.Grammar.terminals

---

The documentation for this class was generated from the following file:

• hyperdbg/script-engine/python/lalr_parsing/grammar.py