Added the ability to utilize custom calling convention in data files

Author: Ayuto

addons/source-python/packages/source-python/memory/helpers.py

@@ -95,7 +95,7 @@ class Key(object):
     DOC = 'doc'
 
     @staticmethod
-    def as_bool(value):
+    def as_bool(manager, value):
         """Convert a string to a boolean.
 
         Raises a ValueError if the string doesn't represent such a value.
@@ -111,23 +111,23 @@ def as_bool(value):
             'Cannot convert "{0}" to a boolean value.'.format(value))
 
     @staticmethod
-    def as_args_tuple(value):
+    def as_args_tuple(manager, value):
         """Convert a string into a tuple containing <DataType> elements."""
         if isinstance(value, str):
             return (DataType.names[value], )
 
         return tuple(DataType.names[item] for item in value)
 
     @staticmethod
-    def as_return_type(value):
+    def as_return_type(manager, value):
         """Convert a string into a <Return> object.
 
         If the conversion fails, the string itself will be returned.
         """
         return DataType.names.get(value, value)
 
     @staticmethod
-    def as_identifier(value):
+    def as_identifier(manager, value):
         """Convert a string into a byte string.
 
         If no spaces in the string, the string itself will be returned.
@@ -138,18 +138,31 @@ def as_identifier(value):
         return value
 
     @staticmethod
-    def as_convention(value):
+    def as_convention(manager, value):
         """Convert a string into a <Convention> object."""
-        return Convention.names[value]
+        try:
+            return Convention.names[value]
+        except KeyError:
+            return manager.custom_conventions[value]
 
     @staticmethod
-    def as_attribute_type(value):
+    def as_attribute_type(manager, value):
         """Convert a string into a <Type> value."""
         if Type.is_native(value):
             return getattr(Type, value)
 
         return value
 
+    @staticmethod
+    def as_str(manager, value):
+        """Convert the value to a string."""
+        return str(value)
+
+    @staticmethod
+    def as_int(manager, value):
+        """Convert the value to an integer."""
+        return int(value)
+
 
 # =============================================================================
 # >> BasePointer
@@ -329,7 +342,7 @@ def skip_hooks(self, *args):
 # =============================================================================
 # >> FUNCTIONS
 # =============================================================================
-def parse_data(raw_data, keys):
+def parse_data(manager, raw_data, keys):
     """Parse the data dictionary.
 
     Parses by converting the values of the given keys into
@@ -340,28 +353,33 @@ def parse_data(raw_data, keys):
 
     <keys> must have the following structure:
     ((<key name>, <converter>, <default value>), ...)
+    
+    The convert function must accept 2 arguments:
+    
+    1. An instance of the TypeManager class
+    2. The value to convert
 
 
     Information about data that comes from a file:
 
-    You can specialize every key by adding "_nt" (for Windows) or "_posix"
-    (for Linux) to the end a key.
+    You can specialize every key by adding ''_windows'' (for Windows) or
+    ''_linux'' (for Linux) to the end a key.
 
     For example:
     If you are using a signature on Windows, but a symbol on Linux, you have
     three possibilities to do that:
 
     1.
-    identifier_nt    = <signature for Windows>
-    identifier       = <symbol for Linux>
+    identifier_windows = <signature for Windows>
+    identifier         = <symbol for Linux>
 
     2.
-    identifier       = <signature for Windows>
-    identifier_posix = <symbol for Linux>
+    identifier         = <signature for Windows>
+    identifier_linux   = <symbol for Linux>
 
     3.
-    identifier_nt    = <signature for Windows>
-    identifier_posix = <symbol for Linux>
+    identifier_windows = <signature for Windows>
+    identifier_linux   = <symbol for Linux>
     """
     for name, data in raw_data.items():
         temp_data = []
@@ -375,7 +393,8 @@ def parse_data(raw_data, keys):
                 raise KeyError(
                     'Missing information for key "{0}".'.format(key))
 
-            temp_data.append(value if value is default else converter(value))
+            temp_data.append(
+                value if value is default else converter(manager, value))
 
         yield (name, temp_data)
 

addons/source-python/packages/source-python/memory/manager.py

@@ -165,6 +165,9 @@ def __init__(self):
         # Stores function typedefs
         self.function_typedefs = {}
 
+        # Storage for custom calling conventions
+        self.custom_conventions = {}
+
     def __call__(self, name, bases, cls_dict):
         """Create and registers a new class."""
         # Set the manager attribute. This is required, so CustomType.__init__
@@ -183,6 +186,41 @@ def __call__(self, name, bases, cls_dict):
         self[name] = cls
         return cls
 
+    def custom_calling_convention(self, cls):
+        """Register a custom calling convention class by its name.
+
+        Example:
+
+        .. code:: python
+
+            @manager.custom_calling_convention
+            class MyCustomCallingConvention(CallingConvention):
+                pass
+
+            # Equals to...
+            class MyCustomCallingConvention(CallingConvention):
+                pass
+
+            manager.register_convention(
+                'MyCustomCallingConvention',
+                MyCustomCallingConvention)
+        """
+        self.register_convention(cls.__name__, cls)
+
+    def register_convention(self, name, convention):
+        """Register a custom calling convention.
+
+        :param str name:
+            Name of the custom calling convention.
+        :param CallingConvention convention:
+            The custom calling convention.
+        """
+        self.custom_conventions[name] = convention
+
+    def unregister_convention(self, name):
+        """Unregister a custom calling convention."""
+        self.custom_conventions.pop(name, None)
+
     def register_converter(self, name, obj):
         """Register a callable object as a converter.
 
@@ -262,15 +300,16 @@ def create_pipe_from_dict(self, raw_data):
         """Create a pipe from a dictionary."""
         # Prepare functions
         funcs = parse_data(
+            self,
             raw_data,
             (
-                (Key.BINARY, str, NO_DEFAULT),
+                (Key.BINARY, Key.as_str, NO_DEFAULT),
                 (Key.IDENTIFIER, Key.as_identifier, NO_DEFAULT),
                 (Key.ARGS, Key.as_args_tuple, ()),
                 (Key.RETURN_TYPE, Key.as_return_type, DataType.VOID),
                 (Key.CONVENTION, Key.as_convention, Convention.CDECL),
                 (Key.SRV_CHECK, Key.as_bool, True),
-                (Key.DOC, str, None)
+                (Key.DOC, Key.as_str, None)
             )
         )
 
@@ -308,14 +347,15 @@ def create_type_from_dict(self, type_name, raw_data, bases=(CustomType,)):
         """Create and registers a new type from a dictionary."""
         # Prepare general type information
         data = tuple(parse_data(
+            self,
             # Discard all subkeys and add the new dict to a another dict to
             # make it work with parse_data(). Okay, this can be improved...
             {0: dict((k, v) for k, v in raw_data.items() if not isinstance(
                 v, dict))},
             (
-                (Key.BINARY, str, CustomType._binary),
+                (Key.BINARY, Key.as_str, CustomType._binary),
                 (Key.SRV_CHECK, Key.as_bool, CustomType._srv_check),
-                (Key.SIZE, int, CustomType._size)
+                (Key.SIZE, Key.as_int, CustomType._size)
             )
         ))[0][1]
 
@@ -324,11 +364,12 @@ def create_type_from_dict(self, type_name, raw_data, bases=(CustomType,)):
         # Prepare pointer and instance attributes
         for method in (self.instance_attribute, self.pointer_attribute):
             attributes = parse_data(
+                self,
                 raw_data.get(method.__name__, {}),
                 (
                     (Key.TYPE_NAME, Key.as_attribute_type, NO_DEFAULT),
-                    (Key.OFFSET, int, NO_DEFAULT),
-                    (Key.DOC, str, None)
+                    (Key.OFFSET, Key.as_int, NO_DEFAULT),
+                    (Key.DOC, Key.as_str, None)
                 )
             )
 
@@ -343,12 +384,13 @@ def create_type_from_dict(self, type_name, raw_data, bases=(CustomType,)):
                 self.static_pointer_array,
                 self.dynamic_pointer_array):
             arrays = parse_data(
+                self,
                 raw_data.get(method.__name__, {}),
                 (
                     (Key.TYPE_NAME, Key.as_attribute_type, NO_DEFAULT),
-                    (Key.OFFSET, int, NO_DEFAULT),
-                    (Key.LENGTH, int, None),
-                    (Key.DOC, str, None)
+                    (Key.OFFSET, Key.as_int, NO_DEFAULT),
+                    (Key.LENGTH, Key.as_int, None),
+                    (Key.DOC, Key.as_str, None)
                 )
             )
 
@@ -358,13 +400,14 @@ def create_type_from_dict(self, type_name, raw_data, bases=(CustomType,)):
 
         # Prepare virtual functions
         vfuncs = parse_data(
+            self,
             raw_data.get('virtual_function', {}),
             (
-                (Key.OFFSET, int, NO_DEFAULT),
+                (Key.OFFSET, Key.as_int, NO_DEFAULT),
                 (Key.ARGS, Key.as_args_tuple, ()),
                 (Key.RETURN_TYPE, Key.as_return_type, DataType.VOID),
                 (Key.CONVENTION, Key.as_convention, Convention.THISCALL),
-                (Key.DOC, str, None)
+                (Key.DOC, Key.as_str, None)
             )
         )
 
@@ -374,13 +417,14 @@ def create_type_from_dict(self, type_name, raw_data, bases=(CustomType,)):
 
         # Prepare functions
         funcs = parse_data(
+            self,
             raw_data.get('function', {}),
             (
                 (Key.IDENTIFIER, Key.as_identifier, NO_DEFAULT),
                 (Key.ARGS, Key.as_args_tuple, ()),
                 (Key.RETURN_TYPE, Key.as_return_type, DataType.VOID),
                 (Key.CONVENTION, Key.as_convention, Convention.THISCALL),
-                (Key.DOC, str, None)
+                (Key.DOC, Key.as_str, None)
             )
         )
 
@@ -657,12 +701,13 @@ def create_function_typedefs_from_file(self, f):
 
         # Prepare typedefs
         typedefs = parse_data(
+            self,
             raw_data,
             (
                 (Key.ARGS, Key.as_args_tuple, ()),
                 (Key.RETURN_TYPE, Key.as_return_type, DataType.VOID),
                 (Key.CONVENTION, Key.as_convention, Convention.CDECL),
-                (Key.DOC, str, None)
+                (Key.DOC, Key.as_str, None)
             )
         )
 
@@ -694,12 +739,13 @@ def create_global_pointers_from_file(self, f):
         """Create global pointers from a file."""
         # Parse pointer data
         pointers = parse_data(
+            self,
             ConfigObj(f, file_error=True),
             (
-                (Key.BINARY, str, NO_DEFAULT),
+                (Key.BINARY, Key.as_str, NO_DEFAULT),
                 (Key.IDENTIFIER, Key.as_identifier, NO_DEFAULT),
-                (Key.OFFSET, int, 0),
-                (Key.LEVEL, int, 0),
+                (Key.OFFSET, Key.as_int, 0),
+                (Key.LEVEL, Key.as_int, 0),
                 (Key.SRV_CHECK, Key.as_bool, True),
             )
         )