[hmaptool] Port to python3

[lanza]

Summary

This is just a few trivial changes -- change the interpreter and fix a
few byte-vs-string issues.

[bruno]

Overall looks great but there are some test failures, looks like you also need to update line 223?

--
Traceback (most recent call last):
  File "/var/lib/buildkite-agent/builds/llvm-project/build/bin/hmaptool", line 296, in <module>
    main()
  File "/var/lib/buildkite-agent/builds/llvm-project/build/bin/hmaptool", line 293, in main
    commands[cmd](cmd, sys.argv[2:])
  File "/var/lib/buildkite-agent/builds/llvm-project/build/bin/hmaptool", line 223, in action_write
    f.write(magic.encode())
AttributeError: 'bytes' object has no attribute 'encode'
--

[ivanmurashko]

clang/utils/hmaptool/hmaptool

224

magic is a bytes object that does not have encode() method

[bruno]

LGTM!

clang/utils/hmaptool/hmaptool

-#!/usr/bin/env python
+#!/usr/bin/env python3
 from __future__ import absolute_import, division, print_function
 
+from ctypes import ArgumentError
 import json
 import optparse
 import os
 import struct
 import sys
 
 ###
 
-k_header_magic_LE = 'pamh'
-k_header_magic_BE = 'hmap'
+k_header_magic_LE = b'pamh'
+k_header_magic_BE = b'hmap'
 
 def hmap_hash(str):
     """hash(str) -> int
 
     Apply the "well-known" headermap hash function.
     """
 
     return sum((ord(c.lower()) * 13
def frompath(path):
             header_fmt = endian_code + 'HHIIII'
             header_size = struct.calcsize(header_fmt)
             data = f.read(header_size)
             if len(data) != header_size:
                 raise SystemExit("error: %s: truncated headermap header" % (
                         path,))
 
             (version, reserved, strtable_offset, num_entries,
-             num_buckets, max_value_len) = struct.unpack(header_fmt, data)
+             num_buckets) = struct.unpack(header_fmt, data)
 
             if version != 1:
                 raise SystemExit("error: %s: unknown headermap version: %r" % (
                         path, version))
             if reserved != 0:
                 raise SystemExit("error: %s: invalid reserved value in header" % (
                         path,))
 
def frompath(path):
             if strtable_size == 0:
                 raise SystemExit("error: %s: unable to read zero-sized string table"%(
                         path,))
             strtable = f.read(strtable_size)
 
             if len(strtable) != strtable_size:
                 raise SystemExit("error: %s: unable to read complete string table"%(
                         path,))
-            if strtable[-1] != '\0':
+            if strtable[-1] != 0:
                 raise SystemExit("error: %s: invalid string table in headermap" % (
                         path,))
 
             return HeaderMap(num_entries, buckets, strtable)
 
     def __init__(self, num_entries, buckets, strtable):
         self.num_entries = num_entries
         self.buckets = buckets
         self.strtable = strtable
 
     def get_string(self, idx):
         if idx >= len(self.strtable):
             raise SystemExit("error: %s: invalid string index" % (
-                    path,))
-        end_idx = self.strtable.index('\0', idx)
+                    idx,))
+        end_idx = self.strtable.index(0, idx)
         return self.strtable[idx:end_idx]
 
     @property
     def mappings(self):
         for key_idx,prefix_idx,suffix_idx in self.buckets:
             if key_idx == 0:
                 continue
             yield (self.get_string(key_idx),
def action_write(name, args):
     bucket_fmt = endian_code + 'III'
     bucket_size = struct.calcsize(bucket_fmt)
     strtable_offset = magic_size + header_size + num_buckets * bucket_size
     header = (1, 0, strtable_offset, len(mappings),
               num_buckets, max_value_len)
 
     # Write out the headermap.
     with open(output_path, 'wb') as f:
-        f.write(magic.encode())
+        f.write(magic)
         f.write(struct.pack(header_fmt, *header))
         for bucket in table:
             f.write(struct.pack(bucket_fmt, *bucket))
         f.write(strtable.encode())
 
 def action_tovfs(name, args):
     "convert a headermap to a VFS layout"