Update CHANGES and clean up the explore_ast example

1 files changed, 29 insertions, 31 deletions

diff --git a/examples/explore_ast.py b/examples/explore_ast.py
index 661eee1..3b3205e 100644
--- a/examples/explore_ast.py
+++ b/examples/explore_ast.py
@@ -32,7 +32,7 @@ from pycparser import c_parser, c_ast
 # to, so I've inserted the dummy typedef in the code to let the
 # parser know Hash and Node are types. You don't need to do it
 # when parsing real, correct C code.
-#
+
 text = r"""
     typedef int Node, Hash;
 
@@ -66,8 +66,8 @@ ast = parser.parse(text, filename='<none>')
 # readable way. show() is the most useful tool in exploring ASTs
 # created by pycparser. See the c_ast.py file for the options you
 # can pass it.
-#
-#~ ast.show()
+
+#ast.show(showcoord=True)
 
 # OK, we've seen that the top node is FileAST. This is always the
 # top node of the AST. Its children are "external declarations",
@@ -79,48 +79,49 @@ ast = parser.parse(text, filename='<none>')
 # ext[] holds the children of FileAST. Since the function
 # definition is the third child, it's ext[2]. Uncomment the
 # following line to show it:
-#
-#~ ast.ext[2].show()
+
+#ast.ext[2].show()
 
 # A FuncDef consists of a declaration, a list of parameter
 # declarations (for K&R style function definitions), and a body.
 # First, let's examine the declaration.
-#
+
 function_decl = ast.ext[2].decl
 
 # function_decl, like any other declaration, is a Decl. Its type child
 # is a FuncDecl, which has a return type and arguments stored in a
 # ParamList node
-#~ function_decl.type.show()
-#~ function_decl.type.args.show()
+
+#function_decl.type.show()
+#function_decl.type.args.show()
 
 # The following displays the name and type of each argument:
-#
-#~ for param_decl in function_decl.type.args.params:
-    #~ print('Arg name: %s' % param_decl.name)
-    #~ print('Type:')
-    #~ param_decl.type.show(offset=6)
+
+#for param_decl in function_decl.type.args.params:
+    #print('Arg name: %s' % param_decl.name)
+    #print('Type:')
+    #param_decl.type.show(offset=6)
 
 # The body is of FuncDef is a Compound, which is a placeholder for a block
 # surrounded by {} (You should be reading _c_ast.cfg parallel to this
 # explanation and seeing these things with your own eyes).
 # Let's see the block's declarations:
-#
+
 function_body = ast.ext[2].body
 
 # The following displays the declarations and statements in the function
 # body
-#
-#~ for decl in function_body.block_items:
-    #~ decl.show()
+
+#for decl in function_body.block_items:
+    #decl.show()
 
 # We can see a single variable declaration, i, declared to be a simple type
 # declaration of type 'unsigned int', followed by statements.
 
 # block_items is a list, so the third element is the For statement:
-#
+
 for_stmt = function_body.block_items[2]
-#~ for_stmt.show()
+#for_stmt.show()
 
 # As you can see in _c_ast.cfg, For's children are 'init, cond,
 # next' for the respective parts of the 'for' loop specifier,
@@ -128,26 +129,26 @@ for_stmt = function_body.block_items[2]
 # a block.
 #
 # Let's dig deeper, to the while statement inside the for loop:
-#
+
 while_stmt = for_stmt.stmt.block_items[1]
-#~ while_stmt.show()
+#while_stmt.show()
 
 # While is simpler, it only has a condition node and a stmt node.
 # The condition:
-#
+
 while_cond = while_stmt.cond
-#~ while_cond.show()
+#while_cond.show()
 
 # Note that it's a BinaryOp node - the basic constituent of
 # expressions in our AST. BinaryOp is the expression tree, with
 # left and right nodes as children. It also has the op attribute,
 # which is just the string representation of the operator.
-#
-#~ print(while_cond.op)
-#~ while_cond.left.show()
-#~ while_cond.right.show()
 
-#
+#print(while_cond.op)
+#while_cond.left.show()
+#while_cond.right.show()
+
+
 # That's it for the example. I hope you now see how easy it is to explore the
 # AST created by pycparser. Although on the surface it is quite complex and has
 # a lot of node types, this is the inherent complexity of the C language every
@@ -156,6 +157,3 @@ while_cond = while_stmt.cond
 # structure of AST nodes and write code that processes them.
 # Specifically, see the cdecl.py example for a non-trivial demonstration of what
 # you can do by recursively going through the AST.
-#
-
-