From d5e5f73387a5a60a7eb7ae520acfae2529a88788 Mon Sep 17 00:00:00 2001
From: pompolic <pompolic@special-circumstanc.es>
Date: Wed, 9 Nov 2022 22:04:49 +0100
Subject: [PATCH] Further dead code removal
---
gdb-port/ast.py | 77 +---------------------------------
gdb-port/hammer-breakpoints.py | 2 -
gdb-port/parser.py | 8 ----
gdb-port/top-level-parse.py | 19 ---------
4 files changed, 1 insertion(+), 105 deletions(-)
diff --git a/gdb-port/ast.py b/gdb-port/ast.py
index 3232e25..b594c93 100644
--- a/gdb-port/ast.py
+++ b/gdb-port/ast.py
@@ -260,7 +260,7 @@ class ASTManager:
self.parser = parser
# Alternatively, instead of constructing one giant map, TopLevelParse could walk the AST
- def token_map(self, parse_state_indices):
+ def token_map(self, parse_state_indices): # TODO: remove
res = {}
#print("token map:")
if self.top_node.has_ast:
@@ -287,78 +287,3 @@ class ASTManager:
ast_manager = ASTManager()
-# In the case of Packrat, the AST is built bottom-up. By saving the "root" of the AST fragment of interest, we can walk the entire subtree and
-# print every token. However, during parsing, where a token begins is known from state->input_stream.index at the time of call, and the end of a token is
-# known from the same upon return. So to keep track of token boundaries, we need to keep track of token starting points as we descend to the first parser
-# that actually advances state->input_stream.index
-class IndexTreeNode:
- def __init__(self, parent):
- self.indices = None
- self.children = []
- if isinstance(parent, IndexTreeNode) or parent is None:
- self.parent = parent
- else:
- print(parent)
- raise ValueError("Parent must also be an IndexTreeNode")
-
- def __getitem__(self, key):
- return self.children[key]
-
- def begin_token(self, index):
- if self.indices is not None:
- raise ValueError("Attempt to overwrite token starting point:", self.indices, index)
- else:
- self.indices = (index, None)
-
- def finish_token(self, index):
- if self.indices[1] is not None:
- raise ValueError("Attempt to overwrite token ending point", self.indices, index)
- else:
- oldindices = self.indices
- self.indices = (oldindices[0], index)
-
- def select_by_path(self, node_list):
- return reduce(operator.getitem, node_list, self)
-
- def add_child_node(self, indices=None):
- new_node = IndexTreeNode(self)
- if indices:
- new_node.begin_token(indices[0]) # TODO: should we be able to assign indices generally, or should going through .begin_token() be enforced like this?
- self.children.append(new_node)
-
- def delete_last_child(self):
- node = self.children.pop()
- node.parent = None
-
- def delete_all_children(self):
- for child in self.children:
- child.parent = None
- self.children = []
-
- def __str__(self):
- if len(self.children):
- return "(" + str(self.indices) + "; [" + ",".join([str(child) for child in self.children]) + "])"
- else:
- return "(" + str(self.indices) + "; [])"
-
-class IndexTree:
- def __init__(self):
- self.root = IndexTreeNode(None)
-
- # support chaining the subscript operator, e. g. sometree[0][1][3]. returning the root here regardless of key makes it more convenient to use
- # path selectors derived from TopLevelParse's call stack. (the first item corresponds to the topmost parser, and will always be 0) : sometree.select_by_path([0,1,3]) corresponding to sometree.root[1][3]
- def __getitem__(self, key):
- return self.root
-
- def select_by_path(self, node_list):
- return reduce(operator.getitem, node_list, self)
-
- def __str__(self):
- return str(self.root)
-
- #TODO: something better for when parser stack is empty
- def add_child_node(self, indices=None):
- new_node = IndexTreeNode(None)
- if indices:
- new_node.begin_token(indices[0])
- self.root = new_node
diff --git a/gdb-port/hammer-breakpoints.py b/gdb-port/hammer-breakpoints.py
index a09f397..982def2 100644
--- a/gdb-port/hammer-breakpoints.py
+++ b/gdb-port/hammer-breakpoints.py
@@ -113,8 +113,6 @@ class HDoParseRetBreakpoint(gdb.Breakpoint):
ast_manager.set_top_node(ret_val, parser_obj)
ast_manager.print_ast()
#print(top_level_parse.peek_parserstack().p_stack) #TODO:sometimes the hammer-parser-backtrace gets messed up
- indices = top_level_parse.get_top_stack_indices()
- token_map = ast_manager.token_map(indices)
top_level_parse.input_ptr = parse_state['input_stream']['input']
top_level_parse.print_input_map(ast_manager.top_node.ast)
#print(top_level_parse.peek_parserstack().p_stack)
diff --git a/gdb-port/parser.py b/gdb-port/parser.py
index eb786b7..f459bf3 100644
--- a/gdb-port/parser.py
+++ b/gdb-port/parser.py
@@ -49,7 +49,6 @@ class ParserStack:
self.parse_state = parse_state
self.arena = arena
self.p_stack = []
- self.parse_state_stack = [] # Would it be better to store (Parser, parse_state) tuples?
self.unclaimed_mem_use = 0
def push(self, parser):
@@ -65,10 +64,6 @@ class ParserStack:
retval = None
return retval
- # TODO: if this approach works out, unify it with the push() API
- def push_parse_state(self, parse_state):
- self.parse_state_stack.append(parse_state)
-
def peek_parse_state(self):
try:
retval = self.parse_state_stack[-1]
@@ -76,9 +71,6 @@ class ParserStack:
retval = None
return retval
- def pop_parse_state(self):
- return self.parse_state_stack.pop()
-
def set_state(self, state):
self.parse_state = state
# Shortcut for setting the name property of the parser on the top of stack
diff --git a/gdb-port/top-level-parse.py b/gdb-port/top-level-parse.py
index 1134504..eaeff82 100644
--- a/gdb-port/top-level-parse.py
+++ b/gdb-port/top-level-parse.py
@@ -4,9 +4,6 @@ class TopLevelParse:
def __init__(self):
self.parser_stacks = []
self.parser_objs = {}
- self.input_stream_indices = IndexTree()
- self.input_index_tree_path = [0]
- self.input_index_tree_path_stack = [] # TODO: put index_tree_path code in IndexTree()
self.index_tree_stack = []
self.current_parse_depth = 0 # Used by the AST handling code.
self.starting_input_index = []
@@ -46,11 +43,6 @@ class TopLevelParse:
parser_stack = ParserStack(None, None)
self.parser_stacks.append(parser_stack)
self.current_parse_depth = -1 # entering h_do_parse increments this by 1. To have it 0-indexed, it needs to be initialized to -1
- if self.input_stream_indices:
- self.index_tree_stack.append(self.input_stream_indices)
- self.input_stream_indices = IndexTree()
- self.input_index_tree_path_stack.append(self.input_index_tree_path)
- self.input_index_tree_path = [0]
return 0
# TODO: arena parameter is useless
@@ -99,9 +91,6 @@ class TopLevelParse:
if old_stack.depth() > 0:
print("Warning: parser stack not empty but parse is successful?")
- self.input_stream_indices = self.index_tree_stack.pop()
- self.input_index_tree_path = self.input_index_tree_path_stack.pop()
-
if not self.parser_stacks: # if self.parser_stacks is now empty, we've returned from h_packrat_parse() called by the "outermost" h_parse()
self.current_parse_depth = -1 # Restore parse depth
else:
@@ -120,9 +109,6 @@ class TopLevelParse:
parser_stack = self.peek_parserstack()
parser_stack.push(parser_obj)
- #TODO
- parse_state = []
- parser_stack.push_parse_state(parse_state)
if self.parser_decombinator:
p_env = self.parser_decombinator.decompose_parser(parser_obj, self)
self.set_parser_env(type(p_env).__name__ + " - " + str(p_env)) # TODO: pass this as data structure to frontend
@@ -131,7 +117,6 @@ class TopLevelParse:
def return_from_perform_lowlevel_parse(self):
parser_stack = self.peek_parserstack()
parser_obj = parser_stack.pop()
- parse_state = parser_stack.pop_parse_state()
# debug print here
def enter_h_arena_malloc_raw(self, alloc_size):
@@ -468,8 +453,4 @@ class TopLevelParse:
def get_current_stack_depth(self):
return self.current_parse_depth # TODO: what's the difference between this and ast_stack_index?
- # TODO: better name pending
- def get_top_stack_indices(self):
- return self.input_stream_indices[self.current_parse_depth:]
-
top_level_parse = TopLevelParse()
--
GitLab