lalr_parsing.lalr_one.ParsingTable Class Reference

Public Member Functions
	__init__ (self, gr)
	stringify_state (self, state_id)
	stringify (self)
	get_single_state_conflict_status (self, state_id)
	get_conflict_status (self)
	is_lalr_one (self)
	save_to_csv (self, filepath)

Public Attributes
	grammar
	terminals
	nonterms
	n_states
	goto
	action

Constructor & Destructor Documentation

__init__()

lalr_parsing.lalr_one.ParsingTable.__init__	(		self,
			gr )

    def __init__(self, gr):
        self.grammar = gr
 
        self.terminals = ()  # terminals of 'gr', union grammar.EOF_SYMBOL
        self.nonterms = ()   # non-terminals of 'gr', except grammar.START_SYMBOL
 
        self.__ccol = ()
        self.n_states = 0  # Taken from the cardinality of the LALR(1) canonical collection
 
        # goto will be a list of dictionaries in order to easy its usage:
        #   goto[state_id][nonterminal]
        # Each dictionary will map a non-terminal to an int: the index of the next state.
        # If for a given non-terminal there's no transition, it will map to None instead.
        #
        # action will be a list of dictionaries in order to easy its usage:
        #   action[state_id][terminal]
        # Each dictionary will map a terminal to a set of "table entries".
        # The type of a table entry varies according to the kind of entry:
        #   a "shift #state_id" entry     is a 2-tuple ('shift and go to state', state_id)
        #   a "reduce #prod_index" entry  is a 2-tuple ('reduce using rule', prod_index)
        #   an "accept" entry             is just a 2-tuple ('accept', '')
        # As a special case: an "error" entry is detoned just by the empty set of table
        # entries.
        #
        # See Dragonbook, page 265, "Canonical LR(1) parsing tables" for reference.
 
        self.goto = ()
        self.action = ()
 
        self.__setup_from_grammar(self.grammar)
 

Member Function Documentation

get_conflict_status()

lalr_parsing.lalr_one.ParsingTable.get_conflict_status

(

self

)

    def get_conflict_status(self):
        return [self.get_single_state_conflict_status(i) for i in range(self.n_states)]
 

get_single_state_conflict_status()

lalr_parsing.lalr_one.ParsingTable.get_single_state_conflict_status	(		self,
			state_id )

    def get_single_state_conflict_status(self, state_id):
        seq = [self.__get_entry_status(e) for t, e in self.action[state_id].items()]
        return STATUS_OK if len(seq) == 0 else max(seq)
 

is_lalr_one()

lalr_parsing.lalr_one.ParsingTable.is_lalr_one

(

self

)

    def is_lalr_one(self):
        seq = self.get_conflict_status()
        return (STATUS_OK if len(seq) == 0 else max(seq)) == STATUS_OK
 

save_to_csv()

lalr_parsing.lalr_one.ParsingTable.save_to_csv	(		self,
			filepath )

    def save_to_csv(self, filepath):
        with open(filepath, 'w', newline='') as csvfile:
            writer = csv.writer(csvfile, dialect='excel')
 
            headers = tuple(' ') + self.terminals + self.nonterms
            writer.writerow(headers)
 
            def stringify_action_entries(entries):
                return ', '.join(e[0].split()[0][0] + str(e[1]) for e in entries)
 
            for state_id in range(self.n_states):
                row = [''] * len(headers)
                row[0] = state_id
 
                for col in range(1, 1 + len(self.terminals)):
                    if not headers[col] in self.action[state_id]:
                        continue
                    row[col] = stringify_action_entries(self.action[state_id][headers[col]])
 
                for col in range(1 + len(self.terminals), len(headers)):
                    if not headers[col] in self.goto[state_id]:
                        continue
                    row[col] = self.goto[state_id][headers[col]]
                
                writer.writerow(row)
 
 

stringify()

lalr_parsing.lalr_one.ParsingTable.stringify

(

self

)

    def stringify(self):
        states_str = '\n'.join(self.stringify_state(i) for i in range(self.n_states))
        return states_str
 

stringify_state()

lalr_parsing.lalr_one.ParsingTable.stringify_state	(		self,
			state_id )

    def stringify_state(self, state_id):
        state_title = 'State %d\n' % state_id
 
        items = drop_itemset_lookaheads(kernels(self.__ccol[state_id]))
        items = sorted(items, key=lambda elem: elem[0])
 
        items_str = '\n'.join('\t' + self.__stringify_lr_zero_item(item) for item in items) + '\n\n'
 
        actions = [(t, e) for t, e in self.action[state_id].items() if len(e) > 0]
        actions = sorted(actions, key=lambda elem: elem[0])
 
        actions_str = '\n'.join(self.__stringify_action_entries(t, e) for t, e in actions)
        actions_str += ('\n' if len(actions_str) > 0 else '')
 
        gotos = [(nt, sid) for nt, sid in self.goto[state_id].items() if sid is not None]
        gotos = sorted(gotos, key=lambda elem: elem[0].name)
 
        gotos_str = '\n'.join(self.__stringify_goto_entry(nt, sid) for nt, sid in gotos)
        gotos_str += ('\n' if len(gotos_str) > 0 else '')
 
        action_goto_separator = ('\n' if len(actions_str) > 0 and len(gotos_str) > 0 else '')
 
        return state_title + items_str + actions_str + action_goto_separator + gotos_str
 

Member Data Documentation

action

lalr_parsing.lalr_one.ParsingTable.action

goto

lalr_parsing.lalr_one.ParsingTable.goto

grammar

lalr_parsing.lalr_one.ParsingTable.grammar

n_states

lalr_parsing.lalr_one.ParsingTable.n_states

nonterms

lalr_parsing.lalr_one.ParsingTable.nonterms

terminals

lalr_parsing.lalr_one.ParsingTable.terminals

---

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

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