Tools gdb script renamed class xrange to range for python3.0

Tools/gdb/webkit.py

 # Copyright (C) 2010, Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 23 matching lines @@
   sys.path.insert(0, "/path/to/tools/gdb/")
   import webkit
 """
 
 from __future__ import print_function
 
 import gdb
 import re
 import struct
 
-
 def guess_string_length(ptr):
     """Guess length of string pointed by ptr.
 
     Returns a tuple of (length, an error message).
     """
     # Try to guess at the length.
-    for i in xrange(0, 2048):
+    for i in range(0, 2048):
         try:
             if int((ptr + i).dereference()) == 0:
                 return i, ''
         except RuntimeError:
             # We indexed into inaccessible memory; give up.
             return i, ' (gdb hit inaccessible memory)'
     return 256, ' (gdb found no trailing NUL)'
 
 
 def ustring_to_string(ptr, length=None):
     """Convert a pointer to UTF-16 data into a Python string encoded with utf-8.
 
     ptr and length are both gdb.Value objects.
     If length is unspecified, will guess at the length."""
     error_message = ''
     if length is None:
         length, error_message = guess_string_length(ptr)
     else:
         length = int(length)
-    char_vals = [int((ptr + i).dereference()) for i in xrange(length)]
+    char_vals = [int((ptr + i).dereference()) for i in range(length)]
     string = struct.pack('H' * length, *char_vals).decode('utf-16', 'replace').encode('utf-8')
     return string + error_message
 
 
 def lstring_to_string(ptr, length=None):
     """Convert a pointer to LChar* data into a Python (non-Unicode) string.
 
     ptr and length are both gdb.Value objects.
     If length is unspecified, will guess at the length."""
     error_message = ''
     if length is None:
         length, error_message = guess_string_length(ptr)
     else:
         length = int(length)
-    string = ''.join([chr((ptr + i).dereference()) for i in xrange(length)])
+    string = ''.join([chr((ptr + i).dereference()) for i in range(length)])
     return string + error_message
 
 
 class StringPrinter(object):
     "Shared code between different string-printing classes"
     def __init__(self, val):
         self.val = val
 
     def display_hint(self):
         return 'string'
@@ skipping 16 matching lines @@
     def to_string(self):
         return self.val['m_string']
 
 
 class WTFCStringPrinter(StringPrinter):
     "Print a WTF::CString"
     def to_string(self):
         # The CString holds a buffer, which is a refptr to a WTF::CStringBuffer.
         data = self.val['m_buffer']['m_ptr']['m_data'].cast(gdb.lookup_type('char').pointer())
         length = self.val['m_buffer']['m_ptr']['m_length']
-        return ''.join([chr((data + i).dereference()) for i in xrange(length)])
+        return ''.join([chr((data + i).dereference()) for i in range(length)])
 
 
 class WTFStringImplPrinter(StringPrinter):
     "Print a WTF::StringImpl"
     def get_length(self):
         return self.val['m_length']
 
     def to_string(self):
         chars_start = self.val.address + 1
         if self.is_8bit():
@@ skipping 242 matching lines @@
             padding = ''
             while len(stack) > 0:
                 pair = stack.pop()
                 print(padding, pair[1], pair[0])
                 padding = padding + '  '
         else:
             print('Sorry: I don\'t know how to deal with %s yet.' % target_type)
 
 
 PrintPathToRootCommand()