Rearrange enum convertion methods

Author: elicn

qiling/const.py

@@ -4,7 +4,7 @@
 #
 
 from enum import Enum, Flag, IntEnum
-from typing import Any, Mapping, Type
+from typing import Mapping, Type, TypeVar
 
 class QL_ENDIAN(IntEnum):
     EL = 1
@@ -66,16 +66,17 @@ class QL_STOP(Flag):
 QL_HOOK_BLOCK = 0b0001
 QL_CALL_BLOCK = 0b0010
 
-def __reverse_enum(e: Type[Enum]) -> Mapping[str, Any]:
-    '''Create a reverse mapping for an enum.
+T = TypeVar('T', bound=Enum)
+def __casefold_enum(e: Type[T]) -> Mapping[str, T]:
+    '''Create a casefolded mapping of an enum to allow case-insensitive lookup.
     '''
 
-    return dict((v.name.lower(), v) for v in e.__members__.values())
+    return dict((k.casefold(), v) for k, v in e._member_map_.items())
 
-debugger_map: Mapping[str, QL_DEBUGGER] = __reverse_enum(QL_DEBUGGER)
-arch_map    : Mapping[str, QL_ARCH]     = __reverse_enum(QL_ARCH)
-os_map      : Mapping[str, QL_OS]       = __reverse_enum(QL_OS)
-verbose_map : Mapping[str, QL_VERBOSE]  = __reverse_enum(QL_VERBOSE)
+debugger_map = __casefold_enum(QL_DEBUGGER)
+arch_map     = __casefold_enum(QL_ARCH)
+os_map       = __casefold_enum(QL_OS)
+verbose_map  = __casefold_enum(QL_VERBOSE)
 
 arch_os_map = {
     QL_ARCH.EVM      : QL_OS.EVM,

qiling/core.py

@@ -122,7 +122,7 @@ def __init__(
             archtype = arch_convert(archtype)
 
         if type(ostype) is str:
-            ostype = ostype_convert(ostype)
+            ostype = os_convert(ostype)
 
         # if provided arch was invalid or not provided, guess arch and os
         if archtype is None:
@@ -141,23 +141,18 @@ def __init__(
             ostype = arch_os_convert(archtype)
 
         # arch should have been determined by now; fail if not
-        if archtype is None or not ql_is_valid_arch(archtype):
+        if type(archtype) is not QL_ARCH:
             raise QlErrorArch(f'Uknown or unsupported architecture: "{archtype}"')
 
         # os should have been determined by now; fail if not
-        if ostype is None or not ql_is_valid_ostype(ostype):
+        if type(ostype) is not QL_OS:
             raise QlErrorOsType(f'Unknown or unsupported operating system: "{ostype}"')
 
         # if endianess is still undetermined, set it to little-endian.
         # this setting is ignored for architectures with predfined endianess
         if endian is None:
             endian = QL_ENDIAN.EL
 
-        # make sure args were canonicalized successfully
-        assert type(archtype) is QL_ARCH
-        assert type(ostype) is QL_OS
-        assert type(endian) is QL_ENDIAN
-
         self._arch = arch_setup(archtype, endian, thumb, self)
 
         self.uc = self.arch.uc

qiling/debugger/gdb/gdb.py

@@ -483,7 +483,7 @@ def handle_q(subcmd):
                 elif subcmd.startswith('Xfer:features:read'):
                     xfercmd_file    = subcmd.split(':')[3]
                     xfercmd_abspath = os.path.dirname(os.path.abspath(__file__))
-                    xml_folder      = arch_convert_str(self.ql.arch.type).lower()
+                    xml_folder      = self.ql.arch.type.name.lower()
                     xfercmd_file    = os.path.join(xfercmd_abspath,"xml",xml_folder, xfercmd_file)                        
 
                     if os.path.exists(xfercmd_file) and self.ql.os.type is not QL_OS.WINDOWS:

qiling/host.py

@@ -21,7 +21,7 @@ def os(self) -> Optional[QL_OS]:
 
         system = platform.system()
 
-        return utils.ostype_convert(system.lower())
+        return utils.os_convert(system)
 
     @cached_property
     def arch(self) -> Optional[QL_ARCH]:
@@ -30,4 +30,4 @@ def arch(self) -> Optional[QL_ARCH]:
 
         machine = platform.machine()
 
-        return utils.arch_convert(machine.lower())
+        return utils.arch_convert(machine)

qiling/os/posix/posix.py

@@ -18,7 +18,7 @@
 from qiling.exception import QlErrorSyscallNotFound
 from qiling.os.os import QlOs
 from qiling.os.posix.const import errors
-from qiling.utils import ostype_convert_str, ql_get_module_function, ql_syscall_mapping_function
+from qiling.utils import ql_get_module_function, ql_syscall_mapping_function
 
 from qiling.os.posix.syscall import *
 from qiling.os.linux.syscall import *
@@ -231,7 +231,7 @@ def load_syscall(self):
             def __get_os_module(osname: str):
                 return ql_get_module_function(f'qiling.os.{osname.lower()}', 'syscall')
 
-            os_syscalls = __get_os_module(ostype_convert_str(self.type))
+            os_syscalls = __get_os_module(self.type.name)
             posix_syscalls = __get_os_module('posix')
 
             # look in os-specific and posix syscall hooks

qiling/utils.py

@@ -12,8 +12,7 @@
 import importlib, os, pefile, yaml
 
 from configparser import ConfigParser
-from typing import Any, Container, Optional, Tuple, Type, Union
-from enum import Enum
+from typing import Any, Mapping, Optional, Tuple, Type, Union
 
 from unicorn import UC_ERR_READ_UNMAPPED, UC_ERR_FETCH_UNMAPPED
 
@@ -31,49 +30,31 @@ def wrapper(*args, **kw):
 
     return wrapper
 
-def enum_values(e: Type[Enum]) -> Container:
-    return e.__members__.values()
+def __name_to_enum(name: str, mapping: Mapping[str, T], aliases: Mapping[str, str] = {}) -> Optional[T]:
+    key = name.casefold()
 
-def ql_is_valid_ostype(ostype: QL_OS) -> bool:
-    return ostype in enum_values(QL_OS)
+    return mapping.get(aliases.get(key) or key)
 
-def ql_is_valid_arch(arch: QL_ARCH) -> bool:
-    return arch in enum_values(QL_ARCH)
-
-def __value_to_key(e: Type[Enum], val: Any) -> Optional[str]:
-    key = e._value2member_map_[val]
-
-    return None if key is None else key.name
-
-def ostype_convert_str(ostype: QL_OS) -> Optional[str]:
-    return __value_to_key(QL_OS, ostype)
-
-def ostype_convert(ostype: str) -> Optional[QL_OS]:
+def os_convert(os: str) -> Optional[QL_OS]:
     alias_map = {
-        "darwin": "macos",
+        'darwin' : 'macos'
     }
 
-    return os_map.get(alias_map.get(ostype, ostype))
-
-def arch_convert_str(arch: QL_ARCH) -> Optional[str]:
-    return __value_to_key(QL_ARCH, arch)
+    return __name_to_enum(os, os_map, alias_map)
 
 def arch_convert(arch: str) -> Optional[QL_ARCH]:
     alias_map = {
-        "x86_64": "x8664",
-        "riscv32": "riscv",
+        'x86_64'  : 'x8664',
+        'riscv32' : 'riscv'
     }
-    
-    return arch_map.get(alias_map.get(arch, arch))
 
-def arch_os_convert(arch: QL_ARCH) -> Optional[QL_OS]:
-    return arch_os_map.get(arch)
+    return __name_to_enum(arch, arch_map, alias_map)
 
 def debugger_convert(debugger: str) -> Optional[QL_DEBUGGER]:
-    return debugger_map.get(debugger)
+    return __name_to_enum(debugger, debugger_map)
 
-def debugger_convert_str(debugger_id: QL_DEBUGGER) -> Optional[str]:
-    return __value_to_key(QL_DEBUGGER, debugger_id)
+def arch_os_convert(arch: QL_ARCH) -> Optional[QL_OS]:
+    return arch_os_map.get(arch)
 
 # Call `function_name` in `module_name`.
 # e.g. map_syscall in qiling.os.linux.map_syscall
@@ -368,7 +349,7 @@ def arch_setup(archtype: QL_ARCH, endian: QL_ENDIAN, thumb: bool, ql):
     }[archtype]
 
     qlarch_path = f'qiling.arch.{module}'
-    qlarch_class = f'QlArch{arch_convert_str(archtype).upper()}'
+    qlarch_class = f'QlArch{archtype.name.upper()}'
 
     obj = ql_get_module_function(qlarch_path, qlarch_class)
 
@@ -377,7 +358,7 @@ def arch_setup(archtype: QL_ARCH, endian: QL_ENDIAN, thumb: bool, ql):
 
 # This function is extracted from os_setup (QlOsPosix) so I put it here.
 def ql_syscall_mapping_function(ostype: QL_OS, archtype: QL_ARCH):
-    qlos_name = ostype_convert_str(ostype)
+    qlos_name = ostype.name
     qlos_path = f'qiling.os.{qlos_name.lower()}.map_syscall'
     qlos_func = 'get_syscall_mapper'
 
@@ -409,7 +390,7 @@ def profile_setup(ql, ostype: QL_OS, filename: Optional[str]):
 
     else:
         qiling_home = os.path.dirname(os.path.abspath(__file__))
-        os_profile = os.path.join(qiling_home, 'profiles', f'{ostype_convert_str(ostype).lower()}.ql')
+        os_profile = os.path.join(qiling_home, 'profiles', f'{ostype.name.lower()}.ql')
 
         profiles = [os_profile]