v1.1.1 alpha patch

Author: codereptile

README.md

@@ -1,4 +1,4 @@
-# visualizer (v1.1.1)
+# visualizer (v1.1.1a)
 
 This project aims to make a quick visual representation for a C++ project (though Python support is planned).
 

visualizer/tree_objects.py

@@ -22,32 +22,35 @@ def __init__(self):
         self.namespaces = {}
 
 
-def parse_cursor(children_nodes, cursor: clang.cindex.Cursor, parent_node):
+def parse_cursor(children_nodes, cursor: clang.cindex.Cursor, parent_node, bruteforce: bool, verbose: bool):
     if cursor.kind.name == 'COMPOUND_STMT':
         for i in cursor.get_children():
-            parse_cursor(children_nodes, i, parent_node)
+            parse_cursor(children_nodes, i, parent_node, bruteforce, verbose)
     elif cursor.kind.name == 'FOR_STMT':
-        children_nodes.append(ForLoop(parent_node, cursor))
+        children_nodes.append(ForLoop(parent_node, cursor, bruteforce, verbose))
     elif cursor.kind.name == 'CXX_FOR_RANGE_STMT':
-        children_nodes.append(ForRangeLoop(parent_node, cursor))
+        children_nodes.append(ForRangeLoop(parent_node, cursor, bruteforce, verbose))
     elif cursor.kind.name == 'WHILE_STMT':
-        children_nodes.append(WhileLoop(parent_node, cursor))
+        children_nodes.append(WhileLoop(parent_node, cursor, bruteforce, verbose))
     elif cursor.kind.name == 'IF_STMT':
-        children_nodes.append(If(parent_node, cursor))
+        children_nodes.append(If(parent_node, cursor, bruteforce, verbose))
     elif cursor.kind.name in ['BINARY_OPERATOR',
                               'CALL_EXPR',
                               'RETURN_STMT',
                               'DECL_STMT',
                               'UNARY_OPERATOR',
                               'UNEXPOSED_EXPR',
                               'CXX_DELETE_EXPR',
+                              'BREAK_STMT',
+                              'CXX_TRY_STMT',
+                              'COMPOUND_ASSIGNMENT_OPERATOR',
+                              'CXX_UNARY_EXPR',
                               ]:
         if len(children_nodes) == 0 or type(children_nodes[-1]) != CodeBlock:
-            children_nodes.append(CodeBlock(parent_node))
-        children_nodes[-1].add_line(cursor)
+            children_nodes.append(CodeBlock(parent_node, bruteforce, verbose))
+        children_nodes[-1].add_line(cursor, bruteforce, verbose)
     else:
-        # FIXME: pass brute-force
-        output_error(False, "Unknown object: ", cursor.kind.name, " located: ", cursor.location)
+        output_error(bruteforce, "Unknown object: ", cursor.kind.name, " located: ", cursor.location)
 
 
 class Node:
@@ -61,7 +64,7 @@ def __init__(self, parent_node):
 
 class CodeLine(Node):
     # FIXME: move construction away from constructor
-    def __init__(self, parent_node, cursor: clang.cindex.Cursor):
+    def __init__(self, parent_node, cursor: clang.cindex.Cursor, bruteforce: bool, verbose: bool):
         super().__init__(parent_node)
         self.cursor = cursor
 
@@ -71,12 +74,12 @@ def print(self, depth):
 
 class CodeBlock(Node):
     # FIXME: move construction away from constructor
-    def __init__(self, parent_node):
+    def __init__(self, parent_node, bruteforce: bool, verbose: bool):
         super().__init__(parent_node)
         self.body_nodes = []
 
-    def add_line(self, cursor: clang.cindex.Cursor):
-        self.body_nodes.append(CodeLine(self, cursor))
+    def add_line(self, cursor: clang.cindex.Cursor, bruteforce: bool, verbose: bool):
+        self.body_nodes.append(CodeLine(self, cursor, bruteforce, verbose))
 
     def print(self, depth):
         print('\t' * depth, 'Block of code:')
@@ -86,7 +89,7 @@ def print(self, depth):
 
 class Loop(Node):
     # FIXME: move construction away from constructor
-    def __init__(self, parent_node, cursor: clang.cindex.Cursor):
+    def __init__(self, parent_node, cursor: clang.cindex.Cursor, bruteforce: bool, verbose: bool):
         super().__init__(parent_node)
         self.body_nodes = []
 
@@ -97,11 +100,11 @@ def print(self, depth):
 
 class ForLoop(Loop):
     # FIXME: move construction away from constructor
-    def __init__(self, parent_node, cursor: clang.cindex.Cursor):
-        super().__init__(parent_node, cursor)
+    def __init__(self, parent_node, cursor: clang.cindex.Cursor, bruteforce: bool, verbose: bool):
+        super().__init__(parent_node, cursor, bruteforce, verbose)
 
         cursor_children = list(cursor.get_children())
-        parse_cursor(self.body_nodes, cursor_children[-1], self)
+        parse_cursor(self.body_nodes, cursor_children[-1], self, bruteforce, verbose)
         # FIXME: make a proper loop arguments parse
 
     def print(self, depth):
@@ -111,11 +114,11 @@ def print(self, depth):
 
 class ForRangeLoop(Loop):
     # FIXME: move construction away from constructor
-    def __init__(self, parent_node, cursor: clang.cindex.Cursor):
-        super().__init__(parent_node, cursor)
+    def __init__(self, parent_node, cursor: clang.cindex.Cursor, bruteforce: bool, verbose: bool):
+        super().__init__(parent_node, cursor, bruteforce, verbose)
 
         cursor_children = list(cursor.get_children())
-        parse_cursor(self.body_nodes, cursor_children[-1], self)
+        parse_cursor(self.body_nodes, cursor_children[-1], self, bruteforce, verbose)
         # FIXME: make a proper loop arguments parse
 
     def print(self, depth):
@@ -125,11 +128,11 @@ def print(self, depth):
 
 class WhileLoop(Loop):
     # FIXME: move construction away from constructor
-    def __init__(self, parent_node, cursor: clang.cindex.Cursor):
-        super().__init__(parent_node, cursor)
+    def __init__(self, parent_node, cursor: clang.cindex.Cursor, bruteforce: bool, verbose: bool):
+        super().__init__(parent_node, cursor, bruteforce, verbose)
 
         cursor_children = list(cursor.get_children())
-        parse_cursor(self.body_nodes, cursor_children[-1], self)
+        parse_cursor(self.body_nodes, cursor_children[-1], self, bruteforce, verbose)
         # FIXME: make a proper loop arguments parse
 
     def print(self, depth):
@@ -139,7 +142,7 @@ def print(self, depth):
 
 class If(Node):
     # FIXME: move construction away from constructor
-    def __init__(self, parent_node, cursor: clang.cindex.Cursor):
+    def __init__(self, parent_node, cursor: clang.cindex.Cursor, bruteforce: bool, verbose: bool):
         super().__init__(parent_node)
 
         self.body_nodes = []
@@ -150,9 +153,9 @@ def __init__(self, parent_node, cursor: clang.cindex.Cursor):
         # FIXME: parse condition
 
         for i in cursor_children[1].get_children():
-            parse_cursor(self.body_nodes, i, self)
+            parse_cursor(self.body_nodes, i, self, bruteforce, verbose)
         if len(cursor_children) == 3:
-            parse_cursor(self.else_nodes, cursor_children[2], self)
+            parse_cursor(self.else_nodes, cursor_children[2], self, bruteforce, verbose)
 
     def print(self, depth):
         print('\t' * depth, 'If:')
@@ -171,13 +174,13 @@ def __init__(self, parent_node):
         self.body_nodes = []
         self.name = ""
 
-    def parse_cpp(self, cursor: clang.cindex.Cursor):
+    def parse_cpp(self, cursor: clang.cindex.Cursor, bruteforce: bool, verbose: bool):
         self.name = cursor.spelling
 
         cursor_children = list(cursor.get_children())
 
         if len(cursor_children) and cursor_children[-1].kind.name == 'COMPOUND_STMT':
-            parse_cursor(self.body_nodes, cursor_children[-1], self)
+            parse_cursor(self.body_nodes, cursor_children[-1], self, bruteforce, verbose)
         # FIXME: parse function arguments
         # FIXME: parse function return
         # TODO: add print method
@@ -189,7 +192,7 @@ def __init__(self, parent_node):
         self.body_nodes = []
         self.name = ""
 
-    def parse_cpp(self, cursor: clang.cindex.Cursor):
+    def parse_cpp(self, cursor: clang.cindex.Cursor, bruteforce: bool, verbose: bool):
         self.name = cursor.spelling
 
         # FIXME: parse class data (methods are parsed externally)
@@ -202,7 +205,7 @@ def __init__(self, parent_node):
         self.body_nodes = []
         self.name = ""
 
-    def parse_cpp(self, cursor: clang.cindex.Cursor, code_tree: CodeTree):
+    def parse_cpp(self, cursor: clang.cindex.Cursor, code_tree: CodeTree, bruteforce: bool, verbose: bool):
         self.name = cursor.spelling
 
         # cursor_dump_rec(cursor, 0, 2)
@@ -217,7 +220,7 @@ def parse_cpp(self, cursor: clang.cindex.Cursor, code_tree: CodeTree):
             elif i.kind.name == 'CXX_METHOD':
                 code_tree.methods[i.get_usr()] = Function(self)
                 self.body_nodes.append(code_tree.methods[i.get_usr()])
-                code_tree.methods[i.get_usr()].parse_cpp(i)
+                code_tree.methods[i.get_usr()].parse_cpp(i, bruteforce, verbose)
             else:
                 output_error(False, "Unknown structure field: ", i.kind.name)
 

visualizer/utils.py

@@ -33,7 +33,7 @@ def no_print(*args):
 
 def output_error(brute_force: bool, *args):
     if brute_force:
-        red_on_black_print(args)
+        red_on_black_print(*args)
     else:
         s = ''
         for i in args:

visualizer/visualizer.py

@@ -88,22 +88,22 @@ def parse_cpp_file(self, file_path: str) -> None:
 
         diagnostics = list(translation_unit.diagnostics)
         if len(diagnostics):
-            output_error(self.bruteforce, 'FOUND ERRORS:')
+            message = 'FOUND ERRORS:\n'
             for diag in diagnostics:
-                output_error(self.bruteforce, 'Error:')
-                output_error(self.bruteforce, '\tseverity:', diag.severity)
-                output_error(self.bruteforce, '\tlocation:', diag.location)
-                output_error(self.bruteforce, '\tspelling:', diag.spelling)
-                output_error(self.bruteforce, '\tranges:', diag.ranges)
-                output_error(self.bruteforce, '\tfixits:', diag.fixits)
-            # sys.exit(2)
+                message += 'Error:\n'
+                message += '\tseverity:' + str(diag.severity) + '\n'
+                message += '\tlocation:' + str(diag.location) + '\n'
+                message += '\tspelling:' + str(diag.spelling) + '\n'
+                message += '\tranges:' + str(diag.ranges) + '\n'
+                message += '\tfixits:' + str(diag.fixits) + '\n'
+            output_error(self.bruteforce, message)
 
         for cursor in translation_unit.cursor.get_children():
             if not is_file_in_standart(str(cursor.location.file)):
                 if cursor.kind.name == 'FUNCTION_DECL':
                     if self.code_tree.functions.get(cursor.get_usr()) is None:
                         self.code_tree.functions[cursor.get_usr()] = Function(None)
-                    self.code_tree.functions[cursor.get_usr()].parse_cpp(cursor)
+                    self.code_tree.functions[cursor.get_usr()].parse_cpp(cursor, self.bruteforce, self.verbose)
                 elif cursor.kind.name == 'CXX_METHOD':
                     cursor_children = list(cursor.get_children())
                     for i in cursor_children:
@@ -118,15 +118,15 @@ def parse_cpp_file(self, file_path: str) -> None:
                     if self.code_tree.methods.get(cursor.get_usr()) is None:
                         output_error(self.bruteforce, "Error: Could not create a method!!")
                     else:
-                        self.code_tree.methods[cursor.get_usr()].parse_cpp(cursor)
+                        self.code_tree.methods[cursor.get_usr()].parse_cpp(cursor, self.bruteforce, self.verbose)
                 elif cursor.kind.name == 'CLASS_DECL':
                     if self.code_tree.classes.get(cursor.get_usr()) is None:
                         self.code_tree.classes[cursor.get_usr()] = Class(None)
-                    self.code_tree.classes[cursor.get_usr()].parse_cpp(cursor)
+                    self.code_tree.classes[cursor.get_usr()].parse_cpp(cursor, self.bruteforce, self.verbose)
                 elif cursor.kind.name == 'STRUCT_DECL':
                     if self.code_tree.structures.get(cursor.get_usr()) is None:
                         self.code_tree.structures[cursor.get_usr()] = Struct(None)
-                    self.code_tree.structures[cursor.get_usr()].parse_cpp(cursor, self.code_tree)
+                    self.code_tree.structures[cursor.get_usr()].parse_cpp(cursor, self.code_tree, self.bruteforce, self.verbose)
                 else:
                     output_error(self.bruteforce, "Error: ", cursor.kind.name, " not supported!!")