Including ctypes_generation code in the project

2026-06-08 14:31:45 +00:00 · 2015-12-30 23:12:56 +01:00
parent 28eb4df2d0
commit 65f3c95539
13 changed files with 3560 additions and 1 deletions
@@ -0,0 +1 @@
+*.pyc
@@ -0,0 +1,13 @@
+== ctypes_generation ==
+
+I promise i will make a real README at the root of the project.
+I don't have the need (nor want to code) a full C parser but i need to parse some windows definition
+to generate some python function/struct/flags.
+So, there are 3 dumb parser used to generate:
+    - function prototype
+    - ctypes struct definition
+    - flags (int with name)
+    
+Maybe one day I will do something clean and sane.
+But not today.
+sorry :(
@@ -0,0 +1,34 @@
+from winstruct import WinStruct, WinStructType, Ptr
+import dummy_wintypes
+from simpleparser import *
+import re
+
+class WinDef(object):
+    def __init__(self, name, code):
+        self.name = name
+        self.code = code
+        
+    def generate_ctypes(self):
+        return """{0} = Flag("{0}", {1})""".format(self.name, self.code)
+
+class WinDefParser(Parser):
+
+    def parse_define(self):
+        self.assert_token_type(SharpToken)
+        define = self.assert_token_type(NameToken)
+        if define.value.lower() != "define":
+            raise ValueError("Expection #define got #{0} instead".format(define.value))
+        define_name = self.assert_token_type(NameToken)
+        define_value = []
+        while self.peek() is not None and type(self.peek()) is not SharpToken:
+            v = self.next_token().value
+            if v.lower().startswith("0x") and v[-1] == "L":
+                v = v[:-1]
+            define_value.append(v)
+        return WinDef(define_name.value, " ".join(define_value))
+        
+    def parse(self):
+        res = []
+        while self.peek() is not None:
+            res.append(self.parse_define())
+        return res 
@@ -0,0 +1 @@
+names = ['ATOM', 'BOOL', 'BOOLEAN', 'BYTE', 'COLORREF', 'DOUBLE', 'DWORD', 'FILETIME', 'FLOAT', 'HACCEL', 'HANDLE', 'HBITMAP', ' HBRUSH', 'HCOLORSPACE', 'HDC', 'HDESK', 'HDWP', 'HENHMETAFILE', 'HFONT', 'HGDIOBJ', 'HGLOBAL', 'HHOOK', 'HICON', 'HINSTA NCE', 'HKEY', 'HKL', 'HLOCAL', 'HMENU', 'HMETAFILE', 'HMODULE', 'HMONITOR', 'HPALETTE', 'HPEN', 'HRGN', 'HRSRC', 'HSTR', 'HTASK', 'HWINSTA', 'HWND', 'INT', 'LANGID', 'LARGE_INTEGER', 'LCID', 'LCTYPE', 'LGRPID', 'LONG', 'LPARAM', 'LPCOLESTR' , 'LPCSTR', 'LPCVOID', 'LPCWSTR', 'LPOLESTR', 'LPSTR', 'LPVOID', 'LPWSTR', 'MAX_PATH', 'MSG', 'OLESTR', 'POINT', 'POINTL ', 'RECT', 'RECTL', 'RGB', 'SC_HANDLE', 'SERVICE_STATUS_HANDLE', 'SHORT', 'SIZE', 'SIZEL', 'SMALL_RECT', 'UINT', 'ULARGE _INTEGER', 'ULONG', 'USHORT', 'VARIANT_BOOL', 'WCHAR', 'WIN32_FIND_DATAA', 'WIN32_FIND_DATAW', 'WORD', 'WPARAM', '_COORD ', '_FILETIME', '_LARGE_INTEGER', '_POINTL', '_RECTL', '_SMALL_RECT', '_ULARGE_INTEGER', 'tagMSG', 'tagPOINT', 'tagRECT' , 'tagSIZE']
@@ -0,0 +1,119 @@
+from winstruct import WinStruct, WinStructType, Ptr
+import dummy_wintypes
+from simpleparser import *
+
+
+class WinFunc(object):
+    def __init__(self, return_type, name, params=()):
+        self.name = name
+        self.return_type = return_type
+        self.params = params
+        #if return_type not in dummy_wintypes.names:
+        #    print("Non-standard return type {0}".format(return_type))
+        #for (type, name) in params:
+        #    if type not in dummy_wintypes.names:
+        #        print("Non-standard type {0}".format(type))
+
+    def generate_ctypes(self):
+        return self.generate_comment_ctypes() + "\n" + self.generate_prototype_ctypes() + "\n" + self.generate_paramflags_ctypes() + "\n"
+    
+    def generate_comment_ctypes(self):
+        model = "# {0}({1}):"
+        ctypes_param = [name for type, name in self.params]
+        ctypes_param_str = ", ".join(ctypes_param)
+        return model.format(self.name, ctypes_param_str)
+    
+    def generate_prototype_ctypes(self):
+        model = "{0} = WINFUNCTYPE({1})"
+        ctypes_param = [self.return_type] + [type for type, name in self.params]
+        ctypes_param_str = ", ".join(ctypes_param)
+        return model.format(self.name + "Prototype", ctypes_param_str)
+        
+    def generate_paramflags_ctypes(self):
+        model =  "{0} = {1}"
+        ctypes_paramflags = tuple([(1, name) for type, name in self.params])
+        return model.format(self.name + "Params", ctypes_paramflags)
+
+
+class WinFuncParser(Parser):
+
+    known_io_info_type = ["__in", "__in_opt", "_In_", "_In_opt_", "_Inout_", "_Out_opt_", "_Out_", "_Reserved_", "_Inout_opt_", "__inout_opt", "__out", "__inout"]
+
+    def assert_argument_io_info(self):
+        io_info = self.assert_token_type(NameToken)
+        if io_info.value not in self.known_io_info_type:
+            raise ParsingError("Was expection IO_INFO got {0} instead".format(io_info))
+        return io_info
+        
+    def parse_func_arg(self, has_winapi):
+        type_ptr = False
+        if has_winapi:
+            self.assert_argument_io_info()
+        arg_type = self.assert_token_type(NameToken)
+        if arg_type.value.upper() == "CONST":
+            arg_type = self.assert_token_type(NameToken)
+            
+        if type(self.peek()) == StarToken:
+            type_ptr = True
+            self.assert_token_type(StarToken)  
+        arg_name = self.assert_token_type(NameToken)
+        if not type(self.peek()) == CloseParenthesisToken:
+            self.assert_token_type(CommaToken)
+        if not type_ptr:
+            return (arg_type.value, arg_name.value)
+        return ("POINTER({0})".format(arg_type.value), arg_name.value)
+        
+    def assert_winapi_token(self):
+        winapi = self.assert_token_type(NameToken)
+        if winapi.value != "WINAPI":
+            raise ParsingError("Was expection NameToken(WINAPI) got {0} instead".format(winapi))
+        return winapi    
+        
+    def parse_winfunc(self):
+        has_winapi = False
+        try:
+            return_type = self.assert_token_type(NameToken).value
+        except StopIteration:
+            raise NormalParsingTerminaison()
+
+        func_name = self.assert_token_type(NameToken).value
+        if func_name.upper() == "WINAPI":
+            has_winapi = True
+            func_name = self.assert_token_type(NameToken).value
+            
+        self.assert_token_type(OpenParenthesisToken)
+
+        params = []
+        while type(self.peek()) != CloseParenthesisToken:
+            params.append(self.parse_func_arg(has_winapi))
+
+        self.assert_token_type(CloseParenthesisToken)
+        self.assert_token_type(ColonToken)
+        return WinFunc(return_type, func_name, params)
+
+    def parse(self):
+        res = []
+        while self.peek() is not None:
+            res.append(self.parse_winfunc())
+        return res
+            
+            
+           
+
+def dbg_lexer(data):
+    for i in Lexer(data).token_generation():
+        print i
+
+def dbg_parser(data):
+    return WinFuncParser(data).parse()
+
+def dbg_validate(data):
+    return validate_structs(Parser(data).parse())
+    
+       
+
+if __name__ == "__main__":
+    import sys
+    data = open(sys.argv[1], 'r').read()
+    funcs = generate_ctypes(data)
+    print(funcs) 
@@ -0,0 +1,212 @@
+import sys
+import os
+import os.path
+
+import dummy_wintypes
+import struct_parser
+import func_parser
+import def_parser
+
+
+TYPE_EQUIVALENCE = [
+    ('PWSTR', 'LPWSTR'),
+    ('SIZE_T', 'c_ulong'),
+    ('PSIZE_T', 'POINTER(SIZE_T)'),
+    ('PVOID', 'c_void_p'),
+    ('PPS_POST_PROCESS_INIT_ROUTINE', 'PVOID'),
+    ('NTSTATUS', 'DWORD'),
+    ('PULONG', 'POINTER(ULONG)'),
+    ('PDWORD', 'POINTER(DWORD)'),
+    ('LPDWORD', 'POINTER(DWORD)'),
+    ('LPTHREAD_START_ROUTINE', 'PVOID'),
+    ('PHANDLER_ROUTINE', 'PVOID'),
+    ('LPBYTE', 'POINTER(BYTE)'),
+    ('ULONG_PTR','PULONG'),
+    ('CHAR', 'c_char'),
+    ('UCHAR', 'c_char'),
+    ('FARPROC', 'PVOID'),
+    ('HGLOBAL', 'PVOID'),
+    ('PVECTORED_EXCEPTION_HANDLER', 'PVOID'),
+    #('HRESULT', 'c_long'), # VERY BAD : real HRESULT raise by itself -> way better
+    ('ULONGLONG', 'c_ulonglong'),
+    ('LONGLONG', 'c_longlong'),
+    ('ULONG64', 'c_ulonglong'),
+    ('DWORD64', 'ULONG64'),
+    ('PULONG64', 'POINTER(ULONG64)'),
+    ('PHANDLE', 'POINTER(HANDLE)'),
+    ('HKEY', 'HANDLE'),
+    ('PHKEY', 'POINTER(HKEY)'),
+    ('ACCESS_MASK', 'DWORD'),
+    ('REGSAM', 'ACCESS_MASK'),
+    # Will be changed at import time
+    ('LPCONTEXT', 'PVOID'),
+    ('HCERTSTORE', 'PVOID'),
+    ('HCRYPTMSG', 'PVOID'),
+    ]
+
+# For functions returning void
+TYPE_EQUIVALENCE.append(('VOID', 'DWORD'))
+
+known_type = dummy_wintypes.names + list([x[0] for x in TYPE_EQUIVALENCE])
+
+FUNC_FILE = "winfunc.txt"
+STRUCT_FILE = "winstruct.txt"
+DEF_FILE = "windef.txt"
+
+GENERATED_STRUCT_FILE = "winstructs"
+GENERATED_FUNC_FILE = "winfuncs"
+GENERATED_DEF_FILE = "windef"
+
+OUT_DIRS = ["..\windows\generated_def"]
+if len(sys.argv) > 1:
+    OUT_DIRS.append(sys.argv[1])
+
+def get_all_struct_name(structs, enums):
+    res = []
+    for s in structs + enums:
+        res.append(s.name)
+        res.extend(s.typedef)
+    return res
+
+def generate_type_equiv_code(type_equiv):
+    ctypes_str = ""
+    for type_equiv in type_equiv:
+        ctypes_str += "{0} = {1}\n".format(*type_equiv)
+    ctypes_str += "\n"
+    return ctypes_str
+
+def verif_funcs_type(funcs, structs, enums):
+    all_struct_name = get_all_struct_name(structs, enums)
+    for f in funcs:
+        ret_type = f.return_type
+        if ret_type not in known_type and ret_type not in all_struct_name:
+            import pdb; pdb.set_trace()
+            raise ValueError("UNKNOW RET TYPE {0}".format(ret_type))
+
+        for param_type, _ in f.params:
+            # Crappy but fuck it !
+            if param_type.startswith("POINTER(") and param_type.endswith(")"):
+                param_type = param_type[len("POINTER("): -1]
+            if param_type not in known_type and param_type not in all_struct_name:
+                import pdb; pdb.set_trace()
+                raise ValueError("UNKNOW PARAM TYPE {0}".format(param_type))
+
+def check_in_define(name, defs):
+    return any(name == d.name for d in defs)
+
+def validate_structs(structs, enums, defs):
+    all_struct_name = get_all_struct_name(structs, enums)
+    for struct in structs:
+        for field_type, field_name, nb_rep in struct.fields:
+            if field_type.name not in known_type + all_struct_name:
+                import pdb; pdb.set_trace()
+                raise ValueError("UNKNOW TYPE {0}".format(field_type))
+            try:
+                int(nb_rep)
+            except ValueError:
+                if not check_in_define(nb_rep, defs):
+                    raise ValueError("UNKNOW DEFINE {0}".format(nb_rep))
+
+common_header = "#Generated file\n"
+
+defs_header = common_header + """
+import sys
+if sys.version_info.major == 3:
+    long = int
+
+class Flag(long):
+    def __new__(cls, name, value):
+        return super(Flag, cls).__new__(cls, value)
+
+    def __init__(self, name, value):
+        self.name = name
+
+    def __repr__(self):
+        return "{0}({1})".format(self.name, hex(self))
+
+    __str__ = __repr__
+"""
+
+def generate_defs_ctypes(defs):
+    ctypes_lines = [defs_header] + [d.generate_ctypes() for d in defs]
+    ctypes_code = "\n".join(ctypes_lines)
+    return ctypes_code
+
+
+funcs_header = common_header + """
+from ctypes import *
+from ctypes.wintypes import *
+from .{0} import *
+
+"""[1:].format(GENERATED_STRUCT_FILE)
+
+def generate_funcs_ctypes(funcs):
+    ctypes_code = funcs_header
+
+    all_funcs_name = [f.name for f in funcs]
+    ctypes_code += "functions = {0}\n\n".format(str(all_funcs_name))
+    for func in funcs:
+        ctypes_code += func.generate_ctypes() + "\n"
+    return ctypes_code
+
+structs_header = common_header + """
+from ctypes import *
+from ctypes.wintypes import *
+from .windef import *
+
+"""[1:]
+
+def generate_struct_ctypes(structs, enums):
+    ctypes_str  = structs_header
+    ctypes_str += generate_type_equiv_code(TYPE_EQUIVALENCE)
+
+    all_struct_name = [s.name for s in structs]
+    ctypes_str += "structs = {0}\n\n".format(str(all_struct_name))
+
+    all_enum_name = [e.name for e in enums]
+    ctypes_str += "enums = {0}\n\n".format(str(all_enum_name))
+
+    # Enums declarations
+    for enum in enums:
+        ctypes_str += "# Enum {0} definitions\n".format(enum.name)
+        ctypes_str += enum.generate_ctypes() + "\n"
+
+    # Struct declarations
+    for struct in structs:
+        ctypes_str += "# Struct {0} definitions\n".format(struct.name)
+        ctypes_str += struct.generate_ctypes() + "\n"
+
+    return ctypes_str
+
+def write_to_out_file(name, data):
+    for out_dir in OUT_DIRS:
+        f = open("{0}/{1}.py".format(out_dir, name), 'w')
+        f.write(data)
+        f.close()
+
+def_code  = open(DEF_FILE, 'r').read()
+funcs_code = open(FUNC_FILE, 'r').read()
+structs_code = open(STRUCT_FILE, 'r').read()
+
+defs = def_parser.WinDefParser(def_code).parse()
+funcs = func_parser.WinFuncParser(funcs_code).parse()
+structs, enums = struct_parser.WinStructParser(structs_code).parse()
+
+
+validate_structs(structs, enums, defs)
+verif_funcs_type(funcs, structs, enums)
+
+defs_ctypes = generate_defs_ctypes(defs)
+funcs_ctypes = generate_funcs_ctypes(funcs)
+structs_ctypes = generate_struct_ctypes(structs, enums)
+
+for out_dir in OUT_DIRS:
+    if not os.path.exists(out_dir):
+        os.mkdir(out_dir)
+
+write_to_out_file(GENERATED_DEF_FILE, defs_ctypes)
+write_to_out_file(GENERATED_FUNC_FILE, funcs_ctypes)
+write_to_out_file(GENERATED_STRUCT_FILE, structs_ctypes)
+
+for out_dir in OUT_DIRS:
+    print("Files generated in <{0}>".format(os.path.abspath(out_dir)))
@@ -0,0 +1,211 @@
+import collections
+
+TupleToken = collections.namedtuple('Token', ['value'])
+
+class Token(TupleToken):
+    def __repr__(self):
+        return "{0}(value={1})".format(type(self).__name__, self.value)
+
+TupleNoValueToken = collections.namedtuple('Token', [])
+
+class NoValueToken(TupleNoValueToken):
+    value = None
+    def __repr__(self):
+        return "{0}()".format(type(self).__name__)
+
+class KeywordToken(Token):
+    pass
+
+class TypeToken(Token):
+    pass
+
+class NameToken(Token):
+    pass
+
+class ColonToken(NoValueToken):
+    value = ";"
+    pass
+
+class CommaToken(NoValueToken):
+    value = ","
+    pass
+
+class StarToken(NoValueToken):
+    value = "*"
+    pass
+
+class OpenBracketToken(NoValueToken):
+    value = "{"
+    pass
+
+class CloseBracketToken(NoValueToken):
+    value = "}"
+    pass
+
+class OpenSquareBracketToken(NoValueToken):
+    value = "["
+    pass
+
+class CloseSquareBracketToken(NoValueToken):
+    value = "]"
+    pass
+
+class OpenParenthesisToken(NoValueToken):
+    value = "("
+    pass
+
+class CloseParenthesisToken(NoValueToken):
+    value = ")"
+    pass
+
+class SharpToken(NoValueToken):
+    value = "#"
+    pass
+
+class EqualToken(NoValueToken):
+    value = "="
+    pass
+
+class Lexer(object):
+    keywords = ["typedef", "struct", "enum", "union"]
+
+    token_chr = {"*" : StarToken, "[" : OpenSquareBracketToken, "]" : CloseSquareBracketToken,
+                    "{" : OpenBracketToken, "}" : CloseBracketToken, ";" : ColonToken,
+                    "," : CommaToken, "(" : OpenParenthesisToken, ")" :  CloseParenthesisToken, "#" : SharpToken, "=" : EqualToken}
+
+    def __init__(self, code):
+        self.code = code
+
+    def split_line(self, line):
+        return line.strip().split()
+
+    def is_keyword(self, word):
+        return word in self.keywords
+
+    def split_word(self, word):
+        """Slit a dummy name with all token_chr"""
+        queue = [None, word]
+        for name in iter(queue.pop, None):
+            if name in self.token_chr:
+                yield self.token_chr[name]()
+                continue
+            if not any(spec_chr in name for spec_chr in self.token_chr):
+                yield NameToken(name)
+                continue
+            new_tokens = [name]
+            for spec_chr in self.token_chr:
+                new_tokens = list(new_tokens[0].partition(spec_chr)) + new_tokens[1:]
+            queue.extend(reversed([x for x in new_tokens if x]))
+
+    def __iter__(self):
+        for line in self.code.split("\n"):
+            for word in self.split_line(line):
+                if self.is_keyword(word):
+                    yield KeywordToken(word)
+                    continue
+                for tok in self.split_word(word):
+                    yield tok
+
+
+
+class ParsingError(Exception):
+    pass
+
+class Parser(object):
+
+    def __init__(self, data):
+        self.lexer = iter(Lexer(data))
+        self.peek_token = None
+
+    def assert_keyword(self, expected_keyword, n=None):
+        if n is None:
+            n = self.assert_token_type(KeywordToken)
+        if n.value != expected_keyword:
+            raise ParsingError("Expected Keyword {0} got {1} instead".format(expected_keyword, n.value))
+        return n
+
+    def assert_token_type(self, expected_type, n=None):
+        if n is None:
+            n = self.next_token()
+        if type(n) != expected_type:
+            raise ParsingError("Expected type {0} and got {1} instead".format(expected_type.__name__, n))
+        return n
+
+    def assert_argument_io_info(self):
+        io_info = self.assert_token_type(NameToken)
+        if io_info.value not in self.known_io_info_type:
+            raise ParsingError("Was expection IO_INFO got {0} instead".format(winapi))
+        return io_info
+
+    def promote_to_type(self, token):
+        self.assert_token_type(NameToken, token)
+        return TypeToken(token.value)
+
+    def promote_to_int(self, token):
+        self.assert_token_type(NameToken, token)
+        try:
+            return int(token.value)
+        except ValueError:
+            return int(token.value, 0)
+
+    def next_token(self):
+        if self.peek_token is not None:
+            res = self.peek_token
+            self.peek_token = None
+            return res
+        return next(self.lexer, None)
+
+    def peek(self):
+        if self.peek_token is None:
+            self.peek_token = self.next_token()
+        return self.peek_token
+
+    def parse(self):
+        raise NotImplementedError("Parser.parse()")
+
+
+#KNOWN_TYPE = ["BYTE", "USHORT", "DWORD", "PVOID", "ULONG", "HANDLE", "PWSTR"]
+#
+#def validate_structs(structs):
+#    by_name = dict([(struct.name, struct) for struct in structs])
+#    if len(by_name) != len(structs):
+#        raise ValueError('2 structs with the same name')
+#
+#    for struct in structs:
+#        for name, value in struct.typedef.items():
+#            by_name[name] = value
+#
+#    for struct in structs:
+#        for field_type, field_name, nb_rep in struct.fields:
+#            if field_type.name not in KNOWN_TYPE:
+#                print("non standard type : {0}".format(field_type))
+#                if field_type.name not in by_name:
+#                    print("UNKNOW TYPE {0}".format(field_type))
+#
+#    return structs
+#
+#
+#
+#data = open("winfunc.txt", "r").read()
+#
+#
+#def dbg_lexer(data):
+#    for i in Lexer(data).token_generation():
+#        print i
+#
+#def dbg_parser(data):
+#    return Parser(data).parse()
+#
+#def dbg_validate(data):
+#    return validate_structs(Parser(data).parse())
+#
+#
+#def tst(x):
+#    print("=== TEST FOR <{0}> === ".format(x))
+#    g =  Lexer("").split_word(x)
+#    for i in g:
+#        print (i)
+#
+#x = dbg_parser(data)
+#for i in x:
+#    print i
@@ -0,0 +1,133 @@
+import dummy_wintypes
+import itertools
+from winstruct import WinStruct, WinUnion, WinStructType, Ptr, WinEnum
+from simpleparser import *
+
+class WinStructParser(Parser):
+
+    def parse_array(self, ):
+        self.assert_token_type(OpenSquareBracketToken)
+        number = self.assert_token_type(NameToken).value
+        self.assert_token_type(CloseSquareBracketToken)
+        return number
+
+    def parse_def(self):
+        if self.peek() == KeywordToken("struct"):
+            discard = self.next_token()
+            
+        def_type_tok  = self.assert_token_type(NameToken)
+        def_type = WinStructType(def_type_tok.value)
+        if type(self.peek()) == StarToken:
+            def_type = Ptr(def_type)
+            discard_star = self.next_token()
+
+        def_name = self.assert_token_type(NameToken)
+
+        if type(self.peek()) == ColonToken:
+            self.next_token()
+            return (def_type, def_name, 1)
+        
+        number_rep = self.parse_array()
+        self.assert_token_type(ColonToken)
+        return (def_type, def_name, number_rep)
+
+    def parse_typedef(self, struct):
+        sep = CommaToken()
+        while type(sep) == CommaToken:
+            add_to_typedef = struct.add_typedef
+            if type(self.peek()) == StarToken:
+                self.next_token()
+                add_to_typedef = struct.add_ptr_typedef
+            name = self.assert_token_type(NameToken)
+            # UGLY HACK for LDR definition
+            if name.value == "RESTRICTED_POINTER":
+                name = self.assert_token_type(NameToken)
+            add_to_typedef(name.value)
+            sep = self.next_token()
+        self.assert_token_type(ColonToken, sep)
+
+    def parse_enum(self):
+        """Handle enum typedef with no value assignement and 1 typedef after"""
+        enum_name = self.assert_token_type(NameToken).value
+        res_enum = WinEnum(enum_name)
+        self.assert_token_type(OpenBracketToken)
+        count = itertools.count()
+        assigned_value = False
+        while type(self.peek()) != CloseBracketToken:
+            i = next(count)
+            name = self.assert_token_type(NameToken)
+            if type(self.peek()) == EqualToken:
+                if i != 0 and not assigned_value:
+                    raise ParsingError("Enum {0} mix def with and without equal".format(enum_name))
+                assigned_value = True
+                self.assert_token_type(EqualToken)
+                i = self.promote_to_int(self.next_token())
+            else:
+                if assigned_value:
+                    raise ParsingError("Enum {0} mix def with and without equal".format(enum_name))
+                
+            res_enum.add_enum_entry(i, name.value)
+            if not type(self.peek()) == CloseBracketToken:
+                self.assert_token_type(CommaToken)
+
+        self.assert_token_type(CloseBracketToken)
+        self.parse_typedef(res_enum)
+        #other_name = self.assert_token_type(NameToken).value
+        #res_enum.add_typedef(other_name)
+        #self.assert_token_type(ColonToken)
+        return res_enum    
+        
+        
+        
+    def parse_winstruct(self):
+        self.assert_keyword("typedef")
+        
+        def_type = self.assert_token_type(KeywordToken)
+        if def_type.value == "enum":
+            return self.parse_enum()
+        if def_type.value == "struct":
+            WinDefType = WinStruct
+        elif def_type.value == "union":
+            WinDefType = WinUnion
+        else:
+            raise ParsingError("Expecting union or struct got <{0}> instead".format(def_type.value))
+        struct_name = self.assert_token_type(NameToken)
+        self.assert_token_type(OpenBracketToken)
+    
+        result = WinDefType(struct_name.value)
+
+        while type(self.peek()) != CloseBracketToken:
+            tok_type, tok_name, nb_rep = self.parse_def()
+            result.add_field((tok_type, tok_name.value, nb_rep))
+        self.assert_token_type(CloseBracketToken)
+        self.parse_typedef(result)
+        return result
+
+    def parse(self):
+        strucs = []
+        enums = []
+        while self.peek() is not None:
+            x = self.parse_winstruct()
+            if type(x) == WinStruct or type(x) == WinUnion:
+                strucs.append(x)
+            elif type(x) == WinEnum:
+                enums.append(x)
+            else:
+                raise ValueError("Unknow returned type {0}".format(x))
+        return strucs, enums
+            
+def dbg_lexer(data):
+    for i in Lexer(data).token_generation():
+        print i
+
+def dbg_parser(data):
+    return WinStructParser(data).parse()
+
+def dbg_validate(data):
+    return validate_structs(Parser(data).parse())
+    
+       
+if __name__ == "__main__":
+    import sys
+    data = open(sys.argv[1], 'r').read()
+    ctypes_code = generate_ctypes(data)
@@ -0,0 +1,541 @@
+#define NULL    0
+#define MAX_PATH          260
+#define ANYSIZE_ARRAY 1
+#define ANY_SIZE 1
+#define IMAGE_SIZEOF_SHORT_NAME 8
+#define IMAGE_NUMBEROF_DIRECTORY_ENTRIES    16
+#define INFINITE            0xFFFFFFFF
+
+#define STD_INPUT_HANDLE  -10
+#define STD_OUTPUT_HANDLE -11
+#define STD_ERROR_HANDLE -12
+
+#define WARMING_NOT_SAME_FLAG_FOR_WINXP 0
+#define PROCESS_ALL_ACCESS  0x001F0FFF
+#define THREAD_ALL_ACCESS  0x001F03FF
+
+
+#define STARTF_USESHOWWINDOW    0x00000001
+#define STARTF_USESIZE          0x00000002
+#define STARTF_USEPOSITION      0x00000004
+#define STARTF_USECOUNTCHARS    0x00000008
+#define STARTF_USEFILLATTRIBUTE 0x00000010
+#define STARTF_RUNFULLSCREEN    0x00000020
+#define STARTF_FORCEONFEEDBACK  0x00000040
+#define STARTF_FORCEOFFFEEDBACK 0x00000080
+#define STARTF_USESTDHANDLES    0x00000100
+
+#define SW_HIDE             0
+#define SW_SHOWNORMAL       1
+#define SW_NORMAL           1
+#define SW_SHOWMINIMIZED    2
+#define SW_SHOWMAXIMIZED    3
+#define SW_MAXIMIZE         3
+#define SW_SHOWNOACTIVATE   4
+#define SW_SHOW             5
+#define SW_MINIMIZE         6
+#define SW_SHOWMINNOACTIVE  7
+#define SW_SHOWNA           8
+#define SW_RESTORE          9
+#define SW_SHOWDEFAULT      10
+#define SW_FORCEMINIMIZE    11
+#define SW_MAX              11
+
+
+#define DEBUG_PROCESS                     0x00000001
+#define DEBUG_ONLY_THIS_PROCESS           0x00000002
+#define CREATE_SUSPENDED                  0x00000004
+#define DETACHED_PROCESS                  0x00000008
+
+#define CREATE_NEW_CONSOLE                0x00000010
+#define NORMAL_PRIORITY_CLASS             0x00000020
+#define IDLE_PRIORITY_CLASS               0x00000040
+#define HIGH_PRIORITY_CLASS               0x00000080
+
+#define REALTIME_PRIORITY_CLASS           0x00000100
+#define CREATE_NEW_PROCESS_GROUP          0x00000200
+#define CREATE_UNICODE_ENVIRONMENT        0x00000400
+#define CREATE_SEPARATE_WOW_VDM           0x00000800
+
+#define CREATE_SHARED_WOW_VDM             0x00001000
+#define CREATE_FORCEDOS                   0x00002000
+#define BELOW_NORMAL_PRIORITY_CLASS       0x00004000
+#define ABOVE_NORMAL_PRIORITY_CLASS       0x00008000
+
+#define INHERIT_PARENT_AFFINITY           0x00010000
+#define INHERIT_CALLER_PRIORITY           0x00020000
+#define CREATE_PROTECTED_PROCESS          0x00040000
+#define EXTENDED_STARTUPINFO_PRESENT      0x00080000
+
+#define PROCESS_MODE_BACKGROUND_BEGIN     0x00100000
+#define PROCESS_MODE_BACKGROUND_END       0x00200000
+
+#define CREATE_BREAKAWAY_FROM_JOB         0x01000000
+#define CREATE_PRESERVE_CODE_AUTHZ_LEVEL  0x02000000
+#define CREATE_DEFAULT_ERROR_MODE         0x04000000
+#define CREATE_NO_WINDOW                  0x08000000
+
+#define PROFILE_USER                      0x10000000
+#define PROFILE_KERNEL                    0x20000000
+#define PROFILE_SERVER                    0x40000000
+#define CREATE_IGNORE_SYSTEM_DEFAULT      0x80000000
+
+
+#define STATUS_WAIT_0                    (0x00000000L)
+#define STATUS_ABANDONED_WAIT_0          (0x00000080L)
+#define STATUS_USER_APC                  (0x000000C0L)
+#define STATUS_TIMEOUT                   (0x00000102L)
+#define STATUS_PENDING                   (0x00000103L)
+#define DBG_EXCEPTION_HANDLED            (0x00010001L)
+#define DBG_CONTINUE                     (0x00010002L)
+#define STATUS_SEGMENT_NOTIFICATION      (0x40000005L)
+#define DBG_TERMINATE_THREAD             (0x40010003L)
+#define DBG_TERMINATE_PROCESS            (0x40010004L)
+#define DBG_CONTROL_C                    (0x40010005L)
+#define DBG_PRINTEXCEPTION_C             (0x40010006L)
+#define DBG_RIPEXCEPTION                 (0x40010007L)
+#define DBG_CONTROL_BREAK                (0x40010008L)
+#define DBG_COMMAND_EXCEPTION            (0x40010009L)
+#define STATUS_GUARD_PAGE_VIOLATION      (0x80000001L)
+#define STATUS_DATATYPE_MISALIGNMENT     (0x80000002L)
+#define STATUS_BREAKPOINT                (0x80000003L)
+#define STATUS_SINGLE_STEP               (0x80000004L)
+#define STATUS_LONGJUMP                  (0x80000026L)
+#define STATUS_UNWIND_CONSOLIDATE        (0x80000029L)
+#define DBG_EXCEPTION_NOT_HANDLED        (0x80010001L)
+#define STATUS_ACCESS_VIOLATION          (0xC0000005L)
+#define STATUS_IN_PAGE_ERROR             (0xC0000006L)
+#define STATUS_INVALID_HANDLE            (0xC0000008L)
+#define STATUS_INVALID_PARAMETER         (0xC000000DL)
+#define STATUS_NO_MEMORY                 (0xC0000017L)
+#define STATUS_ILLEGAL_INSTRUCTION       (0xC000001DL)
+#define STATUS_NONCONTINUABLE_EXCEPTION  (0xC0000025L)
+#define STATUS_INVALID_DISPOSITION       (0xC0000026L)
+#define STATUS_ARRAY_BOUNDS_EXCEEDED     (0xC000008CL)
+#define STATUS_FLOAT_DENORMAL_OPERAND    (0xC000008DL)
+#define STATUS_FLOAT_DIVIDE_BY_ZERO      (0xC000008EL)
+#define STATUS_FLOAT_INEXACT_RESULT      (0xC000008FL)
+#define STATUS_FLOAT_INVALID_OPERATION   (0xC0000090L)
+#define STATUS_FLOAT_OVERFLOW            (0xC0000091L)
+#define STATUS_FLOAT_STACK_CHECK         (0xC0000092L)
+#define STATUS_FLOAT_UNDERFLOW           (0xC0000093L)
+#define STATUS_INTEGER_DIVIDE_BY_ZERO    (0xC0000094L)
+#define STATUS_INTEGER_OVERFLOW          (0xC0000095L)
+#define STATUS_PRIVILEGED_INSTRUCTION    (0xC0000096L)
+#define STATUS_STACK_OVERFLOW            (0xC00000FDL)
+#define STATUS_DLL_NOT_FOUND             (0xC0000135L)
+#define STATUS_ORDINAL_NOT_FOUND         (0xC0000138L)
+#define STATUS_ENTRYPOINT_NOT_FOUND      (0xC0000139L)
+#define STATUS_CONTROL_C_EXIT            (0xC000013AL)
+#define STATUS_DLL_INIT_FAILED           (0xC0000142L)
+#define STATUS_FLOAT_MULTIPLE_FAULTS     (0xC00002B4L)
+#define STATUS_FLOAT_MULTIPLE_TRAPS      (0xC00002B5L)
+#define STATUS_REG_NAT_CONSUMPTION       (0xC00002C9L)
+#define STATUS_STACK_BUFFER_OVERRUN      (0xC0000409L)
+#define STATUS_INVALID_CRUNTIME_PARAMETER (0xC0000417L)
+#define STATUS_ASSERTION_FAILURE         (0xC0000420L)
+#define STATUS_POSSIBLE_DEADLOCK        (0xC0000194)
+
+
+#define WAIT_IO_COMPLETION                  STATUS_USER_APC
+#define STILL_ACTIVE                        STATUS_PENDING
+#define EXCEPTION_ACCESS_VIOLATION          STATUS_ACCESS_VIOLATION
+#define EXCEPTION_DATATYPE_MISALIGNMENT     STATUS_DATATYPE_MISALIGNMENT
+#define EXCEPTION_BREAKPOINT                STATUS_BREAKPOINT
+#define EXCEPTION_SINGLE_STEP               STATUS_SINGLE_STEP
+#define EXCEPTION_ARRAY_BOUNDS_EXCEEDED     STATUS_ARRAY_BOUNDS_EXCEEDED
+#define EXCEPTION_FLT_DENORMAL_OPERAND      STATUS_FLOAT_DENORMAL_OPERAND
+#define EXCEPTION_FLT_DIVIDE_BY_ZERO        STATUS_FLOAT_DIVIDE_BY_ZERO
+#define EXCEPTION_FLT_INEXACT_RESULT        STATUS_FLOAT_INEXACT_RESULT
+#define EXCEPTION_FLT_INVALID_OPERATION     STATUS_FLOAT_INVALID_OPERATION
+#define EXCEPTION_FLT_OVERFLOW              STATUS_FLOAT_OVERFLOW
+#define EXCEPTION_FLT_STACK_CHECK           STATUS_FLOAT_STACK_CHECK
+#define EXCEPTION_FLT_UNDERFLOW             STATUS_FLOAT_UNDERFLOW
+#define EXCEPTION_INT_DIVIDE_BY_ZERO        STATUS_INTEGER_DIVIDE_BY_ZERO
+#define EXCEPTION_INT_OVERFLOW              STATUS_INTEGER_OVERFLOW
+#define EXCEPTION_PRIV_INSTRUCTION          STATUS_PRIVILEGED_INSTRUCTION
+#define EXCEPTION_IN_PAGE_ERROR             STATUS_IN_PAGE_ERROR
+#define EXCEPTION_ILLEGAL_INSTRUCTION       STATUS_ILLEGAL_INSTRUCTION
+#define EXCEPTION_NONCONTINUABLE_EXCEPTION  STATUS_NONCONTINUABLE_EXCEPTION
+#define EXCEPTION_STACK_OVERFLOW            STATUS_STACK_OVERFLOW
+#define EXCEPTION_INVALID_DISPOSITION       STATUS_INVALID_DISPOSITION
+#define EXCEPTION_GUARD_PAGE                STATUS_GUARD_PAGE_VIOLATION
+#define EXCEPTION_INVALID_HANDLE            STATUS_INVALID_HANDLE
+#define EXCEPTION_POSSIBLE_DEADLOCK         STATUS_POSSIBLE_DEADLOCK
+#define CONTROL_C_EXIT                      STATUS_CONTROL_C_EXIT
+
+#define EXCEPTION_DEBUG_EVENT       1
+#define CREATE_THREAD_DEBUG_EVENT   2
+#define CREATE_PROCESS_DEBUG_EVENT  3
+#define EXIT_THREAD_DEBUG_EVENT     4
+#define EXIT_PROCESS_DEBUG_EVENT    5
+#define LOAD_DLL_DEBUG_EVENT        6
+#define UNLOAD_DLL_DEBUG_EVENT      7
+#define OUTPUT_DEBUG_STRING_EVENT   8
+#define RIP_EVENT                   9
+
+
+#define TH32CS_SNAPHEAPLIST 0x00000001
+#define TH32CS_SNAPPROCESS  0x00000002
+#define TH32CS_SNAPTHREAD   0x00000004
+#define TH32CS_SNAPMODULE   0x00000008
+#define TH32CS_SNAPMODULE32 0x00000010
+#define TH32CS_SNAPALL      (TH32CS_SNAPHEAPLIST | TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD | TH32CS_SNAPMODULE)
+#define TH32CS_INHERIT      0x80000000
+
+#define CONTEXT_I386    0x00010000
+
+#define CONTEXT_CONTROL             0x00000001L
+#define CONTEXT_INTEGER             0x00000002L
+#define CONTEXT_SEGMENTS            0x00000004L
+#define CONTEXT_FLOATING_POINT      0x00000008L
+#define CONTEXT_DEBUG_REGISTERS     0x00000010L
+#define CONTEXT_EXTENDED_REGISTERS  0x00000020L
+#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS)
+#define CONTEXT_ALL (CONTEXT_FULL | CONTEXT_FLOATING_POINT | CONTEXT_DEBUG_REGISTERS | CONTEXT_EXTENDED_REGISTERS)
+
+#define CONTEXT_FULL CONTEXT_I386 | CONTEXT_FULL
+#define CONTEXT_ALL  CONTEXT_I386 | CONTEXT_ALL
+
+
+#define PAGE_NOACCESS          0x01
+#define PAGE_READONLY          0x02
+#define PAGE_READWRITE         0x04
+#define PAGE_WRITECOPY         0x08
+#define PAGE_EXECUTE           0x10
+#define PAGE_EXECUTE_READ      0x20
+#define PAGE_EXECUTE_READWRITE 0x40
+#define PAGE_EXECUTE_WRITECOPY 0x80
+#define PAGE_GUARD            0x100
+#define PAGE_NOCACHE          0x200
+#define PAGE_WRITECOMBINE     0x400
+#define MEM_COMMIT           0x1000
+#define MEM_RESERVE          0x2000
+#define MEM_DECOMMIT         0x4000
+#define MEM_RELEASE          0x8000
+#define MEM_FREE            0x10000
+#define MEM_PRIVATE         0x20000
+#define MEM_MAPPED          0x40000
+#define MEM_RESET           0x80000
+#define MEM_TOP_DOWN       0x100000
+#define MEM_WRITE_WATCH    0x200000
+#define MEM_PHYSICAL       0x400000
+#define MEM_ROTATE         0x800000
+#define MEM_LARGE_PAGES  0x20000000
+#define MEM_4MB_PAGES    0x80000000
+
+#define SEC_FILE           0x800000
+#define SEC_IMAGE         0x1000000
+#define SEC_PROTECTED_IMAGE  0x2000000
+#define SEC_RESERVE       0x4000000
+#define SEC_COMMIT        0x8000000
+#define SEC_NOCACHE      0x10000000
+#define SEC_WRITECOMBINE 0x40000000
+#define SEC_LARGE_PAGES  0x80000000
+#define MEM_IMAGE         SEC_IMAGE
+#define WRITE_WATCH_FLAG_RESET 0x01
+
+#define DELETE                           (0x00010000L)
+#define READ_CONTROL                     (0x00020000L)
+#define WRITE_DAC                        (0x00040000L)
+#define WRITE_OWNER                      (0x00080000L)
+#define SYNCHRONIZE                      (0x00100000L)
+#define STANDARD_RIGHTS_REQUIRED         (0x000F0000L)
+#define STANDARD_RIGHTS_READ             (READ_CONTROL)
+#define STANDARD_RIGHTS_WRITE            (READ_CONTROL)
+#define STANDARD_RIGHTS_EXECUTE          (READ_CONTROL)
+
+#define STANDARD_RIGHTS_ALL              (0x001F0000L)
+
+#define SPECIFIC_RIGHTS_ALL              (0x0000FFFFL)
+
+#define TOKEN_ASSIGN_PRIMARY    (0x0001)
+#define TOKEN_DUPLICATE         (0x0002)
+#define TOKEN_IMPERSONATE       (0x0004)
+#define TOKEN_QUERY             (0x0008)
+#define TOKEN_QUERY_SOURCE      (0x0010)
+#define TOKEN_ADJUST_PRIVILEGES (0x0020)
+#define TOKEN_ADJUST_GROUPS     (0x0040)
+#define TOKEN_ADJUST_DEFAULT    (0x0080)
+#define TOKEN_ADJUST_SESSIONID  (0x0100)
+
+#define TOKEN_ALL_ACCESS_P (STANDARD_RIGHTS_REQUIRED | TOKEN_ASSIGN_PRIMARY | TOKEN_DUPLICATE | TOKEN_IMPERSONATE | TOKEN_QUERY | TOKEN_QUERY_SOURCE | TOKEN_ADJUST_PRIVILEGES | TOKEN_ADJUST_GROUPS | TOKEN_ADJUST_DEFAULT)
+
+
+#define TOKEN_ALL_ACCESS  (TOKEN_ALL_ACCESS_P | TOKEN_ADJUST_SESSIONID )
+
+#define SE_PRIVILEGE_ENABLED_BY_DEFAULT (0x00000001L)
+#define SE_PRIVILEGE_ENABLED            (0x00000002L)
+#define SE_PRIVILEGE_REMOVED            (0X00000004L)
+#define SE_PRIVILEGE_USED_FOR_ACCESS    (0x80000000L)
+
+
+#define AF_UNSPEC       0
+#define AF_UNIX         1
+#define AF_INET         2
+#define AF_IMPLINK      3
+#define AF_PUP          4
+#define AF_CHAOS        5
+#define AF_NS           6
+#define AF_IPX          AF_NS
+#define AF_ISO          7
+#define AF_OSI          AF_ISO
+#define AF_ECMA         8
+#define AF_DATAKIT      9
+#define AF_CCITT        10
+#define AF_SNA          11
+#define AF_DECnet       12
+#define AF_DLI          13
+#define AF_LAT          14
+#define AF_HYLINK       15
+#define AF_APPLETALK    16
+#define AF_NETBIOS      17
+#define AF_VOICEVIEW    18
+#define AF_FIREFOX      19
+#define AF_UNKNOWN1     20
+#define AF_BAN          21
+#define AF_ATM          22
+#define AF_INET6        23
+#define AF_CLUSTER      24
+#define AF_12844        25
+#define AF_IRDA         26
+#define AF_NETDES       28
+
+
+#define EXCEPTION_NONCONTINUABLE 0x1
+#define EXCEPTION_MAXIMUM_PARAMETERS 15
+
+
+#define STATUS_WAIT_0                    (0x00000000)
+#define STATUS_ABANDONED_WAIT_0          (0x00000080)
+#define STATUS_USER_APC                  (0x000000C0)
+#define STATUS_TIMEOUT                   (0x00000102)
+#define STATUS_PENDING                   (0x00000103)
+#define DBG_EXCEPTION_HANDLED            (0x00010001)
+#define DBG_CONTINUE                     (0x00010002)
+#define STATUS_SEGMENT_NOTIFICATION      (0x40000005)
+#define DBG_TERMINATE_THREAD             (0x40010003)
+#define DBG_TERMINATE_PROCESS            (0x40010004)
+#define DBG_CONTROL_C                    (0x40010005)
+#define DBG_PRINTEXCEPTION_C             (0x40010006)
+#define DBG_RIPEXCEPTION                 (0x40010007)
+#define DBG_CONTROL_BREAK                (0x40010008)
+#define DBG_COMMAND_EXCEPTION            (0x40010009)
+#define STATUS_GUARD_PAGE_VIOLATION      (0x80000001)
+#define STATUS_DATATYPE_MISALIGNMENT     (0x80000002)
+#define STATUS_BREAKPOINT                (0x80000003)
+#define STATUS_SINGLE_STEP               (0x80000004)
+#define STATUS_LONGJUMP                  (0x80000026)
+#define STATUS_UNWIND_CONSOLIDATE        (0x80000029)
+#define DBG_EXCEPTION_NOT_HANDLED        (0x80010001)
+#define STATUS_ACCESS_VIOLATION          (0xC0000005)
+#define STATUS_IN_PAGE_ERROR             (0xC0000006)
+#define STATUS_INVALID_HANDLE            (0xC0000008)
+#define STATUS_INVALID_PARAMETER         (0xC000000D)
+#define STATUS_NO_MEMORY                 (0xC0000017)
+#define STATUS_ILLEGAL_INSTRUCTION       (0xC000001D)
+#define STATUS_NONCONTINUABLE_EXCEPTION  (0xC0000025)
+#define STATUS_INVALID_DISPOSITION       (0xC0000026)
+#define STATUS_ARRAY_BOUNDS_EXCEEDED     (0xC000008C)
+#define STATUS_FLOAT_DENORMAL_OPERAND    (0xC000008D)
+#define STATUS_FLOAT_DIVIDE_BY_ZERO      (0xC000008E)
+#define STATUS_FLOAT_INEXACT_RESULT      (0xC000008F)
+#define STATUS_FLOAT_INVALID_OPERATION   (0xC0000090)
+#define STATUS_FLOAT_OVERFLOW            (0xC0000091)
+#define STATUS_FLOAT_STACK_CHECK         (0xC0000092)
+#define STATUS_FLOAT_UNDERFLOW           (0xC0000093)
+#define STATUS_INTEGER_DIVIDE_BY_ZERO    (0xC0000094)
+#define STATUS_INTEGER_OVERFLOW          (0xC0000095)
+#define STATUS_PRIVILEGED_INSTRUCTION    (0xC0000096)
+#define STATUS_STACK_OVERFLOW            (0xC00000FD)
+#define STATUS_DLL_NOT_FOUND             (0xC0000135)
+#define STATUS_ORDINAL_NOT_FOUND         (0xC0000138)
+#define STATUS_ENTRYPOINT_NOT_FOUND      (0xC0000139)
+#define STATUS_CONTROL_C_EXIT            (0xC000013A)
+#define STATUS_DLL_INIT_FAILED           (0xC0000142)
+#define STATUS_FLOAT_MULTIPLE_FAULTS     (0xC00002B4)
+#define STATUS_FLOAT_MULTIPLE_TRAPS      (0xC00002B5)
+#define STATUS_REG_NAT_CONSUMPTION       (0xC00002C9)
+#define STATUS_STACK_BUFFER_OVERRUN      (0xC0000409)
+#define STATUS_INVALID_CRUNTIME_PARAMETER (0xC0000417)
+#define STATUS_ASSERTION_FAILURE         (0xC0000420)
+
+
+#define WAIT_IO_COMPLETION                  STATUS_USER_APC
+#define STILL_ACTIVE                        STATUS_PENDING
+#define EXCEPTION_ACCESS_VIOLATION          STATUS_ACCESS_VIOLATION
+#define EXCEPTION_DATATYPE_MISALIGNMENT     STATUS_DATATYPE_MISALIGNMENT
+#define EXCEPTION_BREAKPOINT                STATUS_BREAKPOINT
+#define EXCEPTION_SINGLE_STEP               STATUS_SINGLE_STEP
+#define EXCEPTION_ARRAY_BOUNDS_EXCEEDED     STATUS_ARRAY_BOUNDS_EXCEEDED
+#define EXCEPTION_FLT_DENORMAL_OPERAND      STATUS_FLOAT_DENORMAL_OPERAND
+#define EXCEPTION_FLT_DIVIDE_BY_ZERO        STATUS_FLOAT_DIVIDE_BY_ZERO
+#define EXCEPTION_FLT_INEXACT_RESULT        STATUS_FLOAT_INEXACT_RESULT
+#define EXCEPTION_FLT_INVALID_OPERATION     STATUS_FLOAT_INVALID_OPERATION
+#define EXCEPTION_FLT_OVERFLOW              STATUS_FLOAT_OVERFLOW
+#define EXCEPTION_FLT_STACK_CHECK           STATUS_FLOAT_STACK_CHECK
+#define EXCEPTION_FLT_UNDERFLOW             STATUS_FLOAT_UNDERFLOW
+#define EXCEPTION_INT_DIVIDE_BY_ZERO        STATUS_INTEGER_DIVIDE_BY_ZERO
+#define EXCEPTION_INT_OVERFLOW              STATUS_INTEGER_OVERFLOW
+#define EXCEPTION_PRIV_INSTRUCTION          STATUS_PRIVILEGED_INSTRUCTION
+#define EXCEPTION_IN_PAGE_ERROR             STATUS_IN_PAGE_ERROR
+#define EXCEPTION_ILLEGAL_INSTRUCTION       STATUS_ILLEGAL_INSTRUCTION
+#define EXCEPTION_NONCONTINUABLE_EXCEPTION  STATUS_NONCONTINUABLE_EXCEPTION
+#define EXCEPTION_STACK_OVERFLOW            STATUS_STACK_OVERFLOW
+#define EXCEPTION_INVALID_DISPOSITION       STATUS_INVALID_DISPOSITION
+#define EXCEPTION_GUARD_PAGE                STATUS_GUARD_PAGE_VIOLATION
+#define EXCEPTION_INVALID_HANDLE            STATUS_INVALID_HANDLE
+#define EXCEPTION_POSSIBLE_DEADLOCK         STATUS_POSSIBLE_DEADLOCK
+#define CONTROL_C_EXIT                      STATUS_CONTROL_C_EXIT
+
+
+#define EXCEPTION_EXECUTE_HANDLER       1
+#define EXCEPTION_CONTINUE_SEARCH       0
+#define EXCEPTION_CONTINUE_EXECUTION    -1
+
+
+#define GENERIC_READ                     (0x80000000)
+#define GENERIC_WRITE                    (0x40000000)
+#define GENERIC_EXECUTE                  (0x20000000)
+#define GENERIC_ALL                      (0x10000000)
+
+#define FILE_FLAG_WRITE_THROUGH         0x80000000
+#define FILE_FLAG_OVERLAPPED            0x40000000
+#define FILE_FLAG_NO_BUFFERING          0x20000000
+#define FILE_FLAG_RANDOM_ACCESS         0x10000000
+#define FILE_FLAG_SEQUENTIAL_SCAN       0x08000000
+#define FILE_FLAG_DELETE_ON_CLOSE       0x04000000
+#define FILE_FLAG_BACKUP_SEMANTICS      0x02000000
+#define FILE_FLAG_POSIX_SEMANTICS       0x01000000
+#define FILE_FLAG_OPEN_REPARSE_POINT    0x00200000
+#define FILE_FLAG_OPEN_NO_RECALL        0x00100000
+#define FILE_FLAG_FIRST_PIPE_INSTANCE   0x00080000
+
+#define CREATE_NEW          1
+#define CREATE_ALWAYS       2
+#define OPEN_EXISTING       3
+#define OPEN_ALWAYS         4
+#define TRUNCATE_EXISTING   5
+
+
+#define FILE_SHARE_READ                 0x00000001
+#define FILE_SHARE_WRITE                0x00000002
+#define FILE_SHARE_DELETE               0x00000004
+#define FILE_ATTRIBUTE_READONLY             0x00000001
+#define FILE_ATTRIBUTE_HIDDEN               0x00000002
+#define FILE_ATTRIBUTE_SYSTEM               0x00000004
+#define FILE_ATTRIBUTE_DIRECTORY            0x00000010
+#define FILE_ATTRIBUTE_ARCHIVE              0x00000020
+#define FILE_ATTRIBUTE_DEVICE               0x00000040
+#define FILE_ATTRIBUTE_NORMAL               0x00000080
+#define FILE_ATTRIBUTE_TEMPORARY            0x00000100
+#define FILE_ATTRIBUTE_SPARSE_FILE          0x00000200
+#define FILE_ATTRIBUTE_REPARSE_POINT        0x00000400
+#define FILE_ATTRIBUTE_COMPRESSED           0x00000800
+#define FILE_ATTRIBUTE_OFFLINE              0x00001000
+#define FILE_ATTRIBUTE_NOT_CONTENT_INDEXED  0x00002000
+#define FILE_ATTRIBUTE_ENCRYPTED            0x00004000
+#define FILE_ATTRIBUTE_VIRTUAL              0x00010000
+#define FILE_NOTIFY_CHANGE_FILE_NAME    0x00000001
+#define FILE_NOTIFY_CHANGE_DIR_NAME     0x00000002
+#define FILE_NOTIFY_CHANGE_ATTRIBUTES   0x00000004
+#define FILE_NOTIFY_CHANGE_SIZE         0x00000008
+#define FILE_NOTIFY_CHANGE_LAST_WRITE   0x00000010
+#define FILE_NOTIFY_CHANGE_LAST_ACCESS  0x00000020
+#define FILE_NOTIFY_CHANGE_CREATION     0x00000040
+#define FILE_NOTIFY_CHANGE_SECURITY     0x00000100
+#define FILE_ACTION_ADDED                   0x00000001
+#define FILE_ACTION_REMOVED                 0x00000002
+#define FILE_ACTION_MODIFIED                0x00000003
+#define FILE_ACTION_RENAMED_OLD_NAME        0x00000004
+#define FILE_ACTION_RENAMED_NEW_NAME        0x00000005
+#define MAILSLOT_NO_MESSAGE             (-1)
+#define MAILSLOT_WAIT_FOREVER           (-1)
+#define FILE_CASE_SENSITIVE_SEARCH          0x00000001
+#define FILE_CASE_PRESERVED_NAMES           0x00000002
+#define FILE_UNICODE_ON_DISK                0x00000004
+#define FILE_PERSISTENT_ACLS                0x00000008
+#define FILE_FILE_COMPRESSION               0x00000010
+#define FILE_VOLUME_QUOTAS                  0x00000020
+#define FILE_SUPPORTS_SPARSE_FILES          0x00000040
+#define FILE_SUPPORTS_REPARSE_POINTS        0x00000080
+#define FILE_SUPPORTS_REMOTE_STORAGE        0x00000100
+#define FILE_VOLUME_IS_COMPRESSED           0x00008000
+#define FILE_SUPPORTS_OBJECT_IDS            0x00010000
+#define FILE_SUPPORTS_ENCRYPTION            0x00020000
+#define FILE_NAMED_STREAMS                  0x00040000
+#define FILE_READ_ONLY_VOLUME               0x00080000
+#define FILE_SEQUENTIAL_WRITE_ONCE          0x00100000
+#define FILE_SUPPORTS_TRANSACTIONS          0x00200000
+#define FILE_SUPPORTS_HARD_LINKS            0x00400000
+#define FILE_SUPPORTS_EXTENDED_ATTRIBUTES   0x00800000
+#define FILE_SUPPORTS_OPEN_BY_FILE_ID       0x01000000
+#define FILE_SUPPORTS_USN_JOURNAL           0x02000000
+
+
+#define HKEY_CLASSES_ROOT                   (0x80000000)
+#define HKEY_CURRENT_USER                   (0x80000001)
+#define HKEY_LOCAL_MACHINE                  (0x80000002)
+#define HKEY_USERS                          (0x80000003)
+#define HKEY_PERFORMANCE_DATA               (0x80000004)
+#define HKEY_PERFORMANCE_TEXT               (0x80000050)
+#define HKEY_PERFORMANCE_NLSTEXT            (0x80000060)
+
+
+#define RRF_RT_REG_NONE        0x00000001
+#define RRF_RT_REG_SZ          0x00000002
+#define RRF_RT_REG_EXPAND_SZ   0x00000004
+#define RRF_RT_REG_BINARY      0x00000008
+#define RRF_RT_REG_DWORD       0x00000010
+#define RRF_RT_REG_MULTI_SZ    0x00000020
+#define RRF_RT_REG_QWORD       0x00000040
+#define RRF_RT_DWORD           (RRF_RT_REG_BINARY | RRF_RT_REG_DWORD)
+#define RRF_RT_QWORD           (RRF_RT_REG_BINARY | RRF_RT_REG_QWORD)
+#define RRF_RT_ANY             0x0000ffff
+#define RRF_NOEXPAND           0x10000000
+#define RRF_ZEROONFAILURE      0x20000000
+
+
+#define KEY_QUERY_VALUE         (0x0001)
+#define KEY_SET_VALUE           (0x0002)
+#define KEY_CREATE_SUB_KEY      (0x0004)
+#define KEY_ENUMERATE_SUB_KEYS  (0x0008)
+#define KEY_NOTIFY              (0x0010)
+#define KEY_CREATE_LINK         (0x0020)
+#define KEY_WOW64_32KEY         (0x0200)
+#define KEY_WOW64_64KEY         (0x0100)
+#define KEY_WOW64_RES           (0x0300)
+
+
+#define KEY_READ                ((STANDARD_RIGHTS_READ|KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS|KEY_NOTIFY)&(~SYNCHRONIZE))
+#define KEY_WRITE               ((STANDARD_RIGHTS_WRITE|KEY_SET_VALUE|KEY_CREATE_SUB_KEY)&(~SYNCHRONIZE))
+#define KEY_EXECUTE             ((KEY_READ)&(~SYNCHRONIZE))
+#define KEY_ALL_ACCESS          ((STANDARD_RIGHTS_ALL|KEY_QUERY_VALUE|KEY_SET_VALUE|KEY_CREATE_SUB_KEY|KEY_ENUMERATE_SUB_KEYS|KEY_NOTIFY|KEY_CREATE_LINK)&(~SYNCHRONIZE))
+
+#define STATUS_INFO_LENGTH_MISMATCH      (0xC0000004L)
+
+#define ERROR_NOT_ALL_ASSIGNED           1300
+
+
+#define S_OK                     0
+#define S_FALSE                  1
+#define E_NOINTERFACE            0x80004002
+#define E_FAIL                   0x80004005
+
+
+#define DEBUG_EVENT_BREAKPOINT              0x00000001
+#define DEBUG_EVENT_EXCEPTION               0x00000002
+#define DEBUG_EVENT_CREATE_THREAD           0x00000004
+#define DEBUG_EVENT_EXIT_THREAD             0x00000008
+#define DEBUG_EVENT_CREATE_PROCESS          0x00000010
+#define DEBUG_EVENT_EXIT_PROCESS            0x00000020
+#define DEBUG_EVENT_LOAD_MODULE             0x00000040
+#define DEBUG_EVENT_UNLOAD_MODULE           0x00000080
+#define DEBUG_EVENT_SYSTEM_ERROR            0x00000100
+#define DEBUG_EVENT_SESSION_STATUS          0x00000200
+#define DEBUG_EVENT_CHANGE_DEBUGGEE_STATE   0x00000400
+#define DEBUG_EVENT_CHANGE_ENGINE_STATE     0x00000800
+#define DEBUG_EVENT_CHANGE_SYMBOL_STATE     0x00001000
+
+#define WOW64_MAXIMUM_SUPPORTED_EXTENSION     512
+#define WOW64_SIZE_OF_80387_REGISTERS      80
@@ -0,0 +1,650 @@
+VOID WINAPI ExitProcess(
+  _In_  UINT uExitCode
+);
+
+BOOL WINAPI TerminateProcess(
+  _In_ HANDLE hProcess,
+  _In_ UINT   uExitCode
+);
+
+DWORD WINAPI GetLastError();
+
+HANDLE WINAPI GetCurrentProcess();
+
+HANDLE WINAPI CreateFileA(
+    __in     LPCSTR lpFileName,
+    __in     DWORD dwDesiredAccess,
+    __in     DWORD dwShareMode,
+    __in_opt LPSECURITY_ATTRIBUTES lpSecurityAttributes,
+    __in     DWORD dwCreationDisposition,
+    __in     DWORD dwFlagsAndAttributes,
+    __in_opt HANDLE hTemplateFile
+    );
+
+HANDLE WINAPI CreateFileW(
+    __in     LPCWSTR lpFileName,
+    __in     DWORD dwDesiredAccess,
+    __in     DWORD dwShareMode,
+    __in_opt LPSECURITY_ATTRIBUTES lpSecurityAttributes,
+    __in     DWORD dwCreationDisposition,
+    __in     DWORD dwFlagsAndAttributes,
+    __in_opt HANDLE hTemplateFile
+    );
+
+
+NTSTATUS WINAPI NtQuerySystemInformation(
+  _In_       SYSTEM_INFORMATION_CLASS SystemInformationClass,
+  _Inout_    PVOID SystemInformation,
+  _In_       ULONG SystemInformationLength,
+  _Out_opt_  PULONG ReturnLength
+);
+
+NTSTATUS WINAPI NtQueryInformationProcess(
+  _In_      HANDLE           ProcessHandle,
+  _In_      PROCESSINFOCLASS ProcessInformationClass,
+  _Out_     PVOID            ProcessInformation,
+  _In_      ULONG            ProcessInformationLength,
+  _Out_opt_ PULONG           ReturnLength
+);
+
+NTSTATUS WINAPI NtQueryVirtualMemory(
+  _In_      HANDLE                   ProcessHandle,
+  _In_opt_  PVOID                    BaseAddress,
+  _In_      MEMORY_INFORMATION_CLASS MemoryInformationClass,
+  _Out_     PVOID                    MemoryInformation,
+  _In_      SIZE_T                   MemoryInformationLength,
+  _Out_opt_ PSIZE_T                  ReturnLength
+);
+
+NTSTATUS NtCreateThreadEx(
+        PHANDLE                 ThreadHandle,
+        ACCESS_MASK             DesiredAccess,
+        LPVOID                  ObjectAttributes,
+        HANDLE                  ProcessHandle,
+        LPTHREAD_START_ROUTINE  lpStartAddress,
+        LPVOID                  lpParameter,
+        BOOL                    CreateSuspended,
+        DWORD                   dwStackSize,
+        DWORD                   Unknown1,
+        DWORD                   Unknown2,
+        LPVOID                  Unknown3
+);
+
+NTSTATUS WINAPI NtQueryInformationThread (
+    _In_ HANDLE ThreadHandle,
+    _In_ THREAD_INFORMATION_CLASS ThreadInformationClass,
+    _Out_ PVOID ThreadInformation,
+    _In_ ULONG ThreadInformationLength,
+    _Out_ PULONG ReturnLength
+);
+
+BOOL WINAPI GetExitCodeThread(
+    _In_  HANDLE hThread,
+    _Out_ LPDWORD lpExitCode
+);
+
+BOOL WINAPI GetExitCodeProcess(
+    __in  HANDLE hProcess,
+    __out LPDWORD lpExitCode
+);
+
+LPVOID WINAPI VirtualAlloc(
+  _In_opt_  LPVOID lpAddress,
+  _In_      SIZE_T dwSize,
+  _In_      DWORD flAllocationType,
+  _In_      DWORD flProtect
+);
+
+LPVOID WINAPI VirtualAllocEx(
+  _In_      HANDLE hProcess,
+  _In_opt_  LPVOID lpAddress,
+  _In_      SIZE_T dwSize,
+  _In_      DWORD flAllocationType,
+  _In_      DWORD flProtect
+);
+
+BOOL WINAPI VirtualFree(
+  _In_ LPVOID lpAddress,
+  _In_ SIZE_T dwSize,
+  _In_ DWORD  dwFreeType
+);
+
+BOOL WINAPI VirtualFreeEx(
+  _In_ HANDLE hProcess,
+  _In_ LPVOID lpAddress,
+  _In_ SIZE_T dwSize,
+  _In_ DWORD  dwFreeType
+);
+
+BOOL WINAPI VirtualProtect(
+  _In_   LPVOID lpAddress,
+  _In_   SIZE_T dwSize,
+  _In_   DWORD flNewProtect,
+  _Out_  PDWORD lpflOldProtect
+);
+
+DWORD VirtualQuery(
+  LPCVOID lpAddress,
+  PMEMORY_BASIC_INFORMATION lpBuffer,
+  DWORD dwLength
+);
+
+SIZE_T WINAPI VirtualQueryEx(
+    _In_     HANDLE hProcess,
+    _In_opt_ LPCVOID lpAddress,
+    _Out_ PMEMORY_BASIC_INFORMATION lpBuffer,
+    _In_     SIZE_T dwLength
+    );
+
+
+DWORD WINAPI GetModuleFileNameA(
+  _In_opt_  HMODULE hModule,
+  _Out_     LPSTR lpFilename,
+  _In_      DWORD nSize
+);
+
+DWORD WINAPI GetModuleFileNameW(
+  _In_opt_  HMODULE hModule,
+  _Out_     LPWSTR lpFilename,
+  _In_      DWORD nSize
+);
+
+HANDLE WINAPI CreateThread(
+  _In_opt_   LPSECURITY_ATTRIBUTES lpThreadAttributes,
+  _In_       SIZE_T dwStackSize,
+  _In_       LPTHREAD_START_ROUTINE lpStartAddress,
+  _In_opt_   LPVOID lpParameter,
+  _In_       DWORD dwCreationFlags,
+  _Out_opt_  LPDWORD lpThreadId
+);
+
+HANDLE WINAPI CreateRemoteThread(
+  _In_   HANDLE hProcess,
+  _In_   LPSECURITY_ATTRIBUTES lpThreadAttributes,
+  _In_   SIZE_T dwStackSize,
+  _In_   LPTHREAD_START_ROUTINE lpStartAddress,
+  _In_   LPVOID lpParameter,
+  _In_   DWORD dwCreationFlags,
+  _Out_  LPDWORD lpThreadId
+);
+
+BOOL WINAPI VirtualProtect(
+  _In_   LPVOID lpAddress,
+  _In_   SIZE_T dwSize,
+  _In_   DWORD flNewProtect,
+  _Out_  PDWORD lpflOldProtect
+);
+
+BOOL WINAPI CreateProcessA(
+    __in_opt    LPCSTR lpApplicationName,
+    __inout_opt LPSTR lpCommandLine,
+    __in_opt    LPSECURITY_ATTRIBUTES lpProcessAttributes,
+    __in_opt    LPSECURITY_ATTRIBUTES lpThreadAttributes,
+    __in        BOOL bInheritHandles,
+    __in        DWORD dwCreationFlags,
+    __in_opt    LPVOID lpEnvironment,
+    __in_opt    LPCSTR lpCurrentDirectory,
+    __in        LPSTARTUPINFOA lpStartupInfo,
+    __out       LPPROCESS_INFORMATION lpProcessInformation
+);
+
+BOOL WINAPI CreateProcessW(
+    __in_opt    LPCWSTR lpApplicationName,
+    __inout_opt LPWSTR lpCommandLine,
+    __in_opt    LPSECURITY_ATTRIBUTES lpProcessAttributes,
+    __in_opt    LPSECURITY_ATTRIBUTES lpThreadAttributes,
+    __in        BOOL bInheritHandles,
+    __in        DWORD dwCreationFlags,
+    __in_opt    LPVOID lpEnvironment,
+    __in_opt    LPCWSTR lpCurrentDirectory,
+    __in        LPSTARTUPINFOW lpStartupInfo,
+    __out       LPPROCESS_INFORMATION lpProcessInformation
+);
+
+BOOL WINAPI GetThreadContext(
+    __in    HANDLE hThread,
+    __inout LPCONTEXT lpContext
+);
+
+BOOL WINAPI NtGetContextThread(
+    __in    HANDLE hThread,
+    __inout LPCONTEXT lpContext
+);
+
+BOOL WINAPI SetThreadContext(
+    __in HANDLE hThread,
+    __in CONST LPCONTEXT lpContext
+);
+
+HANDLE WINAPI OpenThread(
+    __in DWORD dwDesiredAccess,
+    __in BOOL bInheritHandle,
+    __in DWORD dwThreadId
+);
+
+HANDLE WINAPI OpenProcess(
+    __in DWORD dwDesiredAccess,
+    __in BOOL bInheritHandle,
+    __in DWORD dwProcessId
+);
+
+BOOL WINAPI CloseHandle(
+    __in HANDLE hObject
+);
+
+BOOL WINAPI ReadProcessMemory(
+  _In_   HANDLE hProcess,
+  _In_   LPCVOID lpBaseAddress,
+  _Out_  LPVOID lpBuffer,
+  _In_   SIZE_T nSize,
+  _Out_  SIZE_T *lpNumberOfBytesRead
+);
+
+BOOL WINAPI NtWow64ReadVirtualMemory64(
+  _In_   HANDLE hProcess,
+  _In_   ULONG64 lpBaseAddress,
+  _Out_  LPVOID lpBuffer,
+  _In_   ULONG64 nSize,
+  _Out_  PULONG64 *lpNumberOfBytesRead
+);
+
+BOOL WINAPI WriteProcessMemory(
+  _In_   HANDLE hProcess,
+  _In_   LPVOID lpBaseAddress,
+  _In_   LPCVOID lpBuffer,
+  _In_   SIZE_T nSize,
+  _Out_  SIZE_T *lpNumberOfBytesWritten
+);
+
+HANDLE WINAPI CreateToolhelp32Snapshot(
+  _In_  DWORD dwFlags,
+  _In_  DWORD th32ProcessID
+);
+
+BOOL WINAPI Thread32First(
+  _In_     HANDLE hSnapshot,
+  _Inout_  LPTHREADENTRY32 lpte
+);
+
+BOOL WINAPI Thread32Next(
+  _In_   HANDLE hSnapshot,
+  _Out_  LPTHREADENTRY32 lpte
+);
+
+BOOL WINAPI Process32First(
+  _In_     HANDLE hSnapshot,
+  _Inout_  LPPROCESSENTRY32 lppe
+);
+
+BOOL WINAPI Process32Next(
+  _In_   HANDLE hSnapshot,
+  _Out_  LPPROCESSENTRY32 lppe
+);
+
+BOOL Process32FirstW(
+    HANDLE hSnapshot,
+    LPPROCESSENTRY32W lppe
+);
+
+BOOL Process32NextW(
+    HANDLE hSnapshot,
+    LPPROCESSENTRY32W lppe
+);
+
+FARPROC WINAPI GetProcAddress(
+  _In_  HMODULE hModule,
+  _In_  LPCSTR lpProcName
+);
+
+
+HMODULE WINAPI LoadLibraryA(
+    __in LPCSTR lpFileName
+);
+
+HMODULE WINAPI LoadLibraryW(
+    __in LPCWSTR lpFileName
+);
+
+BOOL WINAPI OpenProcessToken(
+  _In_   HANDLE ProcessHandle,
+  _In_   DWORD DesiredAccess,
+  _Out_  PHANDLE TokenHandle
+);
+
+BOOL WINAPI LookupPrivilegeValueA(
+    __in_opt LPCSTR lpSystemName,
+    __in     LPCSTR lpName,
+    __out    PLUID   lpLuid
+);
+
+BOOL WINAPI LookupPrivilegeValueW(
+    __in_opt LPCWSTR lpSystemName,
+    __in     LPCWSTR lpName,
+    __out    PLUID   lpLuid
+);
+
+BOOL WINAPI AdjustTokenPrivileges(
+  _In_       HANDLE TokenHandle,
+  _In_       BOOL DisableAllPrivileges,
+  _In_opt_   PTOKEN_PRIVILEGES NewState,
+  _In_       DWORD BufferLength,
+  _Out_opt_  PTOKEN_PRIVILEGES PreviousState,
+  _Out_opt_  PDWORD ReturnLength
+);
+
+HRSRC WINAPI FindResourceA(
+    __in_opt HMODULE hModule,
+    __in     LPCSTR lpName,
+    __in     LPCSTR lpType
+);
+
+HRSRC WINAPI FindResourceW(
+    __in_opt HMODULE hModule,
+    __in     LPCWSTR lpName,
+    __in     LPCWSTR lpType
+);
+
+DWORD WINAPI SizeofResource(
+  _In_opt_  HMODULE hModule,
+  _In_      HRSRC hResInfo
+);
+
+HGLOBAL WINAPI LoadResource(
+  _In_opt_  HMODULE hModule,
+  _In_      HRSRC hResInfo
+);
+
+LPVOID WINAPI LockResource(
+  _In_  HGLOBAL hResData
+);
+
+BOOL WINAPI GetVersionExA(
+    __inout LPOSVERSIONINFOA lpVersionInformation
+);
+
+BOOL WINAPI GetVersionExW(
+    __inout LPOSVERSIONINFOW lpVersionInformation
+);
+
+DWORD GetVersion();
+
+HANDLE GetCurrentThread();
+
+DWORD GetCurrentThreadId();
+
+DWORD GetCurrentProcessorNumber();
+
+BOOL AllocConsole();
+
+BOOL FreeConsole();
+
+HANDLE WINAPI GetStdHandle(
+  _In_  DWORD nStdHandle
+);
+
+BOOL WINAPI SetStdHandle(
+  _In_  DWORD nStdHandle,
+  _In_  HANDLE hHandle
+);
+
+DWORD WINAPI SetThreadAffinityMask(
+  _In_  HANDLE hThread,
+  _In_  DWORD dwThreadAffinityMask
+);
+
+BOOL WINAPI WriteFile(
+  _In_         HANDLE hFile,
+  _In_         LPCVOID lpBuffer,
+  _In_         DWORD nNumberOfBytesToWrite,
+  _Out_opt_    LPDWORD lpNumberOfBytesWritten,
+  _Inout_opt_  LPOVERLAPPED lpOverlapped
+);
+
+DWORD WINAPI GetExtendedTcpTable(
+  _Out_    PVOID pTcpTable,
+  _Inout_  PDWORD pdwSize,
+  _In_     BOOL bOrder,
+  _In_     ULONG ulAf,
+  _In_     TCP_TABLE_CLASS TableClass,
+  _In_     ULONG Reserved
+);
+
+DWORD WINAPI GetExtendedUdpTable(
+  _Out_    PVOID pUdpTable,
+  _Inout_  PDWORD pdwSize,
+  _In_     BOOL bOrder,
+  _In_     ULONG ulAf,
+  _In_     UDP_TABLE_CLASS TableClass,
+  _In_     ULONG Reserved
+);
+
+DWORD WINAPI SetTcpEntry(
+  _In_  PMIB_TCPROW pTcpRow
+);
+
+PVOID WINAPI AddVectoredContinueHandler(
+  _In_  ULONG FirstHandler,
+  _In_  PVECTORED_EXCEPTION_HANDLER VectoredHandler
+);
+
+
+PVOID WINAPI AddVectoredExceptionHandler(
+  _In_  ULONG FirstHandler,
+  _In_  PVECTORED_EXCEPTION_HANDLER VectoredHandler
+);
+
+BOOL WINAPI TerminateThread(
+  _Inout_  HANDLE hThread,
+  _In_     DWORD dwExitCode
+);
+
+VOID WINAPI ExitThread(
+  _In_  DWORD dwExitCode
+);
+
+ULONG WINAPI RemoveVectoredExceptionHandler(
+  _In_  PVOID Handler
+);
+
+DWORD WINAPI ResumeThread(
+  _In_  HANDLE hThread
+);
+
+DWORD WINAPI SuspendThread(
+  _In_  HANDLE hThread
+);
+
+
+
+DWORD WINAPI WaitForSingleObject(
+  _In_  HANDLE hHandle,
+  _In_  DWORD dwMilliseconds
+);
+
+DWORD WINAPI GetThreadId(
+ _In_ HANDLE Thread
+ );
+
+HMODULE WINAPI LoadLibraryExA(
+  _In_       LPCSTR lpFileName,
+  _Reserved_ HANDLE  hFile,
+  _In_       DWORD   dwFlags
+);
+
+HMODULE WINAPI LoadLibraryExW(
+  _In_       LPCWSTR lpFileName,
+  _Reserved_ HANDLE  hFile,
+  _In_       DWORD   dwFlags
+);
+
+BOOL WINAPI SymInitialize(
+  _In_     HANDLE hProcess,
+  _In_opt_ LPCSTR UserSearchPath,
+  _In_     BOOL   fInvadeProcess
+);
+
+BOOL WINAPI SymFromName(
+  _In_    HANDLE       hProcess,
+  _In_    LPCSTR       Name,
+  _Inout_ PSYMBOL_INFO Symbol
+);
+
+DWORD64 WINAPI SymLoadModuleEx(
+  _In_ HANDLE        hProcess,
+  _In_ HANDLE        hFile,
+  _In_ LPCSTR        ImageName,
+  _In_ LPCSTR        ModuleName,
+  _In_ DWORD64       BaseOfDll,
+  _In_ DWORD         DllSize,
+  _In_ PMODLOAD_DATA Data,
+  _In_ DWORD         Flags
+);
+
+DWORD WINAPI SymSetOptions(
+  _In_ DWORD SymOptions
+);
+
+BOOL WINAPI SymGetTypeInfo(
+  _In_  HANDLE                    hProcess,
+  _In_  DWORD64                   ModBase,
+  _In_  ULONG                     TypeId,
+  _In_  IMAGEHLP_SYMBOL_TYPE_INFO GetType,
+  _Out_ PVOID                     pInfo
+);
+
+BOOL WINAPI DeviceIoControl(
+  _In_        HANDLE       hDevice,
+  _In_        DWORD        dwIoControlCode,
+  _In_opt_    LPVOID       lpInBuffer,
+  _In_        DWORD        nInBufferSize,
+  _Out_opt_   LPVOID       lpOutBuffer,
+  _In_        DWORD        nOutBufferSize,
+  _Out_opt_   LPDWORD      lpBytesReturned,
+  _Inout_opt_ LPOVERLAPPED lpOverlapped
+);
+
+BOOL WINAPI GetTokenInformation(
+  _In_      HANDLE                  TokenHandle,
+  _In_      TOKEN_INFORMATION_CLASS TokenInformationClass,
+  _Out_opt_ LPVOID                  TokenInformation,
+  _In_      DWORD                   TokenInformationLength,
+  _Out_     PDWORD                  ReturnLength
+);
+
+LONG WINAPI RegOpenKeyExA(
+  _In_     HKEY    hKey,
+  _In_opt_ LPCSTR lpSubKey,
+  _In_     DWORD   ulOptions,
+  _In_     REGSAM  samDesired,
+  _Out_    PHKEY   phkResult
+);
+
+LONG WINAPI RegOpenKeyExW(
+  _In_     HKEY    hKey,
+  _In_opt_ LPWSTR lpSubKey,
+  _In_     DWORD   ulOptions,
+  _In_     REGSAM  samDesired,
+  _Out_    PHKEY   phkResult
+);
+
+LONG WINAPI RegGetValueA(
+  _In_        HKEY    hkey,
+  _In_opt_    LPCSTR lpSubKey,
+  _In_opt_    LPCSTR lpValue,
+  _In_opt_    DWORD   dwFlags,
+  _Out_opt_   LPDWORD pdwType,
+  _Out_opt_   PVOID   pvData,
+  _Inout_opt_ LPDWORD pcbData
+);
+
+LONG WINAPI RegGetValueW(
+  _In_        HKEY    hkey,
+  _In_opt_    LPWSTR lpSubKey,
+  _In_opt_    LPWSTR lpValue,
+  _In_opt_    DWORD   dwFlags,
+  _Out_opt_   LPDWORD pdwType,
+  _Out_opt_   PVOID   pvData,
+  _Inout_opt_ LPDWORD pcbData
+);
+
+LONG WINAPI RegCloseKey(
+  _In_ HKEY hKey
+);
+
+BOOL WINAPI Wow64DisableWow64FsRedirection(
+  _Out_ PVOID *OldValue
+);
+
+BOOL WINAPI Wow64RevertWow64FsRedirection(
+  _In_ PVOID OldValue
+);
+
+BOOLEAN WINAPI Wow64EnableWow64FsRedirection(
+  _In_ BOOLEAN Wow64FsEnableRedirection
+);
+
+BOOL WINAPI Wow64GetThreadContext(
+    _In_    HANDLE hThread,
+    _Inout_ PWOW64_CONTEXT lpContext
+);
+
+BOOL WINAPI SetConsoleCtrlHandler(
+  _In_opt_ PHANDLER_ROUTINE HandlerRoutine,
+  _In_     BOOL             Add
+);
+
+LONG WINAPI WinVerifyTrust(
+    _In_opt_ HWND hwnd,
+    _In_ GUID *pgActionID,
+    _Inout_ LPVOID pWVTData
+);
+
+HGLOBAL WINAPI GlobalAlloc(
+  _In_ UINT   uFlags,
+  _In_ SIZE_T dwBytes
+);
+
+HGLOBAL WINAPI GlobalFree(
+  _In_ HGLOBAL hMem
+);
+
+BOOL WINAPI GlobalUnlock(
+  _In_ HGLOBAL hMem
+);
+
+LPVOID WINAPI GlobalLock(
+  _In_ HGLOBAL hMem
+);
+
+BOOL WINAPI OpenClipboard(
+  _In_opt_ HWND hWndNewOwner
+);
+
+BOOL WINAPI EmptyClipboard();
+
+BOOL WINAPI CloseClipboard();
+
+HANDLE WINAPI SetClipboardData(
+  _In_     UINT   uFormat,
+  _In_opt_ HANDLE hMem
+);
+
+HANDLE WINAPI GetClipboardData(
+  _In_ UINT uFormat
+);
+
+UINT WINAPI EnumClipboardFormats(
+  _In_ UINT format
+);
+
+INT WINAPI GetClipboardFormatNameA(
+  _In_  UINT   format,
+  _Out_ LPCSTR lpszFormatName,
+  _In_  INT    cchMaxCount
+);
+
+INT WINAPI GetClipboardFormatNameW(
+  _In_  UINT   format,
+  _Out_ LPCWSTR lpszFormatName,
+  _In_  INT    cchMaxCount
+);
@@ -0,0 +1,130 @@
+import collections
+
+#WinStructType = collections.namedtuple('WinStructType', ['name'])
+
+#Ptr = collections.namedtuple('Ptr', [''])
+
+class WinStructType(object):
+    def __init__(self, name):
+        self.name = name
+
+    def __repr__(self):
+        return "{0}({1})".format(type(self).__name__, self.name)
+
+    def generate_ctypes(self):
+        return self.name
+
+class Ptr(object):
+
+    def __init__(self, struct):
+        self.type = struct
+        self.name = struct.name
+
+    def generate_ctypes(self):
+        return "POINTER({0})".format(self.name)
+
+    def __repr__(self):
+        return "Ptr({0})".format(repr(self.type))
+        
+
+class WinStruct(object):
+    ctypes_type = "Structure"
+    def __init__(self, name):
+        self.name = name
+        self.fields = []
+        self.typedef = {}
+
+    def add_field(self, field):
+        self.fields.append(field)
+
+    def add_typedef(self, name):
+        if name in self.typedef:
+            raise ValueError("nop")
+        self.typedef[name] = self
+
+    def add_ptr_typedef(self, name):
+        if name in self.typedef:
+            raise ValueError("nop")
+        self.typedef[name] = Ptr(self)
+
+    def is_self_referencing(self):
+        for type in [f[0] for f in self.fields]:
+            if type.name == self.name:
+                return True
+        return False
+
+    def generate_selfref_ctypes_class(self):
+        res = "# Self referencing struct tricks\n"
+        res += """class {0}(Structure): pass\n""".format(self.name)
+        res += "{0}._fields_ = [\n".format(self.name)
+
+        for (ftype, name, nb_rep) in self.fields:
+            if  nb_rep == 1: 
+                res+= '    ("{0}", {1}),\n'.format(name, ftype.generate_ctypes())
+            else:       
+                res+= '    ("{0}", {1} * {2}),\n'.format(name, ftype.generate_ctypes(), nb_rep)
+        res += "]\n"
+        return res
+
+    def generate_ctypes_class(self):
+        if self.is_self_referencing():
+            return self.generate_selfref_ctypes_class()
+        res = """class {0}({1}):
+        _fields_ = [\n""".format(self.name, self.ctypes_type)
+
+        for (ftype, name, nb_rep) in self.fields:
+            if  nb_rep == 1: 
+                res+= '        ("{0}", {1}),\n'.format(name, ftype.generate_ctypes())
+            else:       
+                res+= '        ("{0}", {1} * {2}),\n'.format(name, ftype.generate_ctypes(), nb_rep)
+        res += "    ]\n"
+        return res
+
+    def generate_ctypes(self):
+        ctypes_class = self.generate_ctypes_class()
+        for typedef_name, value in self.typedef.items():
+            str_value = self.name
+            if type(value) == Ptr:
+                str_value = "POINTER({0})".format(self.name)
+            ctypes_class += "{0} = {1}\n".format(typedef_name, str_value)
+        return ctypes_class
+        
+class WinUnion(WinStruct):
+    ctypes_type = "Union"
+                
+class WinEnum(object):
+    def __init__(self, name):
+        self.name = name
+        self.fields = []
+        self.typedef = {}
+
+    def add_enum_entry(self, number, name):
+        self.fields.append((number, name))
+
+    def add_typedef(self, name):
+        if name in self.typedef:
+            raise ValueError("nop")
+        self.typedef[name] = self
+        
+    def add_ptr_typedef(self, name):
+        if name in self.typedef:
+            raise ValueError("nop")
+        self.typedef[name] = Ptr(self)
+
+    # Assert that enum are DWORD
+    def generate_ctypes(self):
+        lines = ["{0} = DWORD".format(self.name)]
+        for typedef_name, value in self.typedef.items():
+            str_value = self.name
+            if type(value) == Ptr:
+                str_value = "POINTER({0})".format(self.name)
+            lines += ["{0} = {1}".format(typedef_name, str_value)]
+        #lines += ["{0} = {1}".format(t, self.name) for t in self.typedef]
+        lines += [""]
+
+        for i, name in self.fields:
+            lines.append("{0} = {1}".format(name, hex(i)))
+        ctypes_class = "\n".join(lines) 
+
+        return ctypes_class + "\n"
+        
@@ -3,7 +3,7 @@ from ctypes import *
 from ctypes.wintypes import *
 from .winstructs import *

-functions = ['ExitProcess', 'TerminateProcess', 'GetLastError', 'GetCurrentProcess', 'CreateFileA', 'CreateFileW', 'NtQuerySystemInformation', 'NtQueryInformationProcess', 'NtQueryVirtualMemory', 'NtCreateThreadEx', 'NtQueryInformationThread', 'GetExitCodeThread', 'GetExitCodeProcess', 'VirtualAlloc', 'VirtualAllocEx', 'VirtualFree', 'VirtualFreeEx', 'VirtualProtect', 'VirtualQuery', 'VirtualQueryEx', 'GetModuleFileNameA', 'GetModuleFileNameW', 'CreateThread', 'CreateRemoteThread', 'VirtualProtect', 'CreateProcessA', 'CreateProcessW', 'GetThreadContext', 'NtGetContextThread', 'SetThreadContext', 'OpenThread', 'OpenProcess', 'CloseHandle', 'ReadProcessMemory', 'NtWow64ReadVirtualMemory64', 'WriteProcessMemory', 'CreateToolhelp32Snapshot', 'Thread32First', 'Thread32Next', 'Process32First', 'Process32Next', 'Process32FirstW', 'Process32NextW', 'GetProcAddress', 'LoadLibraryA', 'LoadLibraryW', 'OpenProcessToken', 'LookupPrivilegeValueA', 'LookupPrivilegeValueW', 'AdjustTokenPrivileges', 'FindResourceA', 'FindResourceW', 'SizeofResource', 'LoadResource', 'LockResource', 'GetVersionExA', 'GetVersionExW', 'GetVersion', 'GetCurrentThread', 'GetCurrentThreadId', 'GetCurrentProcessorNumber', 'AllocConsole', 'FreeConsole', 'GetStdHandle', 'SetStdHandle', 'SetThreadAffinityMask', 'WriteFile', 'GetExtendedTcpTable', 'GetExtendedUdpTable', 'SetTcpEntry', 'AddVectoredContinueHandler', 'AddVectoredExceptionHandler', 'TerminateThread', 'ExitThread', 'RemoveVectoredExceptionHandler', 'ResumeThread', 'SuspendThread', 'WaitForSingleObject', 'GetThreadId', 'LoadLibraryExA', 'LoadLibraryExW', 'SymInitialize', 'SymFromName', 'SymLoadModuleEx', 'SymSetOptions', 'SymGetTypeInfo', 'DeviceIoControl', 'GetTokenInformation', 'RegOpenKeyExA', 'RegOpenKeyExW', 'RegGetValueA', 'RegGetValueW', 'RegCloseKey', 'Wow64DisableWow64FsRedirection', 'Wow64RevertWow64FsRedirection', 'Wow64EnableWow64FsRedirection', 'Wow64GetThreadContext', 'SetConsoleCtrlHandler']
+functions = ['ExitProcess', 'TerminateProcess', 'GetLastError', 'GetCurrentProcess', 'CreateFileA', 'CreateFileW', 'NtQuerySystemInformation', 'NtQueryInformationProcess', 'NtQueryVirtualMemory', 'NtCreateThreadEx', 'NtQueryInformationThread', 'GetExitCodeThread', 'GetExitCodeProcess', 'VirtualAlloc', 'VirtualAllocEx', 'VirtualFree', 'VirtualFreeEx', 'VirtualProtect', 'VirtualQuery', 'VirtualQueryEx', 'GetModuleFileNameA', 'GetModuleFileNameW', 'CreateThread', 'CreateRemoteThread', 'VirtualProtect', 'CreateProcessA', 'CreateProcessW', 'GetThreadContext', 'NtGetContextThread', 'SetThreadContext', 'OpenThread', 'OpenProcess', 'CloseHandle', 'ReadProcessMemory', 'NtWow64ReadVirtualMemory64', 'WriteProcessMemory', 'CreateToolhelp32Snapshot', 'Thread32First', 'Thread32Next', 'Process32First', 'Process32Next', 'Process32FirstW', 'Process32NextW', 'GetProcAddress', 'LoadLibraryA', 'LoadLibraryW', 'OpenProcessToken', 'LookupPrivilegeValueA', 'LookupPrivilegeValueW', 'AdjustTokenPrivileges', 'FindResourceA', 'FindResourceW', 'SizeofResource', 'LoadResource', 'LockResource', 'GetVersionExA', 'GetVersionExW', 'GetVersion', 'GetCurrentThread', 'GetCurrentThreadId', 'GetCurrentProcessorNumber', 'AllocConsole', 'FreeConsole', 'GetStdHandle', 'SetStdHandle', 'SetThreadAffinityMask', 'WriteFile', 'GetExtendedTcpTable', 'GetExtendedUdpTable', 'SetTcpEntry', 'AddVectoredContinueHandler', 'AddVectoredExceptionHandler', 'TerminateThread', 'ExitThread', 'RemoveVectoredExceptionHandler', 'ResumeThread', 'SuspendThread', 'WaitForSingleObject', 'GetThreadId', 'LoadLibraryExA', 'LoadLibraryExW', 'SymInitialize', 'SymFromName', 'SymLoadModuleEx', 'SymSetOptions', 'SymGetTypeInfo', 'DeviceIoControl', 'GetTokenInformation', 'RegOpenKeyExA', 'RegOpenKeyExW', 'RegGetValueA', 'RegGetValueW', 'RegCloseKey', 'Wow64DisableWow64FsRedirection', 'Wow64RevertWow64FsRedirection', 'Wow64EnableWow64FsRedirection', 'Wow64GetThreadContext', 'SetConsoleCtrlHandler', 'WinVerifyTrust', 'GlobalAlloc', 'GlobalFree', 'GlobalUnlock', 'GlobalLock', 'OpenClipboard', 'EmptyClipboard', 'CloseClipboard', 'SetClipboardData', 'GetClipboardData', 'EnumClipboardFormats', 'GetClipboardFormatNameA', 'GetClipboardFormatNameW']

 # ExitProcess(uExitCode):
 ExitProcessPrototype = WINFUNCTYPE(VOID, UINT)
@@ -397,3 +397,55 @@ Wow64GetThreadContextParams = ((1, 'hThread'), (1, 'lpContext'))
 SetConsoleCtrlHandlerPrototype = WINFUNCTYPE(BOOL, PHANDLER_ROUTINE, BOOL)
 SetConsoleCtrlHandlerParams = ((1, 'HandlerRoutine'), (1, 'Add'))

+# WinVerifyTrust(hwnd, pgActionID, pWVTData):
+WinVerifyTrustPrototype = WINFUNCTYPE(LONG, HWND, POINTER(GUID), LPVOID)
+WinVerifyTrustParams = ((1, 'hwnd'), (1, 'pgActionID'), (1, 'pWVTData'))
+
+# GlobalAlloc(uFlags, dwBytes):
+GlobalAllocPrototype = WINFUNCTYPE(HGLOBAL, UINT, SIZE_T)
+GlobalAllocParams = ((1, 'uFlags'), (1, 'dwBytes'))
+
+# GlobalFree(hMem):
+GlobalFreePrototype = WINFUNCTYPE(HGLOBAL, HGLOBAL)
+GlobalFreeParams = ((1, 'hMem'),)
+
+# GlobalUnlock(hMem):
+GlobalUnlockPrototype = WINFUNCTYPE(BOOL, HGLOBAL)
+GlobalUnlockParams = ((1, 'hMem'),)
+
+# GlobalLock(hMem):
+GlobalLockPrototype = WINFUNCTYPE(LPVOID, HGLOBAL)
+GlobalLockParams = ((1, 'hMem'),)
+
+# OpenClipboard(hWndNewOwner):
+OpenClipboardPrototype = WINFUNCTYPE(BOOL, HWND)
+OpenClipboardParams = ((1, 'hWndNewOwner'),)
+
+# EmptyClipboard():
+EmptyClipboardPrototype = WINFUNCTYPE(BOOL)
+EmptyClipboardParams = ()
+
+# CloseClipboard():
+CloseClipboardPrototype = WINFUNCTYPE(BOOL)
+CloseClipboardParams = ()
+
+# SetClipboardData(uFormat, hMem):
+SetClipboardDataPrototype = WINFUNCTYPE(HANDLE, UINT, HANDLE)
+SetClipboardDataParams = ((1, 'uFormat'), (1, 'hMem'))
+
+# GetClipboardData(uFormat):
+GetClipboardDataPrototype = WINFUNCTYPE(HANDLE, UINT)
+GetClipboardDataParams = ((1, 'uFormat'),)
+
+# EnumClipboardFormats(format):
+EnumClipboardFormatsPrototype = WINFUNCTYPE(UINT, UINT)
+EnumClipboardFormatsParams = ((1, 'format'),)
+
+# GetClipboardFormatNameA(format, lpszFormatName, cchMaxCount):
+GetClipboardFormatNameAPrototype = WINFUNCTYPE(INT, UINT, LPCSTR, INT)
+GetClipboardFormatNameAParams = ((1, 'format'), (1, 'lpszFormatName'), (1, 'cchMaxCount'))
+
+# GetClipboardFormatNameW(format, lpszFormatName, cchMaxCount):
+GetClipboardFormatNameWPrototype = WINFUNCTYPE(INT, UINT, LPCWSTR, INT)
+GetClipboardFormatNameWParams = ((1, 'format'), (1, 'lpszFormatName'), (1, 'cchMaxCount'))
+
				`@@ -0,0 +1 @@`
				names = ['ATOM', 'BOOL', 'BOOLEAN', 'BYTE', 'COLORREF', 'DOUBLE', 'DWORD', 'FILETIME', 'FLOAT', 'HACCEL', 'HANDLE', 'HBITMAP', ' HBRUSH', 'HCOLORSPACE', 'HDC', 'HDESK', 'HDWP', 'HENHMETAFILE', 'HFONT', 'HGDIOBJ', 'HGLOBAL', 'HHOOK', 'HICON', 'HINSTA NCE', 'HKEY', 'HKL', 'HLOCAL', 'HMENU', 'HMETAFILE', 'HMODULE', 'HMONITOR', 'HPALETTE', 'HPEN', 'HRGN', 'HRSRC', 'HSTR', 'HTASK', 'HWINSTA', 'HWND', 'INT', 'LANGID', 'LARGE_INTEGER', 'LCID', 'LCTYPE', 'LGRPID', 'LONG', 'LPARAM', 'LPCOLESTR' , 'LPCSTR', 'LPCVOID', 'LPCWSTR', 'LPOLESTR', 'LPSTR', 'LPVOID', 'LPWSTR', 'MAX_PATH', 'MSG', 'OLESTR', 'POINT', 'POINTL ', 'RECT', 'RECTL', 'RGB', 'SC_HANDLE', 'SERVICE_STATUS_HANDLE', 'SHORT', 'SIZE', 'SIZEL', 'SMALL_RECT', 'UINT', 'ULARGE _INTEGER', 'ULONG', 'USHORT', 'VARIANT_BOOL', 'WCHAR', 'WIN32_FIND_DATAA', 'WIN32_FIND_DATAW', 'WORD', 'WPARAM', '_COORD ', '_FILETIME', '_LARGE_INTEGER', '_POINTL', '_RECTL', '_SMALL_RECT', '_ULARGE_INTEGER', 'tagMSG', 'tagPOINT', 'tagRECT' , 'tagSIZE']