[LLDB] Remove __future__ imports from examples

[DavidSpickett]

Summary

Not needed now that we require python 3.

[kastiglione]

thanks I had the same thought

[JDevlieghere]

LGTM

lldb/examples/customization/bin-utils/binutils.py

 "Collection of tools for displaying bit representation of numbers."""
 
-from __future__ import print_function
-
 def binary(n, width=None):
     """
     Return a list of (0|1)'s for the binary representation of n where n >= 0.
     If you specify a width, it must be > 0, otherwise it is ignored.  The list
     could be padded with 0 bits if width is specified.
     """
     l = []
     if width and width <= 0:

lldb/examples/customization/import-python/importcmd.py

-from __future__ import print_function
 import sys
 import os
 import lldb
 
 
 def check_has_dir_in_path(dirname):
     return sys.path.__contains__(dirname)
 

lldb/examples/customization/pwd-cd-and-system/utils.py

 """Utility for changing directories and execution of commands in a subshell."""
-from __future__ import print_function
 
 import os
 import shlex
 import subprocess
 
 # Store the previous working directory for the 'cd -' command.
 
 

lldb/examples/darwin/heap_find/heap.py

 #!/usr/bin/env python3
 
 #----------------------------------------------------------------------
 # This module is designed to live inside the "lldb" python package
 # in the "lldb.macosx" package. To use this in the embedded python
 # interpreter using "lldb" just import it:
 #
 #   (lldb) script import lldb.macosx.heap
 #----------------------------------------------------------------------
 
-from __future__ import print_function
 import lldb
 import optparse
 import os
 import os.path
 import re
 import shlex
 import string
 import sys

lldb/examples/python/bsd.py

 #!/usr/bin/env python
-from __future__ import print_function
 
 import cmd
 import optparse
 import os
 import shlex
 import struct
 import sys
 

lldb/examples/python/cmdtemplate.py

 #!/usr/bin/env python
 
 # ---------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 #
 # # To use this in the embedded python interpreter using "lldb" just
 # import it with the full path using the "command script import"
 # command
 #   (lldb) command script import /path/to/cmdtemplate.py
 # ---------------------------------------------------------------------
 
-from __future__ import print_function
-
 import inspect
 import lldb
 import optparse
 import shlex
 import sys
 
 
 class FrameStatCommand:

lldb/examples/python/delta.py

 # To use this in the embedded python interpreter using "lldb" just
 # import it with the full path using the "command script import"
 # command. This can be done from the LLDB command line:
 #   (lldb) command script import /path/to/gdbremote.py
 # Or it can be added to your ~/.lldbinit file so this module is always
 # available.
 #----------------------------------------------------------------------
 
-from __future__ import print_function
-
 import optparse
 import os
 import shlex
 import re
 import tempfile
 
 
 def start_gdb_log(debugger, command, result, dict):

lldb/examples/python/diagnose_nsstring.py

 # This implements the "diagnose-nsstring" command, usually installed in the debug session like
 #   command script import lldb.diagnose
 # it is used when NSString summary formatter fails to replicate the logic that went into LLDB making the
 # decisions it did and  providing some useful context information that can
 # be used for improving the formatter
 
-from __future__ import print_function
-
 import lldb
 
 
 def read_memory(process, location, size):
     data = ""
     error = lldb.SBError()
     for x in range(0, size - 1):
         byte = process.ReadUnsignedFromMemory(x + location, 1, error)

lldb/examples/python/diagnose_unwind.py

 # This implements the "diagnose-unwind" command, usually installed
 # in the debug session like
 #   command script import lldb.diagnose
 # it is used when lldb's backtrace fails -- it collects and prints
 # information about the stack frames, and tries an alternate unwind
 # algorithm, that will help to understand why lldb's unwind algorithm
 # did not succeed.
-from __future__ import print_function
 
 import optparse
 import lldb
 import re
 import shlex
 
 # Print the frame number, pc, frame pointer, module UUID and function name
 # Returns the SBModule that contains the PC, if it could be found

lldb/examples/python/gdbremote.py

 # To use this in the embedded python interpreter using "lldb" just
 # import it with the full path using the "command script import"
 # command. This can be done from the LLDB command line:
 #   (lldb) command script import /path/to/gdbremote.py
 # Or it can be added to your ~/.lldbinit file so this module is always
 # available.
 #----------------------------------------------------------------------
 
-from __future__ import print_function
 import binascii
 import subprocess
 import json
 import math
 import optparse
 import os
 import re
 import shlex

lldb/examples/python/globals.py

 #!/usr/bin/env python
 
 #----------------------------------------------------------------------
 # For the shells csh, tcsh:
 #   ( setenv PYTHONPATH /Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python ; ./globals.py <path> [<path> ...])
 #
 # For the shells sh, bash:
 #   PYTHONPATH=/Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python ./globals.py <path> [<path> ...]
 #----------------------------------------------------------------------
-from __future__ import print_function
 
 import lldb
 import optparse
 import os
 import shlex
 import sys
 
 

lldb/examples/python/jump.py

-from __future__ import print_function
-
 import lldb
 import re
 
 
 def parse_linespec(linespec, frame, result):
     """Handles a subset of GDB-style linespecs.  Specifically:
 
        number           - A line in the current file

lldb/examples/python/lldb_module_utils.py

 #!/usr/bin/env python
-from __future__ import print_function
 
 import lldb
 import optparse
 import shlex
 import string
 import sys
 
 

lldb/examples/python/lldbtk.py

 #!/usr/bin/env python
-from __future__ import print_function
 
 import lldb
 import shlex
 import sys
 try:
     from tkinter import *
     import tkinter.ttk as ttk
 except ImportError:

lldb/examples/python/mach_o.py

 #!/usr/bin/env python
-from __future__ import print_function
 
 import cmd
 import dict_utils
 import file_extract
 import optparse
 import re
 import struct
 import string

lldb/examples/python/memory.py

 #!/usr/bin/env python
 
 #----------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 #
 # # To use this in the embedded python interpreter using "lldb" just
 # import it with the full path using the "command script import"
 # command
 #   (lldb) command script import /path/to/cmdtemplate.py
 #----------------------------------------------------------------------
 
-from __future__ import print_function
-
 import platform
 import os
 import re
 import sys
 import subprocess
 
 try:
     # Just try for LLDB in case PYTHONPATH is already correctly setup

lldb/examples/python/performance.py

 #!/usr/bin/env python
 
 #----------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 # On MacOSX csh, tcsh:
 #   setenv PYTHONPATH /Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python
 # On MacOSX sh, bash:
 #   export PYTHONPATH=/Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python
 #----------------------------------------------------------------------
 
-from __future__ import print_function
-
 import optparse
 import os
 import platform
 import re
 import resource
 import sys
 import subprocess
 import time

lldb/examples/python/process_events.py

 #!/usr/bin/env python
 
 #----------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 # On MacOSX csh, tcsh:
 #   setenv PYTHONPATH /Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python
 # On MacOSX sh, bash:
 #   export PYTHONPATH=/Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework/Resources/Python
 #----------------------------------------------------------------------
 
-from __future__ import print_function
-
 import optparse
 import os
 import platform
 import sys
 import subprocess
 
 #----------------------------------------------------------------------
 # Code that auto imports LLDB

lldb/examples/python/pytracer.py

-from __future__ import print_function
 import sys
 import inspect
 from collections import OrderedDict
 
 
 class TracebackFancy:
 
     def __init__(self, traceback):

lldb/examples/python/scripted_step.py

 # To use these stepping modes, you would do:
 #
 #     (lldb) command script import scripted_step.py
 #     (lldb) thread step-scripted -C scripted_step.SimpleStep
 # or
 #
 #     (lldb) thread step-scripted -C scripted_step.StepWithPlan
 
-from __future__ import print_function
-
 import lldb
 
 
 class SimpleStep:
 
     def __init__(self, thread_plan, dict):
         self.thread_plan = thread_plan
         self.start_address = thread_plan.GetThread().GetFrameAtIndex(0).GetPC()

lldb/examples/python/shadow.py

 #!/usr/bin/env python
-from __future__ import print_function
 
 import lldb
 import shlex
 
 
 @lldb.command("shadow")
 def check_shadow_command(debugger, command, exe_ctx, result, dict):
     '''Check the currently selected stack frame for shadowed variables'''

lldb/examples/python/sources.py

 #!/usr/bin/env python
-from __future__ import print_function
 
 import lldb
 import shlex
 
 
 def dump_module_sources(module, result):
     if module:
         print("Module: %s" % (module.file), file=result)

lldb/examples/python/stacks.py

 #!/usr/bin/env python
-from __future__ import print_function
 import lldb
 import optparse
 import shlex
 
 
 def stack_frames(debugger, command, result, dict):
     command_args = shlex.split(command)
     usage = "usage: %prog [options] <PATH> [PATH ...]"

lldb/examples/python/symbolication.py

 #
 # On MacOSX csh, tcsh:
 #   ( setenv PYTHONPATH /path/to/LLDB.framework/Resources/Python ; ./crashlog.py ~/Library/Logs/DiagnosticReports/a.crash )
 #
 # On MacOSX sh, bash:
 #   PYTHONPATH=/path/to/LLDB.framework/Resources/Python ./crashlog.py ~/Library/Logs/DiagnosticReports/a.crash
 #----------------------------------------------------------------------
 
-from __future__ import print_function
 import lldb
 import optparse
 import os
 import plistlib
 import re
 import shlex
 import sys
 import time

lldb/examples/python/types.py

 #!/usr/bin/env python
 
 #----------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 #
 # # To use this in the embedded python interpreter using "lldb" just
 # import it with the full path using the "command script import"
 # command
 #   (lldb) command script import /path/to/cmdtemplate.py
 #----------------------------------------------------------------------
 
-from __future__ import print_function
-
 import platform
 import os
 import re
 import signal
 import sys
 import subprocess
 
 try:

lldb/examples/scripting/tree_utils.py

 functions, and assume that the LLDB Python module has been
 imported.
 
 For a thorough explanation of how the DFS function works, and
 for more information about dictionary.c go to
 http://lldb.llvm.org/scripting.html
 """
 
-from __future__ import print_function
-
 
 def DFS(root, word, cur_path):
     """
     Recursively traverse a binary search tree containing
     words sorted alphabetically, searching for a particular
     word in the tree.  Also maintains a string representing
     the path from the root of the tree to the current node.
     If the word is found in the tree, return the path string.

lldb/examples/summaries/cocoa/CFBitVector.py

 """
 LLDB AppKit formatters
 
 Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 See https://llvm.org/LICENSE.txt for license information.
 SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 """
-from __future__ import print_function
 
 # summary provider for CF(Mutable)BitVector
 import lldb
 import ctypes
 import lldb.runtime.objc.objc_runtime
 import lldb.formatters.metrics
 import lldb.formatters.Logger
 

lldb/examples/summaries/cocoa/Logger.py

-from __future__ import print_function
 import sys
 import os.path
 import inspect
 
 
 class NopLogger:
 
     def __init__(self):

lldb/examples/summaries/cocoa/NSNumber.py

 """
 LLDB AppKit formatters
 
 Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 See https://llvm.org/LICENSE.txt for license information.
 SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 """
 # example summary provider for NSNumber
 # the real summary is now C++ code built into LLDB
 
-from __future__ import print_function
-
 import lldb
 import ctypes
 import lldb.runtime.objc.objc_runtime
 import lldb.formatters.metrics
 import struct
 import lldb.formatters.Logger
 
 statistics = lldb.formatters.metrics.Metrics()

lldb/examples/synthetic/gnu_libstdcpp.py

-from __future__ import division
 import lldb.formatters.Logger
 
 # C++ STL formatters for LLDB
 # As there are many versions of the libstdc++, you are encouraged to look at the STL
 # implementation for your platform before relying on these formatters to do the right
 # thing for your setup
 
 def ForwardListSummaryProvider(valobj, dict):