path: root/bin/leb128

#!/bin/python3

import argparse
import signal
import sys


def SigHandler_SIGINT(signum, frame):
    print()
    sys.exit(0)


def devibytes(val):
    ret = []
    for byte in val.split(","):
        ret.append(int(byte, 16))
    return bytes(ret)


def LEB128UnsignedDecode(bytelist):
    result = 0
    shift = 0
    for byte in bytelist:
        result |= (byte & 0x7F) << shift
        if (byte & 0x80) == 0:
            break
        shift += 7
    return result


def LEB128SignedDecode(bytelist):
    result = 0
    shift = 0
    for byte in bytelist:
        result |= (byte & 0x7F) << shift
        last_byte = byte
        shift += 7
        if (byte & 0x80) == 0:
            break
    if last_byte & 0x40:
        result |= -(1 << shift)
    return result


def LEB128UnsignedEncode(int_val):
    if int_val < 0:
        raise Exception("value must not be negative")
    elif int_val == 0:
        return bytes([0])
    byte_array = bytearray()
    while int_val:
        byte = int_val & 0x7F
        byte_array.append(byte | 0x80)
        int_val >>= 7
    byte_array[-1] ^= 0x80
    return byte_array


def LEB128SignedEncode(int_val):
    byte_array = bytearray()
    while True:
        byte = int_val & 0x7F
        byte_array.append(byte | 0x80)
        int_val >>= 7
        if (int_val == 0 and byte & 0x40 == 0) or (
            int_val == -1 and byte & 0x40
        ):
            byte_array[-1] ^= 0x80
            break
    return byte_array


class Argparser(object):
    def __init__(self):
        parser = argparse.ArgumentParser()
        parser.add_argument("--se", type=int, help="leb128 signed encode")
        parser.add_argument("--ue", type=int, help="leb128 unsigned encode")
        parser.add_argument(
            "--sd",
            type=devibytes,
            help="leb128 signed decode. pass a string like ef1289.",
        )
        parser.add_argument(
            "--ud",
            type=devibytes,
            help="leb128 unsigned decode. pass a string like ef1290",
        )
        self.args = parser.parse_args()


# write code here


def premain():
    signal.signal(signal.SIGINT, SigHandler_SIGINT)
    argparser = Argparser()
    # here
    if argparser.args.se:
        res = LEB128SignedEncode(argparser.args.se)
        for byte in res:
            print(format(byte, "02x"), end=" ")
        print()
    if argparser.args.ue:
        res = LEB128UnsignedEncode(argparser.args.ue)
        for byte in res:
            print(format(byte, "02x"), end=" ")
        print()
    if argparser.args.sd:
        print(LEB128SignedDecode(argparser.args.sd))
    if argparser.args.ud:
        print(LEB128UnsignedDecode(argparser.args.ud))


def main():
    try:
        premain()
    except Exception as e:
        print(e)


if __name__ == "__main__":
    main()