Python 2/3 compat: StringIO

[labath]

I have a feeling most of these files should be just deleted, but since you went through the trouble of creating this patch, I see no reason why to not accept it.

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

 "Collection of tools for displaying bit representation of numbers."""
 
-import StringIO
-
 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.
     """

lldb/trunk/examples/python/mach_o.py

 #!/usr/bin/python
 from __future__ import print_function
 
 import cmd
 import dict_utils
 import file_extract
 import optparse
 import re
 import struct
 import string
-import StringIO
+import io
 import sys
 import uuid
 
 # Mach header "magic" constants
 MH_MAGIC = 0xfeedface
 MH_CIGAM = 0xcefaedfe
 MH_MAGIC_64 = 0xfeedfacf
 MH_CIGAM_64 = 0xcffaedfe
class Skinny:
                 if section:
                     sect_bytes = section.get_contents(self)
                     if options.outfile:
                         if not saved_section_to_disk:
                             outfile = open(options.outfile, 'w')
                             if options.extract_modules:
                                 # print "Extracting modules from mach file..."
                                 data = file_extract.FileExtract(
-                                    StringIO.StringIO(sect_bytes), self.data.byte_order)
+                                    io.BytesIO(sect_bytes), self.data.byte_order)
                                 version = data.get_uint32()
                                 num_modules = data.get_uint32()
                                 # print "version = %u, num_modules = %u" %
                                 # (version, num_modules)
                                 for i in range(num_modules):
                                     data_offset = data.get_uint64()
                                     data_size = data.get_uint64()
                                     name_offset = data.get_uint32()

lldb/trunk/utils/git-svn/convert.py

 4. git svn dcommit [--commit-url https://[e-mail]/svn/llvm-project/lldb/trunk]
 """
 
 from __future__ import print_function
 
 import os
 import re
 import sys
-import StringIO
+import io
 
 
 def usage(problem_file=None):
     if problem_file:
         print("%s is not a file" % problem_file)
     print("Usage: convert.py raw-message-source [raw-message-source2 ...]")
     sys.exit(0)
 
 
 def do_convert(file):
     """Skip all preceding mail message headers until 'From: ' is encountered.
     Then for each line ('From: ' header included), replace the dos style CRLF
     end-of-line with unix style LF end-of-line.
     """
     print("converting %s ..." % file)
 
     with open(file, 'r') as f_in:
         content = f_in.read()
 
     # The new content to be written back to the same file.
-    new_content = StringIO.StringIO()
+    new_content = io.StringIO()
 
     # Boolean flag controls whether to start printing lines.
     from_header_seen = False
 
     # By default, splitlines() don't include line breaks.  CRLF should be gone.
     for line in content.splitlines():
         # Wait till we scan the 'From: ' header before start printing the
         # lines.

lldb/trunk/utils/lui/lldbutil.py

 They can also be useful for general purpose lldb scripting.
 """
 
 from __future__ import print_function
 
 import lldb
 import os
 import sys
-import StringIO
+import io
 
 # ===================================================
 # Utilities for locating/checking executable programs
 # ===================================================
 
 
 def is_exe(fpath):
     """Returns True if fpath is an executable."""

 # ===================================================
 
 
 def disassemble(target, function_or_symbol):
     """Disassemble the function or symbol given a target.
 
     It returns the disassembly content in a string object.
     """
-    buf = StringIO.StringIO()
+    buf = io.StringIO()
     insts = function_or_symbol.GetInstructions(target)
     for i in insts:
         print(i, file=buf)
     return buf.getvalue()
 
 # ==========================================================
 # Integer (byte size 1, 2, 4, and 8) to bytearray conversion
 # ==========================================================
def GetStackFrame(i):
         return thread.GetFrameAtIndex(i)
 
     return [GetStackFrame(i) for i in range(thread.GetNumFrames())]
 
 
 def print_stacktrace(thread, string_buffer=False):
     """Prints a simple stack trace of this thread."""
 
-    output = StringIO.StringIO() if string_buffer else sys.stdout
+    output = io.StringIO() if string_buffer else sys.stdout
     target = thread.GetProcess().GetTarget()
 
     depth = thread.GetNumFrames()
 
     mods = get_module_names(thread)
     funcs = get_function_names(thread)
     symbols = get_symbol_names(thread)
     files = get_filenames(thread)
def print_stacktrace(thread, string_buffer=False):
 
     if string_buffer:
         return output.getvalue()
 
 
 def print_stacktraces(process, string_buffer=False):
     """Prints the stack traces of all the threads."""
 
-    output = StringIO.StringIO() if string_buffer else sys.stdout
+    output = io.StringIO() if string_buffer else sys.stdout
 
     print("Stack traces for " + str(process), file=output)
 
     for thread in process:
         print(print_stacktrace(thread, string_buffer=True), file=output)
 
     if string_buffer:
         return output.getvalue()
if showFuncName:
         return "%s(%s)" % (name, ", ".join(args))
     else:
         return "(%s)" % (", ".join(args))
 
 
 def print_registers(frame, string_buffer=False):
     """Prints all the register sets of the frame."""
 
-    output = StringIO.StringIO() if string_buffer else sys.stdout
+    output = io.StringIO() if string_buffer else sys.stdout
 
     print("Register sets for " + str(frame), file=output)
 
     registerSet = frame.GetRegisters()  # Return type of SBValueList.
     print("Frame registers (size of register set = %d):" % registerSet.GetSize(
     ), file=output)
     for value in registerSet:
         #print >> output, value

 # ======================================
 
 
 class BasicFormatter(object):
     """The basic formatter inspects the value object and prints the value."""
 
     def format(self, value, buffer=None, indent=0):
         if not buffer:
-            output = StringIO.StringIO()
+            output = io.StringIO()
         else:
             output = buffer
         # If there is a summary, it suffices.
         val = value.GetSummary()
         # Otherwise, get the value.
         if val is None:
             val = value.GetValue()
         if val is None and value.GetNumChildren() > 0:
class ChildVisitingFormatter(BasicFormatter):
     """
 
     def __init__(self, indent_child=2):
         """Default indentation of 2 SPC's for the children."""
         self.cindent = indent_child
 
     def format(self, value, buffer=None):
         if not buffer:
-            output = StringIO.StringIO()
+            output = io.StringIO()
         else:
             output = buffer
 
         BasicFormatter.format(self, value, buffer=output)
         for child in value:
             BasicFormatter.format(
                 self, child, buffer=output, indent=self.cindent)
 
class RecursiveDecentFormatter(BasicFormatter):
     """
 
     def __init__(self, indent_level=0, indent_child=2):
         self.lindent = indent_level
         self.cindent = indent_child
 
     def format(self, value, buffer=None):
         if not buffer:
-            output = StringIO.StringIO()
+            output = io.StringIO()
         else:
             output = buffer
 
         BasicFormatter.format(self, value, buffer=output, indent=self.lindent)
         new_indent = self.lindent + self.cindent
         for child in value:
             if child.GetSummary() is not None:
                 BasicFormatter.format(

lldb/trunk/utils/misc/grep-svn-log.py

 #!/usr/bin/env python
 
 """
 Greps and returns the first svn log entry containing a line matching the regular
 expression pattern passed as the only arg.
 
 Example:
 
 svn log -v | grep-svn-log.py '^   D.+why_are_you_missing.h$'
 """
 from __future__ import print_function
 
 import fileinput
 import re
 import sys
-import StringIO
+import io
 
 # Separator string for "svn log -v" output.
 separator = '-' * 72
 
 usage = """Usage: grep-svn-log.py line-pattern
 Example:
     svn log -v | grep-svn-log.py '^   D.+why_are_you_missing.h'"""
 
 
-class Log(StringIO.StringIO):
+class Log(io.StringIO):
     """Simple facade to keep track of the log content."""
 
     def __init__(self):
         self.reset()
 
     def add_line(self, a_line):
         """Add a line to the content, if there is a previous line, commit it."""
         global separator

lldb/trunk/utils/sync-source/syncsource.py

 #!/usr/bin/env python
 """
 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
 
 Sync lldb and related source from a local machine to a remote machine.
 
 This facilitates working on the lldb sourcecode on multiple machines
 and multiple OS types, verifying changes across all.
 """
 
 import argparse
-import cStringIO
+import io
 import importlib
 import json
 import os.path
 import re
 import sys
 
 # Add the local lib directory to the python path.
 LOCAL_LIB_PATH = os.path.join(

 
 def read_rcfile(filename):
     """Returns the json-parsed contents of the input file."""
 
     # First parse file contents, removing all comments but
     # preserving the line count.
     regex = re.compile(r"#.*$")
 
-    comment_stripped_file = cStringIO.StringIO()
+    comment_stripped_file = io.StringIO()
     with open(filename, "r") as json_file:
         for line in json_file:
             comment_stripped_file.write(regex.sub("", line))
-    return json.load(cStringIO.StringIO(comment_stripped_file.getvalue()))
+    return json.load(io.StringIO(comment_stripped_file.getvalue()))
 
 
 def find_appropriate_rcfile(options):
     # Use an options-specified rcfile if specified.
     if options.rc_file and len(options.rc_file) > 0:
         if not os.path.isfile(options.rc_file):
             # If it doesn't exist, error out here.
             raise "rcfile '{}' specified but doesn't exist".format(

lldb/trunk/utils/test/disasm.py

 
 def do_llvm_mc_disassembly(
         gdb_commands,
         gdb_options,
         exe,
         func,
         mc,
         mc_options):
-    from cStringIO import StringIO
+    from io import StringIO
     import pexpect
 
     gdb_prompt = "\r\n\(gdb\) "
     gdb = pexpect.spawn(('gdb %s' % gdb_options) if gdb_options else 'gdb')
     # Turn on logging for what gdb sends back.
     gdb.logfile_read = sys.stdout
     gdb.expect(gdb_prompt)
 

lldb/trunk/utils/test/run-until-faulted.py

else:
         for path in os.environ["PATH"].split(os.pathsep):
             exe_file = os.path.join(path, program)
             if is_exe(exe_file):
                 return exe_file
     return None
 
 
 def do_lldb_launch_loop(lldb_command, exe, exe_options):
-    from cStringIO import StringIO
     import pexpect
     import time
 
     prompt = "\(lldb\) "
     lldb = pexpect.spawn(lldb_command)
     # Turn on logging for what lldb sends back.
     lldb.logfile_read = sys.stdout
     lldb.expect(prompt)