diff --git a/CMakeLists.txt b/CMakeLists.txt index 401ee3bcce..2c131b91f3 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -396,7 +396,7 @@ endif() # If BOX86_ROOT contains a ".c", the build breaks... string(REPLACE ".c" "_private.h" MODROOT ${BOX86_ROOT}) -set(WRAPPEDS_HEAD "") +set(WRAPPEDS_HEAD "${BOX86_ROOT}/src/wrapped/wrappedd3dadapter9_genvate.h") foreach(A ${WRAPPEDS}) string(REPLACE ".c" "_private.h" C ${A}) string(REPLACE "${MODROOT}" "${BOX86_ROOT}" B ${C}) diff --git a/rebuild_wrappers.py b/rebuild_wrappers.py index 16c83d3b0c..daf5d205a7 100755 --- a/rebuild_wrappers.py +++ b/rebuild_wrappers.py @@ -3,6 +3,53 @@ import os import sys +try: + assert(sys.version_info.major == 3) + if sys.version_info.minor >= 9: + # Python 3.9+ + from typing import Any, Generic, NewType, Optional, TypeVar, Union, final + from collections.abc import Callable, Iterable, Sequence + Dict = dict + List = list + Type = type + Tuple = tuple + elif sys.version_info.minor >= 8: + # Python [3.8, 3.9) + from typing import Any, Callable, Dict, Generic, Iterable, List, NewType, Optional, Sequence, Tuple, Type, TypeVar, Union, final + elif (sys.version_info.minor >= 5) and (sys.version_info.micro >= 2): + # Python [3.5.2, 3.8) + from typing import Any, Callable, Dict, Generic, Iterable, List, NewType, Optional, Sequence, Tuple, Type, TypeVar, Union + final = lambda fun: fun # type: ignore + elif sys.version_info.minor >= 5: + # Python [3.5, 3.5.2) + from typing import Any, Callable, Dict, Generic, Iterable, List, Optional, Sequence, Tuple, Type, TypeVar, Union + def NewType(_, b): return b # type: ignore + final = lambda fun: fun # type: ignore + else: + # Python < 3.5 + #print("Your Python version does not have the typing module, fallback to empty 'types'") + # Dummies + class GTDummy: + def __getitem__(self, _): + return self + Any = GTDummy() # type: ignore + Callable = GTDummy() # type: ignore + Dict = GTDummy() # type: ignore + Generic = GTDummy() # type: ignore + Iterable = GTDummy() # type: ignore + List = GTDummy() # type: ignore + def NewType(_, b): return b # type: ignore + Optional = GTDummy() # type: ignore + Sequence = GTDummy() # type: ignore + Tuple = GTDummy() # type: ignore + Type = GTDummy() # type: ignore + def TypeVar(T): return object # type: ignore + Union = GTDummy() # type: ignore + final = lambda fun: fun # type: ignore +except ImportError: + print("It seems your Python version is quite broken...") + assert(False) + """ Generates all files in src/wrapped/generated === @@ -10,28 +57,24 @@ TL;DR: Automagically creates type definitions (/.F.+/ functions/typedefs...). All '//%' in the headers are used by the script. -Reads each lines of each "_private.h" headers (plus wrappedd3dadapter9_gen.h as a special case). +Reads each lines of each "_private.h" headers (plus wrappedd3dadapter9_genvate.h, derived from wrappedd3dadapter9_gen.h). For each of them: - If if starts with a #ifdef, #else, #ifndef, #endif, it memorizes which definition is required - If it starts with a "GO", it will do multiple things: - It memorizes the type used by the function (second macro argument) - - It memorizes the type it is mapped to, if needed (eg, iFEv is mapped to iFE: the second argument is dropped) - - It checks if the type given (both original and ) - - If the signature contains a 'E', it will memorize the original function's signature: - - If it is the special file case, or if the line contains "//%%", it stops there. - - Otherwise, if it starts with "GOS": - - It will search for the special marker "//%". - That special marker is used to detect the following step: - - If the marker is followed by a registered structure ID (see later), it transforms the assembly function signature - into the original signature (eg, transforms pFEp into XFv if //%X was used) - - If the marker is followed by a '{', it will not attempt to alter the given signature, and instead use the - signature between '{' and '}' - - Otherwise, if the line contains '//%{', like before it will use the signature given and not the original one. - - Finally, if it still didn't stop, it will use the assembly signature (without the emulator). -- If the line starts with a '//%' - -`gbl` contains the first list, `redirects` the second, `mytypedefs` the third. -`mystructs` and `mystructs_vals` constains data about the structures. + - It memorizes the type it is mapped to, if needed (eg, iFvp is mapped to iFp: the first argument is dropped) + - It checks if the type given (both original and mapped to) are valid + - If the signature contains a 'E' but it is not a "GOM" command, it will throw an error (and vice-versa*) + - If the line also contains '//%', the script will parse what's attached to this comment start: + - If it is attached to a '%', the function will be skipped when generating the 'SUPER' macro in the *types.h + - *If it is attached to a 'noE' or attached to something that ends with ',noE', it will ignore functions that + don't have the emulator as an argument but are still GOM functions +- If the line starts with a '//%S', it will memorize a structure declaration. + The structure of it is: "//%S " + NOTE: Those structure letters are "fake types" that are accepted in the macros. + +`gbl` contains the first list, `redirects` the second and + `filespec` constains file specific informations (eg, structures, typedefs required...). After sorting the data, it generates: @@ -39,7 +82,6 @@ --------- (Private) type definitions (/.F.+_t/) Function definitions (/.F.+/ functions, that actually execute the function given as argument) -isSimpleWrapper definition wrapper.h --------- @@ -48,74 +90,713 @@ *types.h -------- -Local types definition, for the original signatures (eg, XFv for the earlier example) +Local types definition, for the original signatures The SUPER() macro definition, used to generate and initialize the `*_my_t` library structure (TODO: also automate this declaration/definition? It would require more metadata, and may break sometime in the future due to the system changing...) + +*defs.h +------- +Local `#define`s, for signature mapping + +*undefs.h +--------- +Local `#undefine`s, for signature mapping + + +Example: +======== +In wrappedtest_private.h: + ---------------------- +//%S X TestLibStructure ppu + +GO(superfunction, pFX) +GOM(superFunction2, pFEpX) +GOM(functionWithoutE, pFppu) //%noE +GOM(functionWithoutEAndNotInTypes, pFpppu) //%%,noE +GOM(functionNotInTypes, pFEpppu) //%% + +[No output] +Generated files: +wrapper.c: [snippet] +---------- +typedef void *(*pFppu_t)(void*, void*, uint32_t); +typedef void *(*pFpppu_t)(void*, void*, void*, uint32_t); +typedef void *(*pFEpppu_t)(x86emu_t*, void*, void*, void*, uint32_t); + +void pFppu(x86emu_t *emu, uintptr_t fcn) { pFppu_t *fn = (pFppu_t)fn; R_RAX=...; } +void pFpppu(x86emu_t *emu, uintptr_t fcn) { pFpppu_t *fn = (pFpppu_t)fn; R_RAX=...; } +void pFEpppu(x86emu_t *emu, uintptr_t fcn) { pFpppu_t *fn = (pFpppu_t)fn; R_RAX=...; } + +wrapper.h: [snippet] +---------- +typedef void (*wrapper_t)(x86emu_t*, uintptr_t); + +void pFppu(x86emu_t *emu, uintptr_t fcn); +void pFpppu(x86emu_t *emu, uintptr_t fcn); +void pFEpppu(x86emu_t *emu, uintptr_t fcn); + +wrappedtesttypes.h: +------------------- +typedef void *(*pFpX_t)(void*, TestLibStructure); +typedef void *(*pFppu_t)(void*, void*, uint32_t); +typedef void *(*pFpppu_t)(void*, void*, void*, uint32_t); + +#define SUPER() ADDED_FUNCTIONS() \\ + GO(superFunction2, pFpX) \\ + GO(functionWithoutE, pFppu) + +wrappedtestdefs.h: +------------------ +#define pFX pFppu +#define pFpX pFpppu + +wrappedtestundefs.h: +-------------------- +#undef pFX +#undef pFpX """ -# Free values: -# AB F H J QR T XYZab gh jk mno qrst xyz -values = ['E', 'e', 'v', 'c', 'w', 'i', 'I', 'C', 'W', 'u', 'U', 'f', 'd', 'D', 'K', 'l', 'L', 'p', 'V', 'O', 'S', '2', 'P', 'G', 'N', 'M'] -def splitchar(s): - try: - ret = [len(s), values.index(s[0])] - for c in s[2:]: - ret.append(values.index(c)) - return ret - except ValueError as e: - raise ValueError("Value is " + s) from e +# Free letters: +# AB F H J QR T XYZab e gh jk mno qrst xyz + +T = TypeVar('T') +U = TypeVar('U') -def value(define): - return define[9:-1] if define.startswith("!") else define[8:-1] +Filename = str -def splitdef(dnf, defines): - cunjs = dnf.split(" || ") - clauses = [c.split(" && ") for c in cunjs] +class CustOrderedDict(Generic[T, U], Iterable[T]): + __keys__: List[T] + __actdict__: Dict[T, U] - ret = [len(cunjs)] + def __init__(self, src: Optional[Dict[T, U]] = None) -> None: + if src is None: + self.__keys__ = [] + self.__actdict__ = {} + else: + self.__keys__ = list(src.keys()) + self.__actdict__ = src - for cunj in clauses: - for c in cunj: - ret.append(len(c)) - for cunj in clauses: - for c in cunj: - ret.append(defines.index(value(c)) * 2 + (1 if c.startswith("!") else 0)) - ret.append(0) - return ret + def sort(self, *, key: Callable[[T], Any] = lambda x: x) -> None: + self.__keys__.sort(key=key) + + def __iter__(self): + return iter(self.__keys__) + def __contains__(self, k: T) -> bool: + return k in self.__actdict__ + def __getitem__(self, k: T) -> U: + return self.__actdict__[k] + def __setitem__(self, k: T, v: U) -> None: + if k not in self.__keys__: self.__keys__.append(k) + self.__actdict__[k] = v +class CustOrderedDictList(CustOrderedDict[T, List[U]]): + def __getitem__(self, k: T) -> List[U]: + if k not in self: self[k] = [] + return super().__getitem__(k) -def invert(define): - return define[1:] if define.startswith("!") else ("!" + define) +class FirstArgumentSingletonMeta(Generic[T], type): + _singletons: Dict[T, Type['FirstArgumentSingletonMeta']] + + @classmethod + def __prepare__(metacls, __name: str, __bases: Tuple[type, ...], **kwds: Any) -> Dict[str, Any]: + return { "_singletons": {} } + + def __contains__(cls, k): + return k in cls._singletons + + def getSingletons(cls): + return cls._singletons + def __getitem__(cls, k): + return cls._singletons[k] + + def __call__(cls, fstarg, *largs, **kwargs): + if fstarg not in cls._singletons: + cls._singletons[fstarg] = super().__call__(fstarg, *largs, **kwargs) + return cls._singletons[fstarg] -def main(root, defines, files, ver): - global values +class FileSpec: + class Struct: + def __init__(self, name: str, repl: str) -> None: + self.name = name + self.repl = repl - # Initialize variables: gbl for all values, redirects for redirections - # mytypedefs is a list of all functions per "*FE*" types per filename, mystructs of structures per filename - gbl = {} - redirects = {} - mytypedefs = {} - mystructs = {} - mystructs_vals = {} + # CONSTANT- values: original set + # CONSTANT- rvalues: valid replacement values (outside of structures) + # CONSTANT- validrepl: valid replacement values (for structures) + # structs: structure ids and additional data + values: Sequence[str] = ['E', 'v', 'c', 'w', 'i', 'I', 'C', 'W', 'u', 'U', 'f', 'd', 'D', 'K', 'l', 'L', 'p', 'V', 'O', 'S', '2', 'P', 'G', 'N', 'M', 's'] + rvalues: Sequence[str] = ['E', 'v', 'c', 'w', 'i', 'I', 'C', 'W', 'u', 'U', 'f', 'd', 'D', 'K', 'l', 'L', 'p', 'V', 'O', 'S', '2', 'P', 'G', 'N', 'M', 's'] + validrepl: Sequence[str] = ['c', 'w', 'i', 'I', 'C', 'W', 'u', 'U', 'f', 'd', 'D', 'K', 'l', 'L', 'p', 'V', 'O', 'S', '2', 'P', 'G', 'N', 'M', 's'] + structs: CustOrderedDict[str, Struct] - # First read the files inside the headers - # TODO: remove the special case... - for filepath in files + [os.path.join(root, "src", "wrapped", "wrappedd3dadapter9_gen.h")]: - filename = filepath.split("/")[-1] - dependants = [] + def __init__(self) -> None: + self.structs = CustOrderedDict() + + self.typedefs: CustOrderedDictList[_BareFunctionType, Function] = CustOrderedDictList() + self.structsuses: List[FunctionType] = [] + + def registerStruct(self, id: str, name: str, repl: str): + if len(id) != 1: + # If you REALLY need it, consider opening a ticket + # Before you do, consider that everything that is a valid in a C token is valid here too + raise ValueError("Type ID \"" + id + "\" is too long!") + if id in self.rvalues: + raise ValueError("Type " + id + " is already reserved!") + if id in self.structs: + raise ValueError("Type " + id + " is already used!") + if any(c not in self.validrepl for c in repl): + raise ValueError("Invalid structure replacement value \"" + repl + "\" (note: recursive replacements are not supported)") + if repl == "": + # If you need this, please open an issue (also, this is never actually called, empty strings are removed at the calling site) + raise NotImplementedError("Invalid structure metadata supply (empty replacement)") + + self.structs[id] = FileSpec.Struct(name, repl) + +class FunctionType(metaclass=FirstArgumentSingletonMeta): + def __new__(cls, string: str, filespec: FileSpec) -> 'FunctionType': + if ((string[0] not in FileSpec.values) or any(c not in FileSpec.values for c in string[2:])) \ + and ((string[0] in FileSpec.values) or (string[0] in filespec.structs)) \ + and all((c != 'v') and (c in FileSpec.values) or (c in filespec.structs) for c in string[2:]): + return super().__new__(StructFunctionType) + else: + return super().__new__(cls) + + def __init__(self, string: str, filespec: FileSpec, /) -> None: + # Early fail + if 'VV' in string: + raise ValueError("'V' can only be at the end of the type (use 's' instead)") + + self.orig = string + + self.hasemu = 'E' in string + if self.hasemu: + if ("E" in string[:2]) or ("E" in string[3:]): + raise NotImplementedError("x86emu_t* not as the first parameter") + if len(string) < 4: + raise NotImplementedError("Type {0} too short".format(string)) + chk_type = string[0] + string[3:] + else: + chk_type = string[0] + string[2:] + self.withoutE = _BareFunctionType(string[0:2] + chk_type[1:], filespec, isinstance(self, StructFunctionType)) + self._bare = _BareFunctionType(self.orig, filespec, isinstance(self, StructFunctionType)) + if len(chk_type) < 2: + raise NotImplementedError("Type {0} too short".format(string)) + + if string[1] != "F": + raise NotImplementedError("Bad middle letter {0}".format(string[1])) + + self.redirect = any(c not in FileSpec.values for c in chk_type) or (('v' in chk_type[1:]) and (len(chk_type) > 2)) + self.usestruct: bool = False + self.redirected: Optional[FunctionType] = None + if self.redirect: + if all(((i == 0) or (c != 'v')) and (c in FileSpec.values) or (c in filespec.structs) for i, c in enumerate(chk_type)): + # 'v' is never allowed here + self.redirect = False + self.usestruct = True + return + else: + if any(c not in FileSpec.rvalues for c in chk_type): + raise NotImplementedError("Invalid type {0}".format(string)) + + # Ok, this is acceptable: there is 0, 1 and/or void + string = string[:2] + (string[2:] + .replace("v", "")) # void -> nothing + assert(len(string) >= 3) # If this raises, don't use 'vFvvvvvv' as a signature... + self.redirected = FunctionType(string, filespec) + assert(not self.redirected.redirect and not self.redirected.usestruct) + + def getchar(self, c: str) -> int: + return self._bare.getchar(c) + def getcharidx(self, i: int) -> int: + return self._bare.getcharidx(i) + def splitchar(self) -> List[int]: + return self._bare.splitchar() + + def __hash__(self) -> int: + return str.__hash__(self.orig) + def __eq__(self, o: object): + return isinstance(o, FunctionType) and ((self.orig == o.orig) and (o is self or not isinstance(self, StructFunctionType))) +class StructFunctionType(FunctionType): + def __init__(self, string: str, filespec: FileSpec, /) -> None: + super().__init__(string, filespec) + assert(self.usestruct) + self.filespec = filespec + self.filespec.structsuses.append(self) + + self.returnsstruct = string[0] in self.filespec.structs + if self.returnsstruct: + if self.hasemu: + string = "pFEp" + string[3:] + else: + string = "pFp" + string[2:] + + for struct in self.filespec.structs: + string = string.replace(struct, self.filespec.structs[struct].repl) + self.redirected = FunctionType(string, self.filespec) + +class _BareFunctionType(FunctionType): # Fake derived + def __new__(cls, *largs, **kwargs): + return object.__new__(cls) + def __init__(self, string: str, filespec: FileSpec, isstruct: bool, /) -> None: + self.orig = string + self.filespec = filespec + self.isstruct = isstruct + + def getchar(self, c: str) -> int: + if c in FileSpec.rvalues: + return FileSpec.rvalues.index(c) + else: + assert(self.isstruct) + return self.filespec.structs.__keys__.index(c) + len(FileSpec.rvalues) + def getcharidx(self, i: int) -> int: + return self.getchar(self.orig[i]) + + def splitchar(self) -> List[int]: + try: + ret = [ + len(self.orig), self.getcharidx(0), + *map(self.getcharidx, range(2, len(self.orig))) + ] + return ret + except ValueError as e: + raise ValueError("Value is " + self.orig) from e + except AssertionError as e: + raise ValueError("Value is " + self.orig) from e + +# Allowed GOs: GO,GOM,GO2,GOS,GOW,GOWM,GOW2,GO2S +class Function: + def __init__(self, name: str, funtype: FunctionType, gotype: str, filespec: FileSpec, filename: Filename, line: str) -> None: + self._noE = False + + self.no_dlsym: bool = False + if "//%" in line: + additional_meta = line.split("//%")[1].split(" ")[0].strip() + + if additional_meta.endswith(",noE"): + self._noE = True + additional_meta = additional_meta[:-4] + + if additional_meta == 'noE': + assert not self._noE, "Duplicated 'noE'" + self._noE = True + elif additional_meta == '%': + self.no_dlsym = True + else: + raise NotImplementedError("Changing the function type 'on the fly' is not supported") + + funtypeerr = ValueError("Invalid function type " + gotype) + if not gotype.startswith("GO"): + raise funtypeerr + gotype = gotype[2:] + self.isweak = (len(gotype) > 0) and (gotype[0] == "W") + if self.isweak: + gotype = gotype[1:] + self.ismy = (len(gotype) > 0) and (gotype[0] == "M") + self.is2 = (len(gotype) > 0) and (gotype[0] == "2") + self.retS = (len(gotype) > 0) and (gotype[0] == "S") + if self.ismy or self.is2 or self.retS: + gotype = gotype[1:] + if self.retS: + self.ismy = True + assert((self.no_dlsym and (funtype.orig.startswith("pFp") or funtype.orig.startswith("pFEp"))) + or (isinstance(funtype, StructFunctionType) and funtype.returnsstruct)) + self._noE = self._noE or self.no_dlsym + if isinstance(funtype, StructFunctionType) and funtype.returnsstruct and not self.retS: + gotype = "GO" + \ + ("W" if self.isweak else "") + \ + ("M" if self.ismy else "") + ("2" if self.is2 else "") + raise ValueError("Function type " + funtype.orig + " needs to return a structure, but doesn't (currently " + gotype + ")") + if gotype != "": + raise funtypeerr + + self.name = name + self.type = funtype + self.filespec = filespec + assert(not isinstance(funtype, StructFunctionType) or filespec is funtype.filespec) # No reason why not, so assert() + + if self.is2: + self.fun2 = line.split(',')[2].split(')')[0].strip() + if self.type.hasemu != self.fun2.startswith("my_"): + # If this raises because of a different prefix, open a pull request + print("\033[91mThis is probably not what you meant!\033[m ({0}:{1})".format(filename, line[:-1]), file=sys.stderr) + self.invalid = True + + if (self.ismy and not self.type.hasemu and not self.is2) and not self._noE: + # Probably invalid on box86; if not so, remove/comment this whole 'if' (and also open an issue) + print("\033[94mAre you sure of this?\033[m ({0}:{1})".format(filename, line[:-1]), file=sys.stderr) + self.invalid = True + return + if self.type.hasemu and not self.ismy and not self.is2: + # Certified invalid + print("\033[91mThis is probably not what you meant!\033[m ({0}:{1})".format(filename, line[:-1]), file=sys.stderr) + self.invalid = True + return + if self._noE and not self.ismy: + raise ValueError("Invalid meta: 'no E' provided but function is not a GOM") + + if self.ismy: + # Add this to the typedefs + self.filespec.typedefs[self.type.withoutE].append(self) + +DefineType = NewType('DefineType', str) +@final +class Define: + name: DefineType + inverted_: bool + + defines: List[DefineType] = [] + + def __init__(self, name: DefineType, inverted_: bool) -> None: + # All values for "name" are in defines (throw otherwise) + if name not in Define.defines: + raise KeyError(name) + + self.name = name + self.inverted_ = inverted_ + def copy(self) -> "Define": + return Define(self.name, self.inverted_) + + def value(self) -> int: + return Define.defines.index(self.name)*2 + (1 if self.inverted_ else 0) + + def invert(self) -> "Define": + """ + invert -- Transform a `defined()` into a `!defined()` and vice-versa, in place. + """ + self.inverted_ = not self.inverted_ + return self + def inverted(self) -> "Define": + """ + inverted -- Transform a `defined()` into a `!defined()` and vice-versa, out-of-place. + """ + return Define(self.name, not self.inverted_) + + def __str__(self) -> str: + if self.inverted_: + return "!defined(" + self.name + ")" + else: + return "defined(" + self.name + ")" + def __eq__(self, o) -> bool: + return isinstance(o, Define) and (self.name == o.name) and (self.inverted_ == o.inverted_) +@final +class Clause: + defines: List[Define] + + def __init__(self, defines: Union[List[Define], str] = []) -> None: + if isinstance(defines, str): + if defines == "": + self.defines = [] + else: + self.defines = list( + map( + lambda x: + Define(DefineType(x[9:-1] if x[0] == '!' else x[8:-1]), x[0] == '!') + , defines.split(" && ") + ) + ) + else: + self.defines = [d.copy() for d in defines] + def copy(self) -> "Clause": + return Clause(self.defines) + + def append(self, define: Define) -> "Clause": + if any((define2.name == define.name) and (define2.inverted_ != define.inverted_) for define2 in self.defines): + raise ValueError("Tried to append an incompatible clause") + + self.defines.append(define) + return self + def invert_last(self) -> "Clause": + self.defines[-1].invert() + return self + def pop_last(self) -> "Clause": + if len(self.defines) > 0: self.defines.pop() + return self + + def empty(self) -> bool: + return self.defines == [] + + def __str__(self) -> str: + return " && ".join(map(str, self.defines)) + def __hash__(self): + return hash(str(self)) + def __eq__(self, o) -> bool: + return isinstance(o, Clause) and (self.defines == o.defines) +ClausesStr = str +@final +class Clauses: + """ + Represent a list of clauses, aka a list of or-ed together and-ed "defined()" + conditions + """ + clauses: List[Clause] + + def __init__(self, clauses: Union[List[Clause], str] = []) -> None: + if isinstance(clauses, str): + if clauses == "()": + self.clauses = [] + elif ") || (" in clauses: + self.clauses = list(map(Clause, clauses[1:-1].split(") || ("))) + else: + self.clauses = [Clause(clauses)] + else: + self.clauses = clauses[:] + def copy(self) -> "Clauses": + return Clauses(self.clauses[:]) + + def add(self, defines: Clause) -> "Clauses": + self.clauses.append(defines) + return self + + def empty(self) -> bool: + return self.clauses == [] + + def splitdef(self) -> Sequence[int]: + """ + splitdef -- Sorting key function for #ifdefs + + All #if defined(...) are sorted first by the length of its string + representation, then by the number of clauses, then by the number of + '&&' in each clause and then by the "key" of the tested names (left to + right, inverted placed after non-inverted). + """ + + ret = [len(str(self)), len(self.clauses)] if len(self.clauses) > 0 else [-1] + for cunj in self.clauses: + ret.append(len(cunj.defines)) + for cunj in self.clauses: + for d in cunj.defines: + ret.append(d.value()) + return ret + + def reduce(self) -> None: + """ + reduce -- Reduces the number of clauses in-place + + Removes the most possible number of conditions, both by removing + conditions and by removing entire clauses. + + As a side effect, sorts itself. + """ + # Early breaks + if any(c.empty() for c in self.clauses): + self.clauses = [] + return + if len(self.clauses) == 0: + return + elif len(self.clauses) == 1: + clause = Clause() + for define in self.clauses[0].defines: + if define in clause.defines: + continue + elif define.inverted() in clause.defines: + clause = Clause(',') # This should never happen (and never happens without breaking encapsulation) + else: + clause.append(define) + clause.defines.sort(key=lambda d: Define.defines.index(d.name)) + self.clauses = [clause] + return + elif len(self.clauses) == 2: + if len(self.clauses[0].defines) == len(self.clauses[1].defines) == 1: + if self.clauses[0].defines[0].inverted() == self.clauses[1].defines[0]: + self.clauses = [] + return + + # Quine-McCluskey algorithm + # matches: list of (matches, inverted_mask) + needed: List[Tuple[int, int]] = [ + (i, 0) + for i in range(1< 0: + combined: List[Tuple[int, int]] = [] + combinable: List[bool] = [False] * len(last_combined) + while len(last_combined) > 0: + attempt = last_combined[-1] + for idx, (i, m) in enumerate(last_combined): + if idx == len(last_combined) - 1: + if not combinable[idx]: + uncombinable.append(attempt) + elif m == attempt[1]: + if (i ^ attempt[0]) & ((i ^ attempt[0]) - 1) != 0: + continue # More than 1 bit of difference + + combinable[idx] = True + combinable[len(last_combined) - 1] = True + add = (i | attempt[0], m | (i ^ attempt[0])) + if add in combined: + continue # Aleady added + combined.append(add) + last_combined.pop() + last_combined = combined + + matches: Dict[int, List[Tuple[int, int]]] = { + i: [combination for combination in uncombinable if (i | combination[1]) == combination[0]] for i, _ in needed + } + self.clauses = [] + matches_size: int = 1 + while len(matches) != 0: + match_found = True + while match_found: + match_found = False + for i in matches: + if len(matches[i]) < matches_size: + raise NotImplementedError("There seems to be an error in the algorithm") + elif len(matches[i]) == matches_size: + match_found = True + self.clauses.append( + Clause([ + Define( + n, + matches[i][0][0] & (1 << j) == 0 + ) for j, n in enumerate(Define.defines) if matches[i][0][1] & (1 << j) == 0 + ])) + self.clauses[-1].defines.sort(key=lambda d: Define.defines.index(d.name)) + to_erase: List[int] = [] + for j in matches: + if matches[i][0] in matches[j]: + to_erase.append(j) + for j in to_erase: + del matches[j] + break + matches_size = matches_size + 1 + self.clauses.sort(key=lambda c: (len(c.defines), [Define.defines.index(d.name) for d in c.defines])) + + def __str__(self) -> ClausesStr: + if len(self.clauses) == 1: + return str(self.clauses[0]) + else: + return "(" + ") || (".join(map(str, self.clauses)) + ")" + def __hash__(self): + return hash(str(self)) + def __eq__(self, o) -> bool: + return isinstance(o, Clauses) and (self.clauses == o.clauses) + +JumbledFunctions = CustOrderedDictList[Clause, Function] +FilesSpecific = Dict[Filename, FileSpec] + +SortedGlobals = CustOrderedDictList[Clauses, FunctionType] +SortedRedirects = CustOrderedDictList[Clauses, FunctionType] + +def readFiles(files: Iterable[str]) -> Tuple[JumbledFunctions, JumbledFunctions, FilesSpecific]: + """ + readFiles + + This function is the one that parses the files. + """ + + gbls: JumbledFunctions = CustOrderedDictList() + redirects: JumbledFunctions = CustOrderedDictList() + filespecs: FilesSpecific = {} + + symbols: Dict[str, Filename] = {} + need_halt: bool = False + + for filepath in files: + filename: Filename = filepath.split("/")[-1] + dependants: Clause = Clause() + + filespec = FileSpec() + filespecs[filename[:-10]] = filespec + + def add_symbol_name(symname: Optional[str], weak: bool = False, symsname: Dict[str, List[Tuple[str, bool]]] = {"": []}): + # Optional arguments are evaluated only once! + nonlocal need_halt + if symname is None: + for c in symsname: + if (c != "") and (len(symsname[c]) != 0): + # Note: if this condition ever raises, check the wrapper pointed by it. + # If you find no problem, comment the error below, add a "pass" below (so python is happy) + # and open a ticket so I can fix this. + raise NotImplementedError("Some symbols are only implemented under one condition '{0}' (probably) ({1}/{2})" + .format(c, symsname[c][0][0], filename) + " [extra note in the script]") + for s, w in symsname[c]: + if w: continue # Weak symbols never conflict with others in different libraries + + if s in ( + '_init', '_fini', + '__bss_start', '__bss_start__', '__bss_end__', '_bss_end__', + '__data_start', '_edata', + '_end', '__end__'): + continue # Always allow those symbols [TODO: check if OK] + if s in symbols: + # Check for resemblances between symbols[s] and filename + # if filename.startswith(symbols[s][:-12]) or symbols[s].startswith(filename[:-12]): + # # Probably OK + # continue + # Manual incompatible libs detection + match = lambda l, r: (filename[7:-10], symbols[s][7:-10]) in [(l, r), (r, l)] + if match("gdkx112", "gdk3") \ + or match("gtkx112", "gtk3") \ + or match("libjpeg", "libjpeg62") \ + or match("libncurses", "libncurses6") \ + or match("libncurses", "libncursesw") \ + or match("libncurses6", "libncursesw") \ + or match("libtinfo6", "libtinfo") \ + or match("png12", "png16") \ + or match("sdl1", "sdl2") \ + or match("sdl1image", "sdl2image") \ + or match("sdl1mixer", "sdl2mixer") \ + or match("sdl1net", "sdl2net") \ + or match("sdl1ttf", "sdl2ttf") \ + or match("smpeg", "smpeg2") \ + or match("udev0", "udev1") \ + \ + or match("libc", "tcmallocminimal") \ + or match("libc", "ldlinux") \ + : + # libc and ldlinux have some "__libc_" data symbols in common... TODO check if ok + continue + + # Note: this test is very (too) simple. If it ever raises, comment + # `need_halt = True` and open an issue. + print("The symbol {0} is declared in multiple files ({1}/{2})" + .format(s, symbols[s], filename) + " [extra note in the script]", file=sys.stderr) + need_halt = True + symbols[s] = filename + else: + symname = symname.strip() + if symname == "": + raise ValueError("This symbol name (\"\") is suspicious... ({0})".format(filename)) + + l = len(dependants.defines) + already_pst = any(s == symname for s, _ in symsname[""]) + if l == 1: + symsname.setdefault(str(dependants), []) + already_pst = already_pst or any(s == symname for s, _ in symsname[str(dependants)]) + if already_pst: + print("The symbol {0} is duplicated! ({1})".format(symname, filename), file=sys.stderr) + need_halt = True + return + if l == 1: + s = str(dependants.defines[0].inverted()) + if (s in symsname) and ((symname, weak) in symsname[s]): + symsname[s].remove((symname, weak)) + symsname[""].append((symname, weak)) + elif (s in symsname) and ((symname, not weak) in symsname[s]): + print("The symbol {0} doesn't have the same 'weakness' in different conditions! ({1})" + .format(symname, filename), file=sys.stderr) + need_halt = True + else: + symsname[str(dependants)].append((symname, weak)) + elif l == 0: + symsname[""].append((symname, weak)) + with open(filepath, 'r') as file: for line in file: - def fail(s, causedby=None): - if causedby: - raise NotImplementedError(s + " ({0}:{1})".format(filename, line[:-1])) from causedby - else: - raise NotImplementedError(s + " ({0}:{1})".format(filename, line[:-1])) - ln = line.strip() - # If the line is a `#' line (#ifdef LD80BITS/#ifndef LD80BITS/header) - if ln.startswith("#"): - preproc_cmd = ln[1:].strip() - try: + + try: + # If the line is a `#' line (#ifdef LD80BITS/#ifndef LD80BITS/header) + if ln.startswith("#"): + preproc_cmd = ln[1:].strip() if preproc_cmd.startswith("if defined(GO)"): continue #if defined(GO) && defined(GOM)... elif preproc_cmd.startswith("if !(defined(GO)"): @@ -125,271 +806,169 @@ def fail(s, causedby=None): elif preproc_cmd.startswith("include"): continue #inherit other library elif preproc_cmd.startswith("endif"): - if dependants != []: - dependants.pop() + dependants.pop_last() elif preproc_cmd.startswith("ifdef"): - if preproc_cmd[5:].strip() not in defines: - raise KeyError(preproc_cmd[5:].strip()) - dependants.append("defined(" + preproc_cmd[5:].strip() + ")") + dependants.append(Define(DefineType(preproc_cmd[5:].strip()), False)) elif preproc_cmd.startswith("ifndef"): - if preproc_cmd[6:].strip() not in defines: - raise KeyError(preproc_cmd[6:].strip()) - dependants.append("!defined(" + preproc_cmd[6:].strip() + ")") + dependants.append(Define(DefineType(preproc_cmd[6:].strip()), True)) elif preproc_cmd.startswith("else"): - dependants[-1] = invert(dependants[-1]) + dependants.invert_last() else: - fail("Unknown preprocessor directive: {0}".format(preproc_cmd.split(" ")[0])) - except KeyError as k: - fail("Unknown key: {0}".format(k.args[0]), k) - # If the line is a `GO...' line (GO/GOM/GO2/...)... - elif ln.startswith("GO"): - # ... then look at the second parameter of the line - gotype = ln.split("(")[0].strip() - funname = ln.split(",")[0].split("(")[1].strip() - ln = ln.split(",")[1].split(")")[0].strip() + raise NotImplementedError("Unknown preprocessor directive: {0}".format(preproc_cmd.split(" ")[0])) - if len(ln) < 3: - fail("Type {0} too short".format(ln)) - if "E" in ln: - if ("E" in ln[:2]) or ("E" in ln[3:]): - fail("emu64_t* not as the first parameter") - if len(ln) < 4: - fail("Type {0} too short".format(ln)) - if ln[0] not in values: - fail("Invalid return type {0}".format(ln[0])) + # If the line is a `GO...' line (GO/GOM/GO2/...)... + elif ln.startswith("GO"): + # ... then look at the second parameter of the line + try: + gotype = ln.split("(")[0].strip() + funname = ln.split(",")[0].split("(")[1].strip() + ln = ln.split(",")[1].split(")")[0].strip() + except IndexError: + raise NotImplementedError("Invalid GO command") + + fun = Function(funname, FunctionType(ln, filespec), gotype, filespec, filename, line) + if not filename.endswith("_genvate.h"): + add_symbol_name(fun.name, fun.isweak) + + if hasattr(fun, 'invalid'): + need_halt = True + continue + + if fun.type.redirect or fun.type.usestruct: + redirects[dependants.copy()].append(fun) + else: + gbls[dependants.copy()].append(fun) - if ln[1] != "F": - fail("Bad middle letter {0}".format(ln[1])) - if any(c not in values for c in ln[2:]) or (('v' in ln[2:]) and (len(ln) > 3)): - old = ln - # This needs more work - acceptables = ['v', '0', '1'] + values - if any(c not in acceptables for c in ln[2:]): - fail("Invalid type {0}".format(ln[2:])) - # Ok, this is acceptable: there is 0, 1 and/or void - ln = ln[:2] + (ln[2:] - .replace("v", "") # void -> nothing - .replace("0", "p") # 0 -> pointer - .replace("1", "i")) # 1 -> integer - redirects.setdefault(" && ".join(dependants), {}) - redirects[" && ".join(dependants)][old] = ln - # Simply append the function name if it's not yet existing - gbl.setdefault(" && ".join(dependants), []) - if ln not in gbl[" && ".join(dependants)]: - gbl[" && ".join(dependants)].append(ln) + # If the line is a structure metadata information... + elif ln.startswith("//%S"): + metadata = [e for e in ln.split() if e] + if len(metadata) != 4: + # If you need an empty replacement, please open a PR + raise NotImplementedError("Invalid structure metadata supply (too many/not enough fields)") + if metadata[0] != "//%S": + raise NotImplementedError("Invalid structure metadata supply (invalid signature)") + + filespec.registerStruct(metadata[1], metadata[2], metadata[3]) - if filename == "wrappedd3dadapter9_gen.h": - pass # Special case... - elif ln[2] == 'E': - if "//%%" in line: - # Do not dlsym functions containing "//%%" as metadata + # If the line contains any symbol name... + elif ("GO" in ln) or ("DATA" in ln): + if filename.endswith("_genvate.h"): + continue + # Probably "//GO(..., " or "DATA(...," at least + try: + symname = ln.split('(')[1].split(',')[0].strip() + add_symbol_name(symname) + except IndexError: + # Oops, it wasn't... pass - elif gotype == "GOS": - # Scan the rest of the line to extract the return structure ID - if filename[:-10] not in mystructs: - fail("No structure info in the file") - if "//%" not in line: - fail("Invalid GOS (missing structure ID info)") - if ln[0] != 'p': - fail("Invalid GOS return type ('{0}' and not 'p')".format(ln[0])) - #if (ln[2] != 'p') and ((ln[2] != 'E') or (ln[3] != 'p')): -> only allow pFEp for now - # fail("Invalid GOS first parameter ('{0}' and not 'p' or 'Ep')".format(ln[2:4])) - if (ln[2] != 'E') or (ln[3] != 'p'): - fail("Invalid GOS first parameter ('{0}' and not 'Ep')".format(ln[2:4])) - - sid = line.split("//%")[1].split(" ")[0].strip() - if sid[0] == '{': - # Change type completely, not just the return type... - if sid[-1] != '}': - fail("Invalid type (EOL or space met, expected '}')") - if len(sid) < 5: - fail("Invalid type (Type {0} too short)".format(sid[1:-1])) - if sid[2] != "F": - fail("Invalid type (Bad middle letter {0})".format(sid[2])) - inval_char = lambda c:\ - (c not in mystructs[filename[:-10]]) and (c not in acceptables) \ - or (c == 'E') or (c == 'e') - if inval_char(sid[1]): - fail("Invalid type (Invalid return type {0})".format(sid[1])) - if any(map(inval_char, sid[3:-1])): - fail("Invalid type (Invalid type {0})".format(sid[3:-1])) - mytypedefs.setdefault(filename[:-10], {}) - mytypedefs[filename[:-10]].setdefault(sid[1:-1], []) - mytypedefs[filename[:-10]][sid[1:-1]].append((0, funname)) - else: - if len(sid) != 1: - fail("Invalid structure ID {0} (length is too big)".format(sid)) - if sid not in mystructs[filename[:-10]]: - fail("Invalid structure ID {0} (unknown ID)".format(sid)) - mytypedefs.setdefault(filename[:-10], {}) - mytypedefs[filename[:-10]].setdefault(sid + "F" + ln[4:], []) - mytypedefs[filename[:-10]][sid + "F" + ln[4:]].append((1, funname)) - elif "//%{" in line: - # Change type completely... - # ...Maybe? - if filename[:-10] not in mystructs: - fail("No structure info in the file") - - newtype = line.split("//%")[1].split(" ")[0].strip() - if newtype[-1] != '}': - fail("Invalid type (EOL or space met, expected '}')") - if len(newtype) < 5: - fail("Invalid type (Type {0} too short)".format(newtype[1:-1])) - if newtype[2] != "F": - fail("Invalid type (Bad middle letter {0})".format(newtype[2])) - inval_char = lambda c:\ - (c not in mystructs[filename[:-10]]) and (c not in acceptables) \ - or (c == 'E') or (c == 'e') - if inval_char(newtype[1]): - fail("Invalid type (Invalid return type {0})".format(newtype[1])) - if any(map(inval_char, newtype[3:-1])): - fail("Invalid type (Invalid type {0})".format(newtype[3:-1])) - mytypedefs.setdefault(filename[:-10], {}) - mytypedefs[filename[:-10]].setdefault(newtype[1:-1], []) - mytypedefs[filename[:-10]][newtype[1:-1]].append((2, funname)) - else: - # filename isn't stored with the '_private.h' part - if not filename.endswith('_private.h'): - fail("??? {0}".format(filename)) - if len(ln) > 3: - ln = ln[:2] + ln[3:] - else: - ln = ln[:2] + "v" - mytypedefs.setdefault(filename[:-10], {}) - mytypedefs[filename[:-10]].setdefault(ln, []) - mytypedefs[filename[:-10]][ln].append((3, funname)) - elif ln.startswith("//%S"): - # Extract a structure ID-name pair - data = [s for s in map(lambda s: s.strip(), ln.split(" ")) if s != ""] - if len(data) != 3: - fail("Too much data ({0})".format(len(data))) - if not filename.endswith('_private.h'): - fail("??? {0}".format(filename)) - if (data[0] != "//%S") or (len(data[1]) != 1): - fail("Invalid structure data {0} {1}".format(data[0], data[1])) - if data[1] in values: - fail("{0} cannot be used as a structure type".format(data[1])) - mystructs.setdefault(filename[:-10], {}) - if data[1] in mystructs[filename[:-10]]: - fail("Duplicate structure ID {0} ({1}/{2})".format(data[1], mystructs[filename[:-10]], data[2])) - mystructs[filename[:-10]][data[1]] = data[2] - mystructs_vals.setdefault(filename[:-10], []) - mystructs_vals[filename[:-10]].append(data[1]) - - if ("" not in gbl) or ("" not in redirects): - print("\033[1;31mThere is suspiciously not many types...\033[m") - print("Check the CMakeLists.txt file. If you are SURE there is nothing wrong" - " (as a random example, `set()` resets the variable...), then comment out the following return.") - print("(Also, the program WILL crash later if you proceed.)") - return 2 # Check what you did, not proceeding + except Exception as e: + raise NotImplementedError("{0}:{1}".format(filename, line[:-1])) from e + + if filename.endswith("_genvate.h"): + del filespecs[filename[:-10]] + + add_symbol_name(None) + FunctionType.getSingletons().clear() - gbl_vals = {} - for k in gbl: - ks = k.split(" && ") - for v in gbl[k]: - if k == "": - gbl_vals[v] = [] - continue - if v in gbl_vals: - if gbl_vals[v] == []: - continue - for other_key in gbl_vals[v]: - other_key_vals = other_key.split(" && ") - for other_key_val in other_key_vals: - if other_key_val not in ks: - break - else: - break - else: - gbl_vals[v].append(k) - else: - gbl_vals[v] = [k] - for v in gbl_vals: - for k in gbl_vals[v]: - if " && ".join([invert(v2) for v2 in k.split(" && ")]) in gbl_vals[v]: - gbl_vals[v] = [] - break - gbl = {} - gbl_idxs = [] - for k in gbl_vals: - if len(gbl_vals[k]) == 1: - key = gbl_vals[k][0] - else: - key = "(" + (") || (".join(gbl_vals[k])) + ")" - gbl[key] = gbl.get(key, []) + [k] - if (key not in gbl_idxs) and (key != "()"): - gbl_idxs.append(key) - gbl_idxs.sort(key=lambda v: splitdef(v, defines)) - - redirects_vals = {} - for k in redirects: - ks = k.split(" && ") - for v in redirects[k]: - if k == "": - redirects_vals[(v, redirects[k][v])] = [] - continue - if (v, redirects[k][v]) in redirects_vals: - if redirects_vals[(v, redirects[k][v])] == []: - continue - for other_key in redirects_vals[(v, redirects[k][v])]: - if other_key == "()": - break - other_key_vals = other_key.split(" && ") - for other_key_val in other_key_vals: - if other_key_val not in ks: - break - else: - break - else: - redirects_vals[(v, redirects[k][v])].append(k) - else: - redirects_vals[(v, redirects[k][v])] = [k] - redirects = {} - redirects_idxs = [] - for k, v in redirects_vals: - key = "(" + (") || (".join(redirects_vals[(k, v)])) + ")" - if key in redirects: - redirects[key].append([k, v]) - else: - redirects[key] = [[k, v]] - if (key not in redirects_idxs) and (key != "()"): - redirects_idxs.append(key) - redirects_idxs.sort(key=lambda v: splitdef(v, defines)) - - # Sort the tables - for k in gbl: - gbl[k].sort(key=lambda v: splitchar(v)) - values = values + ['0', '1'] - for k in redirects: - redirects[k].sort(key=lambda v: splitchar(v[0]) + [-1] + splitchar(v[1])) - values = values[:-2] - mytypedefs_vals = {} - for fn in mytypedefs: - if fn in mystructs: - values = values + list(mystructs[fn].keys()) - mytypedefs_vals[fn] = sorted(mytypedefs[fn].keys(), key=lambda v: splitchar(v)) - if fn in mystructs: - values = values[:-len(mystructs[fn])] - for v in mytypedefs_vals[fn]: - mytypedefs[fn][v].sort() + if need_halt: + raise ValueError("Fix all previous errors before proceeding") - # Check if there was any new functions - functions_list = "" - for k in ["()"] + gbl_idxs: - for v in gbl[k]: - functions_list = functions_list + "#" + k + " " + v + "\n" - for k in ["()"] + redirects_idxs: - for v in redirects[k]: - functions_list = functions_list + "#" + k + " " + v[0] + " -> " + v[1] + "\n" - for fn in sorted(mystructs.keys()): - for t in mystructs_vals[fn]: - # Structure Definition - functions_list = functions_list + fn + "/Sd" + t + mystructs[fn][t] + "\n" - for fn in sorted(mytypedefs.keys()): - for t in mytypedefs_vals[fn]: - # Structure Usage - for tnum, f in mytypedefs[fn][t]: - functions_list = functions_list + fn + "/Su" + t + str(tnum) + f + "\n" + return gbls, redirects, filespecs + +def sortArrays(gbl_funcs: JumbledFunctions, red_funcs: JumbledFunctions, filespecs: FilesSpecific) \ + -> Tuple[SortedGlobals, SortedRedirects]: + # First sort file specific stuff + for fn in filespecs: + filespecs[fn].typedefs.sort(key=_BareFunctionType.splitchar) + for funtype in filespecs[fn].typedefs: + filespecs[fn].typedefs[funtype].sort(key=lambda f: f.name) + + filespecs[fn].structs.sort() + filespecs[fn].structsuses.sort(key=FunctionType.splitchar) + + # Now, take all function types, and make a new table gbl_vals + # This table contains all #if conditions for when a function type needs to + # be generated. + def add_to_vals(vals: Dict[FunctionType, Clauses], t: FunctionType, clause: Clause) -> None: + vals.setdefault(t, Clauses()) + if clause in vals[t].clauses: return + vals[t].add(clause) + + gbl_vals: Dict[FunctionType, Clauses] = {} + for clause in gbl_funcs: + for f in gbl_funcs[clause]: + add_to_vals(gbl_vals, f.type, clause) + for clause in red_funcs: + for f in red_funcs[clause]: + assert(f.type.redirected is not None) + add_to_vals(gbl_vals, f.type.redirected, clause) + + # Remove duplicate/useless conditions (and sort) + for t in gbl_vals: + gbl_vals[t].reduce() + + # Now create a new gbls + # gbls will contain the final version of gbls (without duplicates, based on + # gbl_vals), meaning, a dict from clauses to function types to implement + gbls: SortedGlobals = CustOrderedDictList() + for funtype in gbl_vals: + gbls[gbl_vals[funtype]].append(funtype) + # Sort the #if clauses as defined in `splitdef` + gbls.sort(key=Clauses.splitdef) + + # Sort the function types as defined in `splitchar` + for clauses in gbls: + gbls[clauses].sort(key=FunctionType.splitchar) + + # This map will contain all additional function types that are "redirected" + # to an already defined type (with some remapping). + red_vals: Dict[FunctionType, Clauses] = {} + for clause in red_funcs: + for f in red_funcs[clause]: + if isinstance(f.type, StructFunctionType): continue + assert(f.type.redirected is not None) + add_to_vals(red_vals, f.type, clause) + + # Also do the same sorting as before (it also helps keep the order + # in the file deterministic) + for t in red_vals: + red_vals[t].reduce() + + redirects: SortedRedirects = CustOrderedDictList() + for funtype in red_vals: + redirects[red_vals[funtype]].append(funtype) + redirects.sort(key=Clauses.splitdef) + + def fail(): assert(False) + for clauses in redirects: + redirects[clauses].sort(key=lambda v: fail() if v.redirected is None else v.splitchar() + v.redirected.splitchar()) + + return gbls, redirects + +def checkRun(root: str, gbls: SortedGlobals, redirects: SortedRedirects, filesspec: FilesSpecific) -> Optional[str]: + # Check if there was any new functions compared to last run + functions_list: str = "" + for clauses in gbls: + for v in gbls[clauses]: + functions_list = functions_list + "#" + str(clauses) + " " + v.orig + "\n" + for clauses in redirects: + for v in redirects[clauses]: + assert(v.redirected is not None) + functions_list = functions_list + "#" + str(clauses) + " " + v.orig + " -> " + v.redirected.orig + "\n" + for filename in sorted(filesspec.keys()): + functions_list = functions_list + filename + ":\n" + for st in filesspec[filename].structs: + struct = filesspec[filename].structs[st] + functions_list = functions_list + \ + "% " + st + " " + struct.name + " " + struct.repl + "\n" + for _bare in filesspec[filename].typedefs: + functions_list = functions_list + "- " + _bare.orig + ":\n" + for fn in filesspec[filename].typedefs[_bare]: + if fn.no_dlsym: continue + functions_list = functions_list + " - " + fn.name + "\n" + for funtype in filesspec[filename].structsuses: + assert(funtype.redirected is not None) + functions_list = functions_list + "% " + funtype.orig + " -> " + funtype.redirected.orig + "\n" # functions_list is a unique string, compare it with the last run try: @@ -400,328 +979,407 @@ def fail(s, causedby=None): # Mark as OK for CMake with open(os.path.join(root, "src", "wrapped", "generated", "functions_list.txt"), 'w') as file: file.write(functions_list) - return 0 + return None except IOError: # The file does not exist yet, first run pass - # Now the files rebuilding part + return functions_list + +def generate_files(root: str, files: Iterable[str], ver: str, gbls: SortedGlobals, redirects: SortedRedirects, \ + filespecs: FilesSpecific) -> None: # Files header and guard files_header = { - "wrapper.c": """/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v{version}) - *****************************************************************/ -#include -#include -#include - -#include "wrapper.h" -#include "emu/x86emu_private.h" -#include "emu/x87emu_private.h" -#include "regs.h" -#include "x86emu.h" - -typedef union ui64_s {lbr} - int64_t i; - uint64_t u; - uint32_t d[2]; -{rbr} ui64_t; - -typedef struct _2uint_struct_s {lbr} - uint32_t a; - uint32_t b; -{rbr} _2uint_struct_t; - -extern void* my__IO_2_1_stderr_; -extern void* my__IO_2_1_stdin_ ; -extern void* my__IO_2_1_stdout_; - -static void* io_convert(void* v) -{lbr} - if(!v) - return v; - if(v==my__IO_2_1_stderr_) - return stderr; - if(v==my__IO_2_1_stdin_) - return stdin; - if(v==my__IO_2_1_stdout_) - return stdout; - return v; -{rbr} - -typedef struct my_GValue_s -{lbr} - int g_type; - union {lbr} - int v_int; - int64_t v_int64; - uint64_t v_uint64; - float v_float; - double v_double; - void* v_pointer; - {rbr} data[2]; -{rbr} my_GValue_t; - -static void alignGValue(my_GValue_t* v, void* value) -{lbr} - v->g_type = *(int*)value; - memcpy(v->data, value+4, 2*sizeof(double)); -{rbr} -static void unalignGValue(void* value, my_GValue_t* v) -{lbr} - *(int*)value = v->g_type; - memcpy(value+4, v->data, 2*sizeof(double)); -{rbr} - -void* VulkanFromx86(void* src, void** save); -void VulkanTox86(void* src, void* save); - -#define ST0val ST0.d - -int of_convert(int); - -""", - "wrapper.h": """/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v{version}) - *****************************************************************/ -#ifndef __WRAPPER_H_ -#define __WRAPPER_H_ -#include -#include - -typedef struct x86emu_s x86emu_t; - -// the generic wrapper pointer functions -typedef void (*wrapper_t)(x86emu_t* emu, uintptr_t fnc); - -// list of defined wrapper -// v = void, i = int32, u = uint32, U/I= (u)int64 -// l = signed long, L = unsigned long (long is an int with the size of a pointer) -// p = pointer, P = callback -// f = float, d = double, D = long double, K = fake long double -// V = vaargs, E = current x86emu struct, e = ref to current x86emu struct -// 0 = constant 0, 1 = constant 1 -// o = stdout -// C = unsigned byte c = char -// W = unsigned short w = short -// O = libc O_ flags bitfield -// S = _IO_2_1_stdXXX_ pointer (or FILE*) -// Q = ... -// 2 = struct of 2 uint -// P = Vulkan struture pointer -// G = a single GValue pointer -// N = ... automatically sending 1 arg -// M = ... automatically sending 2 args - -""", - "fntypes.h": """/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v{version}) - *****************************************************************/ -#ifndef __{filename}TYPES_H_ -#define __{filename}TYPES_H_ - -#ifndef LIBNAME -#error You should only #include this file inside a wrapped*.c file -#endif -#ifndef ADDED_FUNCTIONS -#define ADDED_FUNCTIONS() -#endif - -""" + "wrapper.c": """ + #include + #include + #include + + #include "wrapper.h" + #include "emu/x86emu_private.h" + #include "emu/x87emu_private.h" + #include "regs.h" + #include "x86emu.h" + + typedef union ui64_s {lbr} + int64_t i; + uint64_t u; + uint32_t d[2]; + {rbr} ui64_t; + + typedef struct _2uint_struct_s {lbr} + uint32_t a; + uint32_t b; + {rbr} _2uint_struct_t; + + extern void* my__IO_2_1_stderr_; + extern void* my__IO_2_1_stdin_ ; + extern void* my__IO_2_1_stdout_; + + static void* io_convert(void* v) + {lbr} + if(!v) + return v; + if(v==my__IO_2_1_stderr_) + return stderr; + if(v==my__IO_2_1_stdin_) + return stdin; + if(v==my__IO_2_1_stdout_) + return stdout; + return v; + {rbr} + + typedef struct my_GValue_s + {lbr} + int g_type; + union {lbr} + int v_int; + int64_t v_int64; + uint64_t v_uint64; + float v_float; + double v_double; + void* v_pointer; + {rbr} data[2]; + {rbr} my_GValue_t; + + static void alignGValue(my_GValue_t* v, void* value) + {lbr} + v->g_type = *(int*)value; + memcpy(v->data, value+4, 2*sizeof(double)); + {rbr} + static void unalignGValue(void* value, my_GValue_t* v) + {lbr} + *(int*)value = v->g_type; + memcpy(value+4, v->data, 2*sizeof(double)); + {rbr} + + void* VulkanFromx86(void* src, void** save); + void VulkanTox86(void* src, void* save); + + #define ST0val ST0.d + + int of_convert(int); + + """, + "wrapper.h": """ + #ifndef __WRAPPER_H_ + #define __WRAPPER_H_ + #include + #include + + typedef struct x86emu_s x86emu_t; + + // the generic wrapper pointer functions + typedef void (*wrapper_t)(x86emu_t* emu, uintptr_t fnc); + + // list of defined wrappers + // E = current x86emu struct + // v = void + // C = unsigned byte c = char + // W = unsigned short w = short + // u = uint32, i = int32 + // U = uint64, I = int64 + // L = unsigned long, l = signed long (long is an int with the size of a pointer) + // p = pointer + // f = float, d = double, D = long double, K = fake long double + // V = vaargs, s = address on the stack (doesn't move forward the pointer) + // O = libc O_ flags bitfield + // o = stdout + // S = _IO_2_1_stdXXX_ pointer (or FILE*) + // 2 = struct of 2 uint + // N = ... automatically sending 1 arg + // M = ... automatically sending 2 args + // P = Vulkan struct pointer, G = a single GValue pointer + + """, + "fntypes.h": """ + #ifndef __{filename}TYPES_H_ + #define __{filename}TYPES_H_ + + #ifndef LIBNAME + #error You should only #include this file inside a wrapped*.c file + #endif + #ifndef ADDED_FUNCTIONS + #define ADDED_FUNCTIONS() + #endif + + """, + "fndefs.h": """ + #ifndef __{filename}DEFS_H_ + #define __{filename}DEFS_H_ + + """, + "fnundefs.h": """ + #ifndef __{filename}UNDEFS_H_ + #define __{filename}UNDEFS_H_ + + """ } - files_guard = {"wrapper.c": """""", + files_guard = { + "wrapper.c": """ + """, "wrapper.h": """ -#endif // __WRAPPER_H_ -""", + #endif // __WRAPPER_H_ + """, "fntypes.h": """ -#endif // __{filename}TYPES_H_ -""" + #endif // __{filename}TYPES_H_ + """, + "fndefs.h": """ + + #endif // __{filename}DEFS_H_ + """, + "fnundefs.h": """ + + #endif // __{filename}UNDEFS_H_ + """ } + banner = "/********************************************************" + ('*'*len(ver)) + "***\n" \ + " * File automatically generated by rebuild_wrappers.py (v" + ver + ") *\n" \ + " ********************************************************" + ('*'*len(ver)) + "***/\n" + trim: Callable[[str], str] = lambda string: '\n'.join(line[2:] for line in string.splitlines())[1:] + # Yes, the for loops are inverted. This is because both dicts should have the same keys. + for fhdr in files_guard: + files_header[fhdr] = banner + trim(files_header[fhdr]) + for fhdr in files_header: + files_guard[fhdr] = trim(files_guard[fhdr]) + + # Typedefs + # E v c w i I C W u U f d D K l L p V O S 2 P G N M s + tdtypes = ["x86emu_t*", "void", "int8_t", "int16_t", "int32_t", "int64_t", "uint8_t", "uint16_t", "uint32_t", "uint64_t", "float", "double", "long double", "double", "intptr_t", "uintptr_t", "void*", "void*", "int32_t", "void*", "_2uint_struct_t", "void*", "void*", "...", "...", "void*"] + if len(FileSpec.values) != len(tdtypes): + raise NotImplementedError("len(values) = {lenval} != len(tdtypes) = {lentypes}".format(lenval=len(FileSpec.values), lentypes=len(tdtypes))) + def generate_typedefs(funs: Iterable[FunctionType], file): + for funtype in funs: + def getstr(i: int) -> str: + if i < len(tdtypes): + return tdtypes[i] + else: + # We are in a *types.h file + assert(isinstance(funtype, _BareFunctionType) and funtype.isstruct) + return funtype.filespec.structs[funtype.filespec.structs.__keys__[i - len(tdtypes)]].name + if funtype.orig.endswith("Ev"): + file.write("typedef " + getstr(funtype.getcharidx(0)) + " (*" + funtype.orig + "_t)" + + "(" + getstr(funtype.getchar('E')) + ");\n") + else: + file.write("typedef " + getstr(funtype.getcharidx(0)) + " (*" + funtype.orig + "_t)" + + "(" + ', '.join(getstr(funtype.getcharidx(i)) for i in range(2, len(funtype.orig))) + ");\n") + + # Wrappers + # E v c w i I C W u U f d D K l L p V O S 2 P G N M s + deltas = [0, 4, 4, 4, 4, 8, 4, 4, 4, 8, 4, 8, 12, 12, 4, 4, 4, 1, 4, 4, 8, 4, 4, 0, 0, 0] + vals = [ + "\n#error Invalid return type: emulator\n", # E + "fn({0});", # v + "R_EAX=fn({0});", # c + "R_EAX=fn({0});", # w + "R_EAX=fn({0});", # i + "ui64_t r; r.i=fn({0}); R_EAX=r.d[0]; R_EDX=r.d[1];", # I + "R_EAX=(unsigned char)fn({0});", # C + "R_EAX=(unsigned short)fn({0});", # W + "R_EAX=(uint32_t)fn({0});", # u + "ui64_t r; r.u=(uint64_t)fn({0}); R_EAX=r.d[0]; R_EDX=r.d[1];", # U + "float fl=fn({0}); fpu_do_push(emu); ST0val = fl;", # f + "double db=fn({0}); fpu_do_push(emu); ST0val = db;", # d + "long double ld=fn({0}); fpu_do_push(emu); ST0val = ld;", # D + "double db=fn({0}); fpu_do_push(emu); ST0val = db;", # K + "R_EAX=(intptr_t)fn({0});", # l + "R_EAX=(uintptr_t)fn({0});", # L + "R_EAX=(uintptr_t)fn({0});", # p + "\n#error Invalid return type: va_list\n", # V + "\n#error Invalid return type: at_flags\n", # O + "\n#error Invalid return type: _io_file*\n", # S + "\n#error Invalid return type: _2uint_struct\n", # 2 + "\n#error Invalid return type: Vulkan Struct\n", # P + "\n#error Invalid return type: GValue Pointer\n", # G + "\n#error Invalid return type: ... with 1 arg\n", # N + "\n#error Invalid return type: ... with 2 args\n", # M + "\n#error Invalid return type: address on the stack\n", # V + ] + arg = [ + "emu, ", # E + "", # v + "*(int8_t*)(R_ESP + {p}), ", # c + "*(int16_t*)(R_ESP + {p}), ", # w + "*(int32_t*)(R_ESP + {p}), ", # i + "*(int64_t*)(R_ESP + {p}), ", # I + "*(uint8_t*)(R_ESP + {p}), ", # C + "*(uint16_t*)(R_ESP + {p}), ", # W + "*(uint32_t*)(R_ESP + {p}), ", # u + "*(uint64_t*)(R_ESP + {p}), ", # U + "*(float*)(R_ESP + {p}), ", # f + "*(double*)(R_ESP + {p}), ", # d + "LD2localLD((void*)(R_ESP + {p})), ", # D + "FromLD((void*)(R_ESP + {p})), ", # K + "*(intptr_t*)(R_ESP + {p}), ", # l + "*(uintptr_t*)(R_ESP + {p}), ", # L + "*(void**)(R_ESP + {p}), ", # p + "(void*)(R_ESP + {p}), ", # V + "of_convert(*(int32_t*)(R_ESP + {p})), ", # O + "io_convert(*(void**)(R_ESP + {p})), ", # S + "(_2uint_struct_t){{*(uintptr_t*)(R_ESP + {p}),*(uintptr_t*)(R_ESP + {p} + 4)}}, ", # 2 + "arg{p}, ", # P + "&arg{p}, ", # G + "*(void**)(R_ESP + {p}), ", # N + "*(void**)(R_ESP + {p}),*(void**)(R_ESP + {p} + 4), ", # M + "(void*)(R_ESP + {p}), ", # V + ] + # Asserts + if len(FileSpec.values) != len(deltas): + raise NotImplementedError("len(values) = {lenval} != len(deltas) = {lendeltas}".format(lenval=len(FileSpec.values), lendeltas=len(deltas))) + if len(FileSpec.values) != len(vals): + raise NotImplementedError("len(values) = {lenval} != len(vals) = {lenvals}".format(lenval=len(FileSpec.values), lenvals=len(vals))) + if len(FileSpec.values) != len(arg): + raise NotImplementedError("len(values) = {lenval} != len(arg) = {lenarg}".format(lenval=len(FileSpec.values), lenarg=len(arg))) - # E e v c w i I C W u U f d D K l L p V O S 2 P G N M - tdtypes = ["x86emu_t*", "x86emu_t**", "void", "int8_t", "int16_t", "int32_t", "int64_t", "uint8_t", "uint16_t", "uint32_t", "uint64_t", "float", "double", "long double", "double", "intptr_t", "uintptr_t", "void*", "void*", "int32_t", "void*", "_2uint_struct_t", "void*", "void*", "...", "..."] - if len(values) != len(tdtypes): - raise NotImplementedError("len(values) = {lenval} != len(tdtypes) = {lentypes}".format(lenval=len(values), lentypes=len(tdtypes))) - def generate_typedefs(arr, file): - for v in arr: - file.write("typedef " + tdtypes[values.index(v[0])] + " (*" + v + "_t)" - + "(" + ', '.join(tdtypes[values.index(t)] for t in v[2:]) + ");\n") + # Helper functions to write the function definitions + def function_args(args: str, d: int = 4) -> str: + if len(args) == 0: + return "" + if d % 4 != 0: + raise ValueError("{d} is not a multiple of 4. Did you try passing a V then something else?".format(d=d)) + + return arg[FileSpec.values.index(args[0])].format(p=d) + function_args(args[1:], d + deltas[FileSpec.values.index(args[0])]) + + def function_writer(f, N: FunctionType, W: str) -> None: + f.write("void {0}(x86emu_t *emu, uintptr_t fcn) {2} {1} fn = ({1})fcn; ".format(N.orig, W, "{")) + + if N.orig == 'vFv': + f.write("(void)fcn; ") + + args = N.orig[2:] + if args == 'Ev': args = 'E' + + if any(c in 'PG' for c in args): + # Vulkan struct or GValue pointer, need to unwrap functions at the end + delta = 4 + for c in args: + if c == 'P': + f.write("void* save{d} = NULL; void *arg{d} = VulkanFromx86(*(void**)(R_ESP + {d}), &save{d}); ".format(d=delta)) + if c == 'G': + f.write("my_GValue_t arg{d}; alignGValue(&arg{d}, *(void**)(R_ESP + {d})); ".format(d=delta)) + delta = delta + deltas[FileSpec.values.index(c)] + f.write(vals[FileSpec.values.index(N.orig[0])].format(function_args(args)[:-2]) + " ") + delta = 4 + for c in args: + if c == 'P': + f.write("VulkanTox86(arg{d}, save{d}); ".format(d=delta)) + if c == 'G': + f.write("unalignGValue(*(void**)(R_ESP + {d}), &arg{d}); ".format(d=delta)) + delta = delta + deltas[FileSpec.values.index(c)] + f.write("}\n") + else: + # Generic function + f.write(vals[FileSpec.values.index(N.orig[0])].format(function_args(args)[:-2]) + " }\n") # Rewrite the wrapper.c file: with open(os.path.join(root, "src", "wrapped", "generated", "wrapper.c"), 'w') as file: file.write(files_header["wrapper.c"].format(lbr="{", rbr="}", version=ver)) # First part: typedefs - generate_typedefs(gbl["()"], file) - for k in gbl_idxs: - file.write("\n#if " + k + "\n") - generate_typedefs(gbl[k], file) - file.write("#endif\n") + for clauses in gbls: + if not clauses.empty(): + file.write("\n#if " + str(clauses) + "\n") + generate_typedefs(gbls[clauses], file) + if not clauses.empty(): + file.write("#endif\n") file.write("\n") # Next part: function definitions - # Helper variables - arg = [ - "emu, ", # E - "&emu, ", # e - "", # v - "*(int8_t*)(R_ESP + {p}), ", # c - "*(int16_t*)(R_ESP + {p}), ", # w - "*(int32_t*)(R_ESP + {p}), ", # i - "*(int64_t*)(R_ESP + {p}), ", # I - "*(uint8_t*)(R_ESP + {p}), ", # C - "*(uint16_t*)(R_ESP + {p}), ", # W - "*(uint32_t*)(R_ESP + {p}), ", # u - "*(uint64_t*)(R_ESP + {p}), ", # U - "*(float*)(R_ESP + {p}), ", # f - "*(double*)(R_ESP + {p}), ", # d - "LD2localLD((void*)(R_ESP + {p})), ", # D - "FromLD((void*)(R_ESP + {p})), ", # K - "*(intptr_t*)(R_ESP + {p}), ", # l - "*(uintptr_t*)(R_ESP + {p}), ", # L - "*(void**)(R_ESP + {p}), ", # p - "(void*)(R_ESP + {p}), ", # V - "of_convert(*(int32_t*)(R_ESP + {p})), ", # O - "io_convert(*(void**)(R_ESP + {p})), ", # S - "(_2uint_struct_t){{*(uintptr_t*)(R_ESP + {p}),*(uintptr_t*)(R_ESP + {p} + 4)}}, ", # 2 - "arg{p}, ", # P - "&arg{p}, ", # G - "*(void**)(R_ESP + {p}), ", # N - "*(void**)(R_ESP + {p}),*(void**)(R_ESP + {p} + 4), ", # M - ] - # E e v c w i I C W u U f d D K l L p V O S 2 P G N, M - deltas = [0, 0, 4, 4, 4, 4, 8, 4, 4, 4, 8, 4, 8, 12, 12, 4, 4, 4, 0, 4, 4, 8, 4, 4, 0, 0] - vals = [ - "\n#error Invalid return type: emulator\n", # E - "\n#error Invalid return type: &emulator\n", # e - "fn({0});", # v - "R_EAX=fn({0});", # c - "R_EAX=fn({0});", # w - "R_EAX=fn({0});", # i - "ui64_t r; r.i=fn({0}); R_EAX=r.d[0]; R_EDX=r.d[1];", # I - "R_EAX=(unsigned char)fn({0});", # C - "R_EAX=(unsigned short)fn({0});", # W - "R_EAX=(uint32_t)fn({0});", # u - "ui64_t r; r.u=(uint64_t)fn({0}); R_EAX=r.d[0]; R_EDX=r.d[1];", # U - "float fl=fn({0}); fpu_do_push(emu); ST0val = fl;", # f - "double db=fn({0}); fpu_do_push(emu); ST0val = db;", # d - "long double ld=fn({0}); fpu_do_push(emu); ST0val = ld;", # D - "double db=fn({0}); fpu_do_push(emu); ST0val = db;", # K - "R_EAX=(intptr_t)fn({0});", # l - "R_EAX=(uintptr_t)fn({0});", # L - "R_EAX=(uintptr_t)fn({0});", # p - "\n#error Invalid return type: va_list\n", # V - "\n#error Invalid return type: at_flags\n", # O - "\n#error Invalid return type: _io_file*\n", # S - "\n#error Invalid return type: _2uint_struct\n", # 2 - "\n#error Invalid return type: Vulkan Struct\n", # P - "\n#error Invalid return type: GValue Pointer\n", # G - "\n#error Invalid return type: ... with 1 arg\n", # N - "\n#error Invalid return type: ... with 2 args\n", # M - ] - # Asserts - if len(values) != len(arg): - raise NotImplementedError("len(values) = {lenval} != len(arg) = {lenarg}".format(lenval=len(values), lenarg=len(arg))) - if len(values) != len(deltas): - raise NotImplementedError("len(values) = {lenval} != len(deltas) = {lendeltas}".format(lenval=len(values), lendeltas=len(deltas))) - if len(values) != len(vals): - raise NotImplementedError("len(values) = {lenval} != len(vals) = {lenvals}".format(lenval=len(values), lenvals=len(vals))) - - # Helper functions to write the function definitions - def function_args(args, d=4): - if len(args) == 0: - return "" - if d % 4 != 0: - raise ValueError("{d} is not a multiple of 4. Did you try passing a V and something else?".format(d=d)) - - if args[0] == "0": - return "(void*)(R_ESP + {p}), ".format(p=d) + function_args(args[1:], d + 4) - elif args[0] == "1": - return "1, " + function_args(args[1:], d) - - return arg[values.index(args[0])].format(p=d) + function_args(args[1:], d + deltas[values.index(args[0])]) - - def function_writer(f, N, W, rettype, args): - f.write("void {0}(x86emu_t *emu, uintptr_t fcn) {2} {1} fn = ({1})fcn; ".format(N, W, "{")) - if any(cc in 'PG' for cc in args): - # Vulkan struct or GValue pointer, need to unwrap functions at the end - delta = 4 - for c in args: - if c == 'P': - f.write("void* save{d}=NULL; void *arg{d} = VulkanFromx86(*(void**)(R_ESP + {d}), &save{d}); ".format(d=delta)) - if c == 'G': - f.write("my_GValue_t arg{d}; alignGValue(&arg{d}, *(void**)(R_ESP + {d})); ".format(d=delta)) - delta = delta + deltas[values.index(c)] - f.write(vals[values.index(rettype)].format(function_args(args)[:-2]) + " ") - delta = 4 - for c in args: - if c == 'P': - f.write("VulkanTox86(arg{d}, save{d}); ".format(d=delta)) - if c == 'G': - f.write("unalignGValue(*(void**)(R_ESP + {d}), &arg{d}); ".format(d=delta)) - delta = delta + deltas[values.index(c)] - f.write("}\n") - else: - # Generic function - f.write(vals[values.index(rettype)].format(function_args(args)[:-2]) + " }\n") - - for v in gbl["()"]: - function_writer(file, v, v + "_t", v[0], v[2:]) - for k in gbl_idxs: - file.write("\n#if " + k + "\n") - for v in gbl[k]: - function_writer(file, v, v + "_t", v[0], v[2:]) - file.write("#endif\n") + for clauses in gbls: + if not clauses.empty(): + file.write("\n#if " + str(clauses) + "\n") + for funtype in gbls[clauses]: + function_writer(file, funtype, funtype.orig + "_t") + if not clauses.empty(): + file.write("#endif\n") file.write("\n") - for v in redirects["()"]: - function_writer(file, v[0], v[1] + "_t", v[0][0], v[0][2:]) - for k in redirects_idxs: - file.write("\n#if " + k + "\n") - for v in redirects[k]: - function_writer(file, v[0], v[1] + "_t", v[0][0], v[0][2:]) - file.write("#endif\n") + for clauses in redirects: + if not clauses.empty(): + file.write("\n#if " + str(clauses) + "\n") + for funtype in redirects[clauses]: + assert(funtype.redirected is not None) + function_writer(file, funtype, funtype.redirected.orig + "_t") + if not clauses.empty(): + file.write("#endif\n") file.write(files_guard["wrapper.c"].format(lbr="{", rbr="}", version=ver)) # Rewrite the wrapper.h file: with open(os.path.join(root, "src", "wrapped", "generated", "wrapper.h"), 'w') as file: file.write(files_header["wrapper.h"].format(lbr="{", rbr="}", version=ver)) - for v in gbl["()"]: - file.write("void " + v + "(x86emu_t *emu, uintptr_t fnc);\n") - for k in gbl_idxs: - file.write("\n#if " + k + "\n") - for v in gbl[k]: - file.write("void " + v + "(x86emu_t *emu, uintptr_t fnc);\n") - file.write("#endif\n") + for clauses in gbls: + if not clauses.empty(): + file.write("\n#if " + str(clauses) + "\n") + for funtype in gbls[clauses]: + file.write("void " + funtype.orig + "(x86emu_t *emu, uintptr_t fnc);\n") + if not clauses.empty(): + file.write("#endif\n") file.write("\n") - for v in redirects["()"]: - file.write("void " + v[0] + "(x86emu_t *emu, uintptr_t fnc);\n") - for k in redirects_idxs: - file.write("\n#if " + k + "\n") - for v in redirects[k]: - file.write("void " + v[0] + "(x86emu_t *emu, uintptr_t fnc);\n") - file.write("#endif\n") + for clauses in redirects: + if not clauses.empty(): + file.write("\n#if " + str(clauses) + "\n") + for funtype in redirects[clauses]: + file.write("void " + funtype.orig + "(x86emu_t *emu, uintptr_t fnc);\n") + if not clauses.empty(): + file.write("#endif\n") file.write(files_guard["wrapper.h"].format(lbr="{", rbr="}", version=ver)) - for fn in mytypedefs: + for fn in filespecs: + tdtypes[FileSpec.values.index('V')] = "..." with open(os.path.join(root, "src", "wrapped", "generated", fn + "types.h"), 'w') as file: file.write(files_header["fntypes.h"].format(lbr="{", rbr="}", version=ver, filename=fn)) - if fn in mystructs: - values = values + mystructs_vals[fn] - tdtypes = tdtypes + [mystructs[fn][k] for k in mystructs_vals[fn]] - generate_typedefs(mytypedefs_vals[fn], file) - if fn in mystructs: - values = values[:-len(mystructs_vals[fn])] - tdtypes = tdtypes[:-len(mystructs_vals[fn])] + generate_typedefs(filespecs[fn].typedefs, file) file.write("\n#define SUPER() ADDED_FUNCTIONS()") - for v in mytypedefs_vals[fn]: - for t, f in mytypedefs[fn][v]: - assert(t in [0, 1, 2, 3]) - file.write(" \\\n\tGO({0}, {1}_t)".format(f, v)) - file.write("\n") + for _bare in filespecs[fn].typedefs: + for fun in filespecs[fn].typedefs[_bare]: + if fun.no_dlsym: continue + file.write(" \\\n\tGO({0}, {1}_t)".format(fun.name, _bare.orig)) + file.write("\n\n") file.write(files_guard["fntypes.h"].format(lbr="{", rbr="}", version=ver, filename=fn)) + + with open(os.path.join(root, "src", "wrapped", "generated", fn + "defs.h"), 'w') as file: + file.write(files_header["fndefs.h"].format(lbr="{", rbr="}", version=ver, filename=fn)) + for defined in filespecs[fn].structsuses: + file.write("#define {defined} {define}\n".format(defined=defined.orig, define=defined.redirected.orig)) + file.write(files_guard["fndefs.h"].format(lbr="{", rbr="}", version=ver, filename=fn)) + + with open(os.path.join(root, "src", "wrapped", "generated", fn + "undefs.h"), 'w') as file: + file.write(files_header["fnundefs.h"].format(lbr="{", rbr="}", version=ver, filename=fn)) + for defined in filespecs[fn].structsuses: + file.write("#undef {defined}\n".format(defined=defined.orig)) + file.write(files_guard["fnundefs.h"].format(lbr="{", rbr="}", version=ver, filename=fn)) + +def main(root: str, files: Iterable[str], ver: str): + """ + main -- The main function + + root: the root path (where the CMakeLists.txt is located) + files: a list of files to parse (wrapped*.h) + ver: version number + """ + + # First read the files inside the headers + gbl_funcs, red_funcs, filespecs = readFiles(files) + + if all(not c.empty() for c in gbl_funcs) or all(not c.empty() for c in red_funcs): + print("\033[1;31mThere is suspiciously not many types...\033[m", file=sys.stderr) + print("Check the CMakeLists.txt file. If you are SURE there is nothing wrong" + " (as a random example, `set()` resets the variable...), then comment out the following return.", file=sys.stderr) + print("(Also, the program WILL crash later if you proceed.)", file=sys.stderr) + return 2 # Check what you did, not proceeding + + gbls, redirects = sortArrays(gbl_funcs, red_funcs, filespecs) + + # Check if there was any new functions + functions_list = checkRun(root, gbls, redirects, filespecs) + if functions_list is None: + print("Detected same build as last run, skipping") + return 0 + + # Now the files rebuilding part + generate_files(root, files, ver, gbls, redirects, filespecs) # Save the string for the next iteration, writing was successful with open(os.path.join(root, "src", "wrapped", "generated", "functions_list.txt"), 'w') as file: @@ -734,6 +1392,7 @@ def function_writer(f, N, W, rettype, args): for i, v in enumerate(sys.argv): if v == "--": limit.append(i) - if main(sys.argv[1], sys.argv[2:limit[0]], sys.argv[limit[0]+1:], "1.2.0.09") != 0: + Define.defines = list(map(DefineType, sys.argv[2:limit[0]])) + if main(sys.argv[1], sys.argv[limit[0]+1:], "2.0.0.10") != 0: exit(2) exit(0) diff --git a/src/elfs/elfloader.c b/src/elfs/elfloader.c index df63d76839..742e05598f 100755 --- a/src/elfs/elfloader.c +++ b/src/elfs/elfloader.c @@ -695,7 +695,7 @@ int RelocateElfPlt(lib_t *maplib, lib_t *local_maplib, elfheader_t* head) return -1; } if(pltResolver==~0) { - pltResolver = AddBridge(my_context->system, vFE, PltResolver, 0); + pltResolver = AddBridge(my_context->system, vFEv, PltResolver, 0); } if(head->pltgot) { *(uintptr_t*)(head->pltgot+head->delta+8) = pltResolver; diff --git a/src/librarian/library.c b/src/librarian/library.c index b3fa00afea..54c0f4813e 100755 --- a/src/librarian/library.c +++ b/src/librarian/library.c @@ -27,7 +27,7 @@ #include "wrappedlibs.h" // create the native lib list #define GO(P, N) int wrapped##N##_init(library_t* lib, box86context_t *box86); \ - void wrapped##N##_fini(library_t* lib);\ + void wrapped##N##_fini(library_t* lib); \ int wrapped##N##_get(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, int version, const char* vername, int local); \ int wrapped##N##_getnoweak(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, int version, const char* vername, int local); #include "library_list.h" @@ -80,12 +80,56 @@ int NbDot(const char* name) return ret; } +void NativeLib_CommonInit(library_t* lib) +{ + lib->priv.w.bridge = NewBridge(); +// Create maps + lib->symbolmap = kh_init(symbolmap); + lib->wsymbolmap = kh_init(symbolmap); + lib->mysymbolmap = kh_init(symbolmap); + lib->wmysymbolmap = kh_init(symbolmap); + lib->stsymbolmap = kh_init(symbolmap); + lib->wstsymbolmap = kh_init(symbolmap); + lib->symbol2map = kh_init(symbol2map); + lib->datamap = kh_init(datamap); + lib->wdatamap = kh_init(datamap); + lib->mydatamap = kh_init(datamap); +} + void EmuLib_Fini(library_t* lib) { kh_destroy(mapsymbols, lib->priv.n.mapsymbols); kh_destroy(mapsymbols, lib->priv.n.localsymbols); } +void NativeLib_FinishFini(library_t* lib) +{ + if(lib->priv.w.lib) + dlclose(lib->priv.w.lib); + lib->priv.w.lib = NULL; + if(lib->priv.w.altprefix) + free(lib->priv.w.altprefix); + if(lib->priv.w.neededlibs) { + for(int i=0; ipriv.w.needed; ++i) + free(lib->priv.w.neededlibs[i]); + free(lib->priv.w.neededlibs); + } + FreeBridge(&lib->priv.w.bridge); +} +int NativeLib_defget(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, int version, const char* vername, int local) +{ + uintptr_t addr = 0; + uint32_t size = 0; + void* symbol = NULL; + if (!getSymbolInMaps(lib, name, 0, &addr, &size, version, vername, local)) { + return 0; + } + if(!addr && !size) + return 0; + *offs = addr; + *sz = size; + return 1; +} int EmuLib_Get(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, int version, const char* vername, int local) { // symbols... @@ -105,6 +149,20 @@ int EmuLib_Get(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, } return 0; } +int NativeLib_defgetnoweak(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, int version, const char* vername, int local) +{ + uintptr_t addr = 0; + uint32_t size = 0; + void* symbol = NULL; + if (!getSymbolInMaps(lib, name, 1, &addr, &size, version, vername, local)) { + return 0; + } + if(!addr && !size) + return 0; + *offs = addr; + *sz = size; + return 1; +} int EmuLib_GetNoWeak(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, int version, const char* vername, int local) { uintptr_t start, end; @@ -416,18 +474,22 @@ void Free1Library(library_t **lib, x86emu_t* emu) kh_destroy(symbolmap, (*lib)->symbolmap); if((*lib)->wsymbolmap) kh_destroy(symbolmap, (*lib)->wsymbolmap); - if((*lib)->datamap) - kh_destroy(datamap, (*lib)->datamap); - if((*lib)->wdatamap) - kh_destroy(datamap, (*lib)->wdatamap); - if((*lib)->mydatamap) - kh_destroy(datamap, (*lib)->mydatamap); if((*lib)->mysymbolmap) kh_destroy(symbolmap, (*lib)->mysymbolmap); + if((*lib)->wmysymbolmap) + kh_destroy(symbolmap, (*lib)->wmysymbolmap); if((*lib)->stsymbolmap) kh_destroy(symbolmap, (*lib)->stsymbolmap); + if((*lib)->wstsymbolmap) + kh_destroy(symbolmap, (*lib)->wstsymbolmap); if((*lib)->symbol2map) kh_destroy(symbol2map, (*lib)->symbol2map); + if((*lib)->datamap) + kh_destroy(datamap, (*lib)->datamap); + if((*lib)->wdatamap) + kh_destroy(datamap, (*lib)->wdatamap); + if((*lib)->mydatamap) + kh_destroy(datamap, (*lib)->mydatamap); free_neededlib(&(*lib)->needed); free_neededlib(&(*lib)->dependedby); @@ -648,6 +710,40 @@ static int getSymbolInSymbolMaps(library_t*lib, const char* name, int noweak, ui return 1; } if(!noweak) { + k = kh_get(symbolmap, lib->wmysymbolmap, name); + if (k!=kh_end(lib->wmysymbolmap)) { + char buff[200]; + if(lib->altmy) + strcpy(buff, lib->altmy); + else + strcpy(buff, "my_"); + strcat(buff, name); + symbol = dlsym(lib->priv.w.box86lib, buff); + if(!symbol) { + printf_log(LOG_NONE, "Warning, function %s not found\n", buff); + } else + AddOffsetSymbol(lib->context->maplib, symbol, name); + *addr = AddBridge(lib->priv.w.bridge, kh_value(lib->wmysymbolmap, k), symbol, 0); + *size = sizeof(void*); + return 1; + } + k = kh_get(symbolmap, lib->wstsymbolmap, name); + if (k!=kh_end(lib->wstsymbolmap)) { + char buff[200]; + if(lib->altmy) + strcpy(buff, lib->altmy); + else + strcpy(buff, "my_"); + strcat(buff, name); + symbol = dlsym(lib->priv.w.box86lib, buff); + if(!symbol) { + printf_log(LOG_NONE, "Warning, function %s not found\n", buff); + } else + AddOffsetSymbol(lib->context->maplib, symbol, name); + *addr = AddBridge(lib->priv.w.bridge, kh_value(lib->wstsymbolmap, k), symbol, 4); // all of this for this little "4" + *size = sizeof(void*); + return 1; + } k = kh_get(symbolmap, lib->wsymbolmap, name); if (k!=kh_end(lib->wsymbolmap)) { symbol = dlsym(lib->priv.w.lib, name); diff --git a/src/librarian/library_private.h b/src/librarian/library_private.h index fe56cad345..f7b5cc6310 100755 --- a/src/librarian/library_private.h +++ b/src/librarian/library_private.h @@ -68,7 +68,9 @@ typedef struct library_s { kh_symbolmap_t *symbolmap; kh_symbolmap_t *wsymbolmap; kh_symbolmap_t *mysymbolmap; + kh_symbolmap_t *wmysymbolmap; kh_symbolmap_t *stsymbolmap; + kh_symbolmap_t *wstsymbolmap; kh_symbol2map_t *symbol2map; kh_datamap_t *datamap; kh_datamap_t *wdatamap; diff --git a/src/main.c b/src/main.c index 97d32aad5b..2184289537 100755 --- a/src/main.c +++ b/src/main.c @@ -617,14 +617,16 @@ void LoadEnvVars(box86context_t *context) AddPath("libcrypto.so.1.0.0", &context->box86_emulated_libs, 0); if(getenv("BOX86_NOSIGSEGV")) { - if (strcmp(getenv("BOX86_NOSIGSEGV"), "1")==0) + if (strcmp(getenv("BOX86_NOSIGSEGV"), "1")==0) { context->no_sigsegv = 1; printf_log(LOG_INFO, "BOX86: Disabling handling of SigSEGV\n"); + } } if(getenv("BOX86_NOSIGILL")) { - if (strcmp(getenv("BOX86_NOSIGILL"), "1")==0) + if (strcmp(getenv("BOX86_NOSIGILL"), "1")==0) { context->no_sigill = 1; printf_log(LOG_INFO, "BOX86: Disabling handling of SigILL\n"); + } } // check BOX86_PATH and load it LoadEnvPath(&context->box86_path, ".:bin", "BOX86_PATH"); diff --git a/src/wrapped/generated/functions_list.txt b/src/wrapped/generated/functions_list.txt index ef3821eba0..6c16596516 100644 --- a/src/wrapped/generated/functions_list.txt +++ b/src/wrapped/generated/functions_list.txt @@ -1,4 +1,3 @@ -#() vFE #() vFv #() vFi #() vFu @@ -17,7 +16,6 @@ #() cFp #() cFG #() wFp -#() iFE #() iFv #() iFw #() iFi @@ -43,7 +41,6 @@ #() CFG #() WFi #() WFp -#() uFE #() uFv #() uFi #() uFu @@ -55,8 +52,8 @@ #() UFv #() UFu #() UFp -#() UFV #() UFG +#() UFs #() fFi #() fFf #() fFp @@ -74,9 +71,9 @@ #() lFG #() LFv #() LFu +#() LFL #() LFp #() LFG -#() pFE #() pFv #() pFw #() pFi @@ -91,6 +88,7 @@ #() pFp #() pFV #() pFG +#() vFEv #() vFEp #() vFii #() vFiI @@ -143,9 +141,9 @@ #() vFGp #() vFGG #() cFpp +#() iFEv #() iFEL #() iFEp -#() iFEV #() iFwp #() iFii #() iFiI @@ -157,8 +155,6 @@ #() iFuu #() iFup #() iFli -#() iFLi -#() iFLp #() iFpw #() iFpi #() iFpI @@ -171,6 +167,7 @@ #() iFpl #() iFpL #() iFpp +#() iFpV #() iFpO #() iFpP #() iFpG @@ -185,8 +182,10 @@ #() CFpi #() CFpu #() CFpp +#() uFEv #() uFEu #() uFEp +#() uFii #() uFiu #() uFui #() uFuu @@ -203,7 +202,7 @@ #() UFUU #() UFUp #() UFpp -#() UFVV +#() UFss #() fFEp #() fFif #() fFfi @@ -226,15 +225,13 @@ #() lFpp #() LFii #() LFLi -#() LFLp #() LFpL #() LFpp +#() pFEv #() pFEi #() pFEp -#() pFEV #() pFii #() pFiu -#() pFiL #() pFip #() pFiV #() pFui @@ -257,6 +254,7 @@ #() pFpp #() pFpV #() pFpG +#() pFps #() pFSi #() vFEip #() vFEpi @@ -347,7 +345,6 @@ #() iFiii #() iFiiI #() iFiiu -#() iFiiL #() iFiip #() iFiiO #() iFiII @@ -359,6 +356,7 @@ #() iFipL #() iFipp #() iFCiW +#() iFuwp #() iFuii #() iFuip #() iFuui @@ -368,7 +366,6 @@ #() iFuLp #() iFupp #() iFfff -#() iFLwp #() iFpwp #() iFpii #() iFpiu @@ -396,7 +393,6 @@ #() iFpll #() iFplp #() iFpLi -#() iFpLL #() iFpLp #() iFppi #() iFppI @@ -426,8 +422,6 @@ #() uFEpp #() uFipu #() uFuip -#() uFuui -#() uFuuI #() uFuuu #() uFuup #() uFupi @@ -445,7 +439,6 @@ #() uFppp #() UFppi #() UFppu -#() fFuii #() fFull #() fFfff #() fFffp @@ -461,12 +454,15 @@ #() lFipL #() lFlll #() lFlpi +#() lFpli #() lFpLp #() lFppi #() lFppL #() lFSpl #() LFiii -#() LFpii +#() LFLLl +#() LFLpu +#() LFLpL #() LFpip #() LFpLi #() LFpLp @@ -527,8 +523,8 @@ #() pFppl #() pFppL #() pFppp -#() pFpVV #() pFpOM +#() pFpss #() pFSpl #() pFSpp #() vFEiip @@ -678,7 +674,6 @@ #() iFEppL #() iFEppp #() iFEppV -#() iFEpVV #() iFEpOu #() iFEpOV #() iFEPpp @@ -688,13 +683,13 @@ #() iFiiiu #() iFiiip #() iFiiII -#() iFiiLi +#() iFiiui #() iFiipi #() iFiipp +#() iFiuwp #() iFiuii #() iFiuui #() iFiupp -#() iFiLwp #() iFipii #() iFipip #() iFipui @@ -711,10 +706,11 @@ #() iFupup #() iFuppi #() iFuppp +#() iFpwww +#() iFpwpp #() iFpiii #() iFpiiu #() iFpiid -#() iFpiiL #() iFpiip #() iFpiuu #() iFpiuL @@ -728,6 +724,7 @@ #() iFpCCC #() iFpCpi #() iFpWWu +#() iFpuwp #() iFpuii #() iFpuiu #() iFpuiL @@ -748,7 +745,6 @@ #() iFpUpp #() iFplii #() iFplip -#() iFpLwp #() iFpLpi #() iFpLpL #() iFppii @@ -845,6 +841,7 @@ #() pFippi #() pFippu #() pFuiii +#() pFuuuu #() pFulli #() pFullu #() pFffff @@ -912,7 +909,6 @@ #() vFuiiii #() vFuiiiu #() vFuiiip -#() vFuiiup #() vFuiifi #() vFuiIII #() vFuiuii @@ -1004,11 +1000,12 @@ #() iFEipuu #() iFEippi #() iFEippp -#() iFEipVV +#() iFEuuuu #() iFEpiii #() iFEpiup #() iFEpipi #() iFEpipp +#() iFEpipV #() iFEpupV #() iFEpUup #() iFEpLpp @@ -1019,7 +1016,6 @@ #() iFEpplp #() iFEpppp #() iFEpppV -#() iFEppVV #() iFEpPpp #() iFiiipu #() iFiiipp @@ -1036,16 +1032,18 @@ #() iFipppi #() iFipppp #() iFuppup +#() iFpwwww +#() iFpwppp #() iFpiiii #() iFpiiiu #() iFpiiiL #() iFpiiip +#() iFpiiui #() iFpiiuu -#() iFpiiLi #() iFpiipi #() iFpiipp +#() iFpiuwp #() iFpiupu -#() iFpiLwp #() iFpipii #() iFpipiL #() iFpipip @@ -1074,12 +1072,12 @@ #() iFppiup #() iFppipi #() iFppipp +#() iFppuwp #() iFppuip #() iFppupi #() iFppupp #() iFppllp #() iFpplpp -#() iFppLwp #() iFppLip #() iFppLpi #() iFppLpL @@ -1090,6 +1088,7 @@ #() iFpppui #() iFpppuu #() iFpppup +#() iFpppLi #() iFppppi #() iFppppu #() iFppppL @@ -1212,7 +1211,6 @@ #() vFuiUUUU #() vFuiffff #() vFuidddd -#() vFuipiup #() vFuuiiii #() vFuuiiiu #() vFuuiuii @@ -1297,17 +1295,14 @@ #() iFEpiLpp #() iFEpippi #() iFEpippp -#() iFEpipVV #() iFEpuuip #() iFEpuppp -#() iFEpupVV #() iFEpUPpp #() iFEpLppp -#() iFEpLpVV #() iFEppppp #() iFiiiiii #() iFiiiiip -#() iFiiiLwp +#() iFiiiuwp #() iFiuiipi #() iFipipuu #() iFipuufp @@ -1425,10 +1420,8 @@ #() vFEpppppp #() vFiiiiiip #() vFiiiiuup -#() vFiiupuip #() vFiiffffp #() vFiipllli -#() vFiupuuup #() vFuiiiiii #() vFuiiiuip #() vFuiiiuup @@ -1504,6 +1497,7 @@ #() iFEpuiupV #() iFEpupppp #() iFEpUuppp +#() iFEpLiipV #() iFEppiuui #() iFEppupIi #() iFEppuppp @@ -1513,7 +1507,7 @@ #() iFiiiiiip #() iFpiiiiii #() iFpiiiiip -#() iFpiiiLwp +#() iFpiiiuwp #() iFpiiuuiu #() iFpiiuuuu #() iFpiipppp @@ -1611,13 +1605,10 @@ #() vFEpppuipV #() vFEpppppuu #() vFiiiiuuip -#() vFiupuiuup -#() vFiupuuuup #() vFilipufip #() vFuiiiiiii #() vFuiiiiill #() vFuiiiiuup -#() vFuiiipiup #() vFuiuiiiii #() vFuiuiiiip #() vFuiulplpp @@ -1658,15 +1649,12 @@ #() iFEpuuiipp #() iFEpuuuipp #() iFEpuuLppp -#() iFEpLiipVV #() iFEppppipp #() iFiiiiiiip #() iFiiupiupi -#() iFuiifpppp #() iFuipuuluf +#() iFuuuuuuuu #() iFullfpppp -#() iFLLLLLLLL -#() iFpiiiiipi #() iFpCCWWpWu #() iFpWCuWCuu #() iFpuiipppp @@ -1728,14 +1716,12 @@ #() vFuiiilliip #() vFuiiillilp #() vFuiuiiiiip -#() vFuiupuffup #() vFuuiiiiiii #() vFuuiuiiiii #() vFuuiuiiiip #() vFuuiuiiuup #() vFuuuiiiiip #() vFuuuuuuuuu -#() vFuupiuiuuf #() vFuffffffff #() vFffuuuufff #() vFddddddddd @@ -1767,8 +1753,8 @@ #() iFpiuuupipu #() iFpipLpiiip #() iFpuiuuipip +#() iFpuuuuuuuu #() iFpupuupWWu -#() iFpLLLLLLLL #() iFppiiiiiii #() iFppiuiippu #() iFppipiiipi @@ -1817,7 +1803,6 @@ #() vFuuiuiiiuup #() vFuuuuuuuiii #() vFuuuuuuuuuu -#() vFuupiiupuuf #() vFuffiiffiip #() vFuddiiddiip #() vFffffffffff @@ -1985,6 +1970,7 @@ #() pFipppppppppppppppppppppp #() iFpppppppppppppppppppppppppppppppppp #defined(NOALIGN) IFpi +#defined(NOALIGN) iFipV #defined(NOALIGN) iFppiiiip #!defined(NOALIGN) iFEi #!defined(NOALIGN) iFEO @@ -1993,6 +1979,7 @@ #!defined(NOALIGN) iFEpd #!defined(NOALIGN) IFEpi #!defined(NOALIGN) dFEpi +#!defined(NOALIGN) iFEipV #!defined(NOALIGN) iFEiiip #!defined(NOALIGN) iFEipii #!defined(NOALIGN) iFEpppi @@ -2017,1053 +2004,1967 @@ #!defined(HAVE_LD80BITS) KFppip #!defined(HAVE_LD80BITS) iFKipppL #!defined(HAVE_LD80BITS) vFppippKKC -#() vFEv -> vFE -#() iFEv -> iFE -#() uFEv -> uFE -#() pFEv -> pFE #() iFEvpp -> iFEpp -#() UFVvvV -> UFVV -#() iFEvppp -> iFEppp -#() iFEvpVV -> iFEpVV +#() iFEvpV -> iFEpV +#() UFsvvs -> UFss #() iFEpvpp -> iFEppp -#() iFEpvpVV -> iFEppVV -#() iFEpvvpVV -> iFEppVV -#() pFpVvvvvV -> pFpVV +#() iFEpvpV -> iFEppV +#() iFEpvvpV -> iFEppV +#() pFpsvvvvs -> pFpss #() iFEpuvvppp -> iFEpuppp -wrappedlibxcb/Sdxmy_xcb_cookie_t -wrappedlibxcb/SdXmy_xcb_XXX_iterator_t -wrappedlibxcbdri2/SdXmy_xcb_cookie_t -wrappedlibxcbdri3/SdXmy_xcb_cookie_t -wrappedlibxcbimage/SdXmy_xcb_cookie_t -wrappedlibxcbpresent/SdXmy_xcb_cookie_t -wrappedlibxcbrandr/SdXmy_xcb_cookie_t -wrappedlibxcbrandr/SdTmy_xcb_iterator_t -wrappedlibxcbshape/SdXmy_xcb_cookie_t -wrappedlibxcbshm/SdXmy_xcb_cookie_t -wrappedlibxcbshm/SdTmy_xcb_iterator_t -wrappedlibxcbxfixes/SdXmy_xcb_cookie_t -wrappedlibxcbxtest/SdXmy_xcb_cookie_t -wrappedsdl2/SdJSDL_JoystickGUID -wrappedsdl2/SdgSDL_GameControllerButtonBind -wrappedbz2/SuiFp3BZ2_bzCompressEnd -wrappedbz2/SuiFp3BZ2_bzDecompress -wrappedbz2/SuiFp3BZ2_bzDecompressEnd -wrappedbz2/SuiFpi3BZ2_bzCompress -wrappedbz2/SuiFpii3BZ2_bzDecompressInit -wrappedbz2/SuiFpiii3BZ2_bzCompressInit -wrappedcrypto/SuvFp3CRYPTO_set_id_callback -wrappedcrypto/SuvFp3CRYPTO_set_locking_callback -wrappedcrypto/SupFp3sk_new -wrappedcrypto/SuvFpp3sk_pop_free -wrappedcrypto/SupFpppp3PEM_read_bio_DSAPrivateKey -wrappedcrypto/SupFpppp3PEM_read_bio_DSA_PUBKEY -wrappedcrypto/SupFpppp3PEM_read_bio_ECPrivateKey -wrappedcrypto/SupFpppp3PEM_read_bio_EC_PUBKEY -wrappedcrypto/SupFpppp3PEM_read_bio_RSAPrivateKey -wrappedcrypto/SupFpppp3PEM_read_bio_RSA_PUBKEY -wrappedcrypto/SuiFpiipp3ENGINE_ctrl -wrappedcrypto/SuiFpplppi3ENGINE_ctrl_cmd -wrappedcrypto/SuiFppppipp3PEM_write_bio_DSAPrivateKey -wrappedcrypto/SuiFppppipp3PEM_write_bio_ECPrivateKey -wrappedcrypto/SuiFppppipp3PEM_write_bio_RSAPrivateKey -wrappedcurl/SuuFpup3curl_easy_setopt -wrappedd3dadapter9/SupFp3D3DAdapter9GetProc -wrappeddbus/SuvFppp3dbus_connection_remove_filter -wrappeddbus/SuvFppp3dbus_timeout_set_data -wrappeddbus/SuvFppp3dbus_watch_set_data -wrappeddbus/SuvFpppp3dbus_connection_set_dispatch_status_function -wrappeddbus/SuvFpppp3dbus_connection_set_wakeup_main_function -wrappeddbus/SuiFpipp3dbus_connection_set_data -wrappeddbus/SuiFpipp3dbus_message_set_data -wrappeddbus/SuiFpipp3dbus_pending_call_set_data -wrappeddbus/SuiFppip3dbus_message_get_args_valist -wrappeddbus/SuiFppiV3dbus_message_get_args -wrappeddbus/SuiFpppp3dbus_connection_add_filter -wrappeddbus/SuiFpppp3dbus_pending_call_set_notify -wrappeddbus/SuiFppppp3dbus_connection_try_register_object_path -wrappeddbus/SuiFpppppp3dbus_connection_set_timeout_functions -wrappeddbus/SuiFpppppp3dbus_connection_set_watch_functions -wrappeddbusglib1/SuvFppp3dbus_g_type_collection_value_iterate -wrappeddbusglib1/SuvFppp3dbus_g_type_map_value_iterate -wrappeddbusglib1/SuvFpppp3dbus_g_proxy_disconnect_signal -wrappeddbusglib1/SuvFppppp3dbus_g_proxy_connect_signal -wrappeddbusglib1/SupFpppppiV3dbus_g_proxy_begin_call -wrappeddbusglib1/SupFpppppiiV3dbus_g_proxy_begin_call_with_timeout -wrappedexpat/SuvFpp3XML_SetCharacterDataHandler -wrappedexpat/SuvFppp3XML_SetElementHandler -wrappedfontconfig/SuiFppiuui3FcPatternAdd -wrappedfontconfig/SuiFppiuui3FcPatternAddWeak -wrappedfreetype/SuiFpplp3FT_Open_Face -wrappedfreetype/SuiFpuuLppp3FTC_Manager_New -wrappedgdk3/SuvFpp3gdk_init -wrappedgdk3/SuiFpp3gdk_init_check -wrappedgdk3/SuvFppp3gdk_event_handler_set -wrappedgdk3/SuvFppp3gdk_window_add_filter -wrappedgdk3/SuvFppp3gdk_window_remove_filter -wrappedgdk3/SuiFiipp3gdk_input_add -wrappedgdk3/SuiFiippp3gdk_input_add_full -wrappedgdkpixbuf2/SupFpiiiiiipp3gdk_pixbuf_new_from_data -wrappedgdkx112/SuvFpp3gdk_init -wrappedgdkx112/SuiFpp3gdk_init_check -wrappedgdkx112/SuvFppp3gdk_event_handler_set -wrappedgdkx112/SuvFppp3gdk_window_add_filter -wrappedgdkx112/SuvFppp3gdk_window_remove_filter -wrappedgdkx112/SuiFiipp3gdk_input_add -wrappedgdkx112/SuiFiippp3gdk_input_add_full -wrappedgio2/SuvFppp3g_simple_async_result_set_op_res_gpointer -wrappedgio2/SuvFippp3g_bus_get -wrappedgio2/SuvFppip3g_simple_async_result_run_in_thread -wrappedgio2/SuvFpppp3g_dbus_connection_close -wrappedgio2/SuvFpppp3g_dbus_connection_flush -wrappedgio2/SuvFpppp3g_simple_async_report_gerror_in_idle -wrappedgio2/SuvFpppp3g_simple_async_report_take_gerror_in_idle -wrappedgio2/SuuFpppp3g_dbus_connection_add_filter -wrappedgio2/SuLFpppp3g_cancellable_connect -wrappedgio2/SupFpppp3g_simple_async_result_new -wrappedgio2/SupFpppp3g_simple_async_result_new_from_error -wrappedgio2/SupFpppp3g_simple_async_result_new_take_error -wrappedgio2/SuvFpippp3g_async_initable_init_async -wrappedgio2/SuvFpipppp3g_dbus_connection_new_for_address -wrappedgio2/SuvFiippppV3g_async_initable_new_async -wrappedgio2/SuvFiupippp3g_async_initable_newv_async -wrappedgio2/SuvFippippp3g_async_initable_new_valist_async -wrappedgio2/SuvFppipppp3g_dbus_connection_new -wrappedgio2/SuvFpppuipV3g_simple_async_report_error_in_idle -wrappedgio2/SuuFipipppp3g_bus_watch_name -wrappedgio2/SuuFppipppp3g_bus_own_name_on_connection -wrappedgio2/SuuFppipppp3g_bus_watch_name_on_connection -wrappedgio2/SuuFppppppp3g_dbus_connection_register_object -wrappedgio2/SupFpppuipV3g_simple_async_result_new_error -wrappedgio2/SuvFppiipppp3g_dbus_connection_send_message_with_reply -wrappedgio2/SuvFpppiippp3g_dbus_proxy_call -wrappedgio2/SuuFipippppp3g_bus_own_name -wrappedgio2/SuvFiippppppp3g_dbus_proxy_new_for_bus -wrappedgio2/SuvFpippppppp3g_dbus_proxy_new -wrappedgio2/SuvFpppiipppp3g_dbus_proxy_call_with_unix_fd_list -wrappedgio2/SupFiippppppp3g_dbus_object_manager_client_new_for_bus_sync -wrappedgio2/SuuFppppppippp3g_dbus_connection_signal_subscribe -wrappedgio2/SuvFpppppppiippp3g_dbus_connection_call -wrappedglib2/SuvFp3g_atexit -wrappedglib2/SupFp3g_completion_new -wrappedglib2/SupFp3g_main_context_get_poll_func -wrappedglib2/SupFp3g_private_new -wrappedglib2/SupFp3g_ptr_array_new_with_free_func -wrappedglib2/SupFp3g_set_print_handler -wrappedglib2/SupFp3g_set_printerr_handler -wrappedglib2/SuvFpp3g_array_set_clear_func -wrappedglib2/SuvFpp3g_array_sort -wrappedglib2/SuvFpp3g_completion_set_compare -wrappedglib2/SuvFpp3g_list_free_full -wrappedglib2/SuvFpp3g_main_context_set_poll_func -wrappedglib2/SuvFpp3g_ptr_array_set_free_func -wrappedglib2/SuvFpp3g_ptr_array_sort -wrappedglib2/SuvFpp3g_source_set_funcs -wrappedglib2/SuvFpp3g_thread_foreach -wrappedglib2/SuvFpV3g_print -wrappedglib2/SuvFpV3g_printerr -wrappedglib2/SuiFpp3g_source_remove_by_funcs_user_data -wrappedglib2/SuiFpp3g_vprintf -wrappedglib2/SuiFpV3g_printf -wrappedglib2/SuuFpp3g_idle_add -wrappedglib2/SuuFpp3g_printf_string_upper_bound -wrappedglib2/SupFup3g_ptr_array_new_full -wrappedglib2/SupFpu3g_source_new -wrappedglib2/SupFpp3g_hash_table_new -wrappedglib2/SupFpp3g_list_sort -wrappedglib2/SupFpp3g_log_set_default_handler -wrappedglib2/SupFpp3g_markup_vprintf_escaped -wrappedglib2/SupFpp3g_slist_sort -wrappedglib2/SupFpp3g_strdup_vprintf -wrappedglib2/SupFpp3g_variant_new_parsed_va -wrappedglib2/SupFpV3g_build_filename -wrappedglib2/SupFpV3g_markup_printf_escaped -wrappedglib2/SupFpV3g_strdup_printf -wrappedglib2/SupFpV3g_variant_new -wrappedglib2/SupFpV3g_variant_new_parsed -wrappedglib2/SuvFppp3g_array_sort_with_data -wrappedglib2/SuvFppp3g_hash_table_foreach -wrappedglib2/SuvFppp3g_ptr_array_foreach -wrappedglib2/SuvFppp3g_ptr_array_sort_with_data -wrappedglib2/SuvFppp3g_static_private_set -wrappedglib2/SuvFppV3g_variant_get -wrappedglib2/SuiFppp3g_vasprintf -wrappedglib2/SuiFppp3g_vfprintf -wrappedglib2/SuiFppp3g_vsprintf -wrappedglib2/SuiFppV3g_fprintf -wrappedglib2/SuiFppV3g_sprintf -wrappedglib2/SuuFipp3g_child_watch_add -wrappedglib2/SuuFupp3g_timeout_add -wrappedglib2/SuuFupp3g_timeout_add_seconds -wrappedglib2/SuuFppp3g_hash_table_foreach_remove -wrappedglib2/SuuFppp3g_hash_table_foreach_steal -wrappedglib2/SupFppp3g_hash_table_find -wrappedglib2/SupFppp3g_list_find_custom -wrappedglib2/SupFppp3g_list_sort_with_data -wrappedglib2/SupFppp3g_queue_find_custom -wrappedglib2/SupFppp3g_slist_find_custom -wrappedglib2/SupFppp3g_slist_foreach -wrappedglib2/SupFppp3g_slist_insert_sorted -wrappedglib2/SupFppp3g_slist_sort_with_data -wrappedglib2/SupFppp3g_variant_new_va -wrappedglib2/SupFppV3g_build_path -wrappedglib2/SuvFpupp3g_datalist_id_set_data_full -wrappedglib2/SuvFpppp3g_source_set_callback -wrappedglib2/SuiFpLpp3g_vsnprintf -wrappedglib2/SuiFpLpV3g_snprintf -wrappedglib2/SuuFippp3g_idle_add_full -wrappedglib2/SuuFpipp3g_io_add_watch -wrappedglib2/SuuFpipp3g_log_set_handler -wrappedglib2/SupFpupp3g_datalist_id_dup_data -wrappedglib2/SupFppip3g_thread_create -wrappedglib2/SupFpppp3g_hash_table_new_full -wrappedglib2/SupFpppp3g_slist_insert_sorted_with_data -wrappedglib2/SuvFpiLpp3g_qsort_with_data -wrappedglib2/SuvFppipV3g_set_error -wrappedglib2/SuuFiippp3g_child_watch_add_full -wrappedglib2/SuuFiuppp3g_timeout_add_full -wrappedglib2/SuuFiuppp3g_timeout_add_seconds_full -wrappedglib2/SuiFpupppp3g_datalist_id_replace_data -wrappedglib2/SuuFpiippp3g_io_add_watch_full -wrappedglib2/SupFppuipp3g_variant_new_from_data -wrappedglib2/SupFppLiiip3g_thread_create_full -wrappedglib2/SuiFpppipppp3g_spawn_async -wrappedglib2/SuiFpppipppppp3g_spawn_sync -wrappedglib2/SuiFpppippppppp3g_spawn_async_with_pipes -wrappedgnutls/SuvFp3gnutls_global_set_log_function -wrappedgnutls/SuvFpp3gnutls_transport_set_pull_function -wrappedgnutls/SuvFpp3gnutls_transport_set_pull_timeout_function -wrappedgnutls/SuvFpp3gnutls_transport_set_push_function -wrappedgobject2/SupFp3g_type_class_peek_parent -wrappedgobject2/SuiFpp3g_param_type_register_static -wrappedgobject2/SupFpp3g_value_array_sort -wrappedgobject2/SuvFiip3g_type_add_interface_static -wrappedgobject2/SuvFiip3g_value_register_transform_func -wrappedgobject2/SuiFppp3g_boxed_type_register_static -wrappedgobject2/SupFipV3g_object_new -wrappedgobject2/SupFppp3g_value_array_sort_with_data -wrappedgobject2/SupFppV3g_object_connect -wrappedgobject2/SuvFpupp3g_param_spec_set_qdata_full -wrappedgobject2/SuvFpppp3g_object_set_data_full -wrappedgobject2/SuiFippi3g_type_register_static -wrappedgobject2/SuiFipppi3g_type_register_fundamental -wrappedgobject2/SuLFupppp3g_signal_add_emission_hook -wrappedgobject2/SuLFpppppu3g_signal_connect_data -wrappedgobject2/SuiFipupupi3g_type_register_static_simple -wrappedgobject2/SuuFpiupppp3g_signal_handlers_block_matched -wrappedgobject2/SuuFpiupppp3g_signal_handlers_disconnect_matched -wrappedgobject2/SuuFpiupppp3g_signal_handlers_unblock_matched -wrappedgobject2/SuLFpiupppp3g_signal_handler_find -wrappedgobject2/SuuFpiiupppiuV3g_signal_new -wrappedgobject2/SuuFpiippppiup3g_signal_new_valist -wrappedgobject2/SuuFpiippppiup3g_signal_newv -wrappedgthread2/SuvFp3g_thread_init -wrappedgthread2/SuvFp3g_thread_init_with_errorcheck_mutexes -wrappedgtk3/SupFi3gtk_type_class -wrappedgtk3/SuvFpp3gtk_init -wrappedgtk3/SuiFpp3gtk_init_check -wrappedgtk3/SuiFpp3gtk_type_unique -wrappedgtk3/SuvFppp3gtk_builder_connect_signals_full -wrappedgtk3/SuvFppp3gtk_container_forall -wrappedgtk3/SuvFppp3gtk_menu_attach_to_widget -wrappedgtk3/SuvFppV3gtk_dialog_add_buttons -wrappedgtk3/SuvFppV3gtk_message_dialog_format_secondary_markup -wrappedgtk3/SuvFppV3gtk_message_dialog_format_secondary_text -wrappedgtk3/SuuFupp3gtk_timeout_add -wrappedgtk3/SuvFpppp3gtk_object_set_data_full -wrappedgtk3/SuvFpppp3gtk_stock_set_translate_func -wrappedgtk3/SuvFpppp3gtk_tree_sortable_set_default_sort_func -wrappedgtk3/SuvFpppp3gtk_tree_view_set_search_equal_func -wrappedgtk3/SuiFpppp3gtk_text_iter_backward_find_char -wrappedgtk3/SuiFpppp3gtk_text_iter_forward_find_char -wrappedgtk3/SuvFpippp3gtk_tree_sortable_set_sort_func -wrappedgtk3/SuiFppuppp3gtk_clipboard_set_with_data -wrappedgtk3/SuiFppuppp3gtk_clipboard_set_with_owner -wrappedgtk3/SuiFpppppp3gtk_init_with_args -wrappedgtk3/SuvFpppppuu3gtk_menu_popup -wrappedgtk3/SupFppppppi3gtk_toolbar_insert_stock -wrappedgtk3/SupFppppppp3gtk_toolbar_append_item -wrappedgtk3/SupFppppppp3gtk_toolbar_prepend_item -wrappedgtk3/SuLFppppppii3gtk_signal_connect_full -wrappedgtk3/SupFpppppppi3gtk_toolbar_insert_item -wrappedgtk3/SupFpippppppp3gtk_toolbar_append_element -wrappedgtk3/SupFpippppppp3gtk_toolbar_prepend_element -wrappedgtk3/SupFpipppppppi3gtk_toolbar_insert_element -wrappedgtkx112/SufFp3gtk_spin_button_get_value_as_float -wrappedgtkx112/SupFi3gtk_type_class -wrappedgtkx112/SuvFpp3gtk_builder_connect_signals -wrappedgtkx112/SuvFpp3gtk_init -wrappedgtkx112/SuiFpp3gtk_init_check -wrappedgtkx112/SuiFpp3gtk_type_unique -wrappedgtkx112/SupFpi3gtk_type_check_object_cast -wrappedgtkx112/SuvFppp3gtk_builder_connect_signals_full -wrappedgtkx112/SuvFppp3gtk_clipboard_request_text -wrappedgtkx112/SuvFppp3gtk_container_forall -wrappedgtkx112/SuvFppp3gtk_container_foreach -wrappedgtkx112/SuvFppp3gtk_menu_attach_to_widget -wrappedgtkx112/SuvFppp3gtk_tree_model_foreach -wrappedgtkx112/SuvFppV3gtk_dialog_add_buttons -wrappedgtkx112/SuvFppV3gtk_message_dialog_format_secondary_markup -wrappedgtkx112/SuvFppV3gtk_message_dialog_format_secondary_text -wrappedgtkx112/SuuFupp3gtk_timeout_add -wrappedgtkx112/SuvFppup3gtk_action_group_add_actions -wrappedgtkx112/SuvFpppp3gtk_clipboard_request_contents -wrappedgtkx112/SuvFpppp3gtk_object_set_data_full -wrappedgtkx112/SuvFpppp3gtk_stock_set_translate_func -wrappedgtkx112/SuvFpppp3gtk_tree_sortable_set_default_sort_func -wrappedgtkx112/SuvFpppp3gtk_tree_view_set_search_equal_func -wrappedgtkx112/SuiFpppp3gtk_text_iter_backward_find_char -wrappedgtkx112/SuiFpppp3gtk_text_iter_forward_find_char -wrappedgtkx112/SuLFpppp3gtk_signal_connect -wrappedgtkx112/SuvFpippp3gtk_tree_sortable_set_sort_func -wrappedgtkx112/SuvFppupp3gtk_action_group_add_actions_full -wrappedgtkx112/SuvFppppp3gtk_cell_layout_set_cell_data_func -wrappedgtkx112/SuvFpuipuV3gtk_binding_entry_add_signal -wrappedgtkx112/SuiFppuppp3gtk_clipboard_set_with_data -wrappedgtkx112/SuiFppuppp3gtk_clipboard_set_with_owner -wrappedgtkx112/SuiFpppppp3gtk_init_with_args -wrappedgtkx112/SuuFiipppp3gtk_input_add_full -wrappedgtkx112/SuvFpppppuu3gtk_menu_popup -wrappedgtkx112/SupFppppppi3gtk_toolbar_insert_stock -wrappedgtkx112/SupFppppppp3gtk_toolbar_append_item -wrappedgtkx112/SupFppppppp3gtk_toolbar_prepend_item -wrappedgtkx112/SuLFppppppii3gtk_signal_connect_full -wrappedgtkx112/SupFpppppppi3gtk_toolbar_insert_item -wrappedgtkx112/SupFpippppppp3gtk_toolbar_append_element -wrappedgtkx112/SupFpippppppp3gtk_toolbar_prepend_element -wrappedgtkx112/SupFpipppppppi3gtk_toolbar_insert_element -wrappedkrb5/SuiFppppppipp3krb5_get_init_creds_password -wrappedlcms2/SuvFp3cmsSetLogErrorHandler -wrappedldapr/SuiFpppppupp3ldap_sasl_interactive_bind_s -wrappedldlinux/SupFv3___tls_get_addr -wrappedldlinux/SupFp3__tls_get_addr -wrappedlibasound/SuiFp3snd_dlclose -wrappedlibasound/SuiFp3snd_lib_error_set_handler -wrappedlibasound/SupFppp3snd_dlsym -wrappedlibasound/SuiFpipp3snd_async_add_handler -wrappedlibasound/SuiFpppp3snd_async_add_pcm_handler -wrappedlibasound/SupFpipL3snd_dlopen -wrappedlibc/SuiFpp3__vwprintf_chk -wrappedlibc/SuiFpV3execl -wrappedlibc/SuiFpV3execle -wrappedlibc/SuiFpV3execlp -wrappedlibc/SuiFSp3_IO_file_stat -wrappedlibc/SuvFpup3_ITM_addUserCommitAction -wrappedlibc/SuiFipL3modify_ldt -wrappedlibc/SuiFppp3__vfwprintf_chk -wrappedlibc/SuvFpppp3__libc_init -wrappedlibdl/SuiFp3dlclose -wrappedlibdl/SupFv3dlerror -wrappedlibdl/SuiFpp3dladdr -wrappedlibdl/SupFpi3dlopen -wrappedlibdl/SupFpp3dlsym -wrappedlibdl/SuiFpip3dlinfo -wrappedlibdl/SupFppi3dlmopen -wrappedlibdl/SupFppp3dlvsym -wrappedlibgl/SupFp3glXGetProcAddress -wrappedlibgl/SupFp3glXGetProcAddressARB -wrappedlibgl/SuvFpp3glDebugMessageCallback -wrappedlibgl/SuvFpp3glDebugMessageCallbackAMD -wrappedlibgl/SuvFpp3glDebugMessageCallbackARB -wrappedlibgl/SuvFipp3glProgramCallbackMESA -wrappedlibglu/SuvFpip3gluNurbsCallback -wrappedlibglu/SuvFpip3gluQuadricCallback -wrappedlibglu/SuvFpip3gluTessCallback -wrappedlibjpeg/SuiFp3jpeg_finish_decompress -wrappedlibjpeg/SuiFp3jpeg_start_decompress -wrappedlibjpeg/SupFp3jpeg_std_error -wrappedlibjpeg/SuiFpi3jpeg_read_header -wrappedlibjpeg/SuvFpiL3jpeg_CreateDecompress -wrappedlibjpeg/SuvFpip3jpeg_set_marker_processor -wrappedlibjpeg/SuuFppu3jpeg_read_scanlines -wrappedlibjpeg62/SuvFp3jpeg_destroy_compress -wrappedlibjpeg62/SuvFp3jpeg_destroy_decompress -wrappedlibjpeg62/SuvFp3jpeg_finish_compress -wrappedlibjpeg62/SuvFp3jpeg_set_defaults -wrappedlibjpeg62/SuiFp3jpeg_finish_decompress -wrappedlibjpeg62/SuiFp3jpeg_start_decompress -wrappedlibjpeg62/SupFp3jpeg_std_error -wrappedlibjpeg62/SuvFpi3jpeg_start_compress -wrappedlibjpeg62/SuiFpi3jpeg_read_header -wrappedlibjpeg62/SuiFpi3jpeg_resync_to_restart -wrappedlibjpeg62/SuvFpii3jpeg_set_quality -wrappedlibjpeg62/SuvFpiL3jpeg_CreateCompress -wrappedlibjpeg62/SuvFpiL3jpeg_CreateDecompress -wrappedlibjpeg62/SuvFpip3jpeg_set_marker_processor -wrappedlibjpeg62/SuvFppp3jpeg_mem_dest -wrappedlibjpeg62/SuuFppu3jpeg_read_scanlines -wrappedlibjpeg62/SuuFppu3jpeg_write_scanlines -wrappedlibjpeg62/SuvFpipu3jpeg_write_marker -wrappedlibncurses/SuiFpV3printw -wrappedlibncurses/SuiFiipV3mvprintw -wrappedlibncurses/SuiFpiipV3mvwprintw -wrappedlibncurses6/SuiFpV3printw -wrappedlibncurses6/SuiFpiipV3mvwprintw -wrappedlibncursesw/SuiFpV3printw -wrappedlibncursesw/SuiFpiipV3mvwprintw -wrappedlibpthread/SuvFp3__pthread_register_cancel -wrappedlibpthread/SuvFp3__pthread_unregister_cancel -wrappedlibpthread/SuvFp3__pthread_unwind_next -wrappedlibpthread/SuiFp3pthread_attr_destroy -wrappedlibpthread/SuiFp3pthread_cond_broadcast@GLIBC_2.0 -wrappedlibpthread/SuiFp3pthread_cond_destroy@GLIBC_2.0 -wrappedlibpthread/SuiFp3pthread_cond_signal@GLIBC_2.0 -wrappedlibpthread/SuvFpi3_pthread_cleanup_pop -wrappedlibpthread/SuvFpi3_pthread_cleanup_pop_restore -wrappedlibpthread/SuiFpi3pthread_attr_setscope -wrappedlibpthread/SuiFpi3pthread_kill -wrappedlibpthread/SuiFpi3pthread_mutexattr_setkind_np -wrappedlibpthread/SuiFpp3__pthread_key_create -wrappedlibpthread/SuiFpp3__pthread_once -wrappedlibpthread/SuiFpp3pthread_attr_setschedparam -wrappedlibpthread/SuiFpp3pthread_cond_init@GLIBC_2.0 -wrappedlibpthread/SuiFpp3pthread_cond_wait -wrappedlibpthread/SuiFpp3pthread_cond_wait@GLIBC_2.0 -wrappedlibpthread/SuiFpp3pthread_key_create -wrappedlibpthread/SuiFpp3pthread_once -wrappedlibpthread/SuiFpp3pthread_setname_np -wrappedlibpthread/SuvFppp3_pthread_cleanup_push -wrappedlibpthread/SuvFppp3_pthread_cleanup_push_defer -wrappedlibpthread/SuiFLup3pthread_setaffinity_np -wrappedlibpthread/SuiFpup3pthread_attr_setaffinity_np -wrappedlibpthread/SuiFpup3pthread_getaffinity_np -wrappedlibpthread/SuiFppu3pthread_getname_np -wrappedlibpthread/SuiFppL3pthread_attr_setstack -wrappedlibpthread/SuiFppp3__pthread_atfork -wrappedlibpthread/SuiFppp3pthread_atfork -wrappedlibpthread/SuiFppp3pthread_attr_getstack -wrappedlibpthread/SuiFppp3pthread_cond_timedwait -wrappedlibpthread/SuiFppp3pthread_cond_timedwait@GLIBC_2.0 -wrappedlibpthread/SuiFpppp3pthread_create -wrappedlibrt/SuiFupp3timer_create -wrappedlibsm/SuiFppp3SmcRequestSaveYourselfPhase2 -wrappedlibsm/SuiFpipp3SmcInteractRequest -wrappedlibsm/SupFppiiLpppip3SmcOpenConnection -wrappedlibsndfile/SuiFp3sf_close -wrappedlibsndfile/SupFpipp3sf_open_virtual -wrappedlibssl/SuvFpp3SSL_CTX_sess_set_new_cb -wrappedlibssl/SuvFpp3SSL_CTX_set_default_passwd_cb -wrappedlibssl/SuvFpp3SSL_set_psk_client_callback -wrappedlibssl/SuvFpip3SSL_CTX_set_verify -wrappedlibssl/SuvFpip3SSL_set_verify -wrappedlibssl/SuvFppp3SSL_CTX_set_next_proto_select_cb -wrappedlibssl/SulFpip3SSL_CTX_callback_ctrl -wrappedlibssl/SulFpip3SSL_callback_ctrl -wrappedlibssl/SuiFlpppp3SSL_get_ex_new_index -wrappedlibtinfo/SuiFpip3tputs -wrappedlibtinfo6/SuiFpip3tputs -wrappedlibusb1/SuiFp3libusb_cancel_transfer -wrappedlibusb1/SuiFp3libusb_submit_transfer -wrappedlibusb1/SupFi3libusb_alloc_transfer -wrappedlibusb1/SuiFpiiiiippp3libusb_hotplug_register_callback -wrappedlibv4l2/SuiFpL3v4l2_munmap -wrappedlibv4l2/SupFpLiiii3v4l2_mmap -wrappedlibvorbis/SuvFp3vorbis_dsp_clear -wrappedlibvorbis/SuiFp3vorbis_bitrate_addblock -wrappedlibvorbis/SuiFp3vorbis_block_clear -wrappedlibvorbis/SuiFp3vorbis_synthesis_restart -wrappedlibvorbis/SuiFpi3vorbis_analysis_wrote -wrappedlibvorbis/SuiFpi3vorbis_synthesis_read -wrappedlibvorbis/SuiFpp3vorbis_analysis -wrappedlibvorbis/SuiFpp3vorbis_analysis_blockout -wrappedlibvorbis/SuiFpp3vorbis_analysis_init -wrappedlibvorbis/SuiFpp3vorbis_bitrate_flushpacket -wrappedlibvorbis/SuiFpp3vorbis_block_init -wrappedlibvorbis/SuiFpp3vorbis_synthesis -wrappedlibvorbis/SuiFpp3vorbis_synthesis_blockin -wrappedlibvorbis/SuiFpp3vorbis_synthesis_init -wrappedlibvorbis/SuiFpp3vorbis_synthesis_lapout -wrappedlibvorbis/SuiFpp3vorbis_synthesis_pcmout -wrappedlibvorbis/SupFpi3vorbis_analysis_buffer -wrappedlibvorbis/SupFpi3vorbis_window -wrappedlibvorbis/SuiFppppp3vorbis_analysis_headerout -wrappedlibx11/SuiFp3XCloseDisplay -wrappedlibx11/SuiFp3XDestroyImage -wrappedlibx11/SuiFp3XInitImage -wrappedlibx11/SupFp3XOpenDisplay -wrappedlibx11/SupFp3XSetErrorHandler -wrappedlibx11/SupFp3XSetIOErrorHandler -wrappedlibx11/SuvFpp3_XDeqAsyncHandler -wrappedlibx11/SuiFpi3XSynchronize -wrappedlibx11/SupFpp3XLoadQueryFont -wrappedlibx11/SupFpp3XSetAfterFunction -wrappedlibx11/SuiFppu3XSetBackground -wrappedlibx11/SuiFppu3XSetForeground -wrappedlibx11/SuiFppp3XAddConnectionWatch -wrappedlibx11/SuiFppp3XRemoveConnectionWatch -wrappedlibx11/SupFpip3XESetCloseDisplay -wrappedlibx11/SupFpip3XESetError -wrappedlibx11/SupFpip3XESetEventToWire -wrappedlibx11/SupFpip3XESetWireToEvent -wrappedlibx11/SuiFpppp3XCheckIfEvent -wrappedlibx11/SuiFpppp3XIfEvent -wrappedlibx11/SuiFpppp3XPeekIfEvent -wrappedlibx11/SupFppup3XCreateGC -wrappedlibx11/SuiFppppp3XQueryExtension -wrappedlibx11/SuiFpppppp3XRegisterIMInstantiateCallback -wrappedlibx11/SuiFpppppp3XUnregisterIMInstantiateCallback -wrappedlibx11/SupFppiiuuui3XGetImage -wrappedlibx11/SuiFppppiiiiuu3XPutImage -wrappedlibx11/SupFppuiipuuii3XCreateImage -wrappedlibx11/SupFppiiuuuipii3XGetSubImage -wrappedlibxcb/SuxFp1xcb_get_input_focus -wrappedlibxcb/SuxFp1xcb_get_modifier_mapping -wrappedlibxcb/SuxFp1xcb_grab_server -wrappedlibxcb/SuxFp1xcb_ungrab_server -wrappedlibxcb/SuXFp1xcb_depth_visuals_iterator -wrappedlibxcb/SuXFp1xcb_screen_allowed_depths_iterator -wrappedlibxcb/SuXFp1xcb_setup_pixmap_formats_iterator -wrappedlibxcb/SuXFp1xcb_setup_roots_iterator -wrappedlibxcb/SuxFpC1xcb_bell -wrappedlibxcb/SuxFpu1xcb_close_font -wrappedlibxcb/SuxFpu1xcb_close_font_checked -wrappedlibxcb/SuxFpu1xcb_destroy_window -wrappedlibxcb/SuxFpu1xcb_free_colormap -wrappedlibxcb/SuxFpu1xcb_free_colormap_checked -wrappedlibxcb/SuxFpu1xcb_free_gc -wrappedlibxcb/SuxFpu1xcb_free_pixmap -wrappedlibxcb/SuxFpu1xcb_get_atom_name -wrappedlibxcb/SuxFpu1xcb_get_geometry -wrappedlibxcb/SuxFpu1xcb_get_geometry_unchecked -wrappedlibxcb/SuxFpu1xcb_get_selection_owner -wrappedlibxcb/SuxFpu1xcb_get_selection_owner_unchecked -wrappedlibxcb/SuxFpu1xcb_get_window_attributes -wrappedlibxcb/SuxFpu1xcb_get_window_attributes_unchecked -wrappedlibxcb/SuxFpu1xcb_map_subwindows -wrappedlibxcb/SuxFpu1xcb_map_window -wrappedlibxcb/SuxFpu1xcb_map_window_checked -wrappedlibxcb/SuxFpu1xcb_query_pointer -wrappedlibxcb/SuxFpu1xcb_query_tree -wrappedlibxcb/SuxFpu1xcb_query_tree_unchecked -wrappedlibxcb/SuxFpu1xcb_ungrab_keyboard -wrappedlibxcb/SuxFpu1xcb_ungrab_keyboard_checked -wrappedlibxcb/SuxFpu1xcb_ungrab_pointer -wrappedlibxcb/SuxFpu1xcb_unmap_window -wrappedlibxcb/SuxFpp1xcb_free_cursor -wrappedlibxcb/SuxFpCC1xcb_get_keyboard_mapping -wrappedlibxcb/SuxFpup1xcb_change_keyboard_control -wrappedlibxcb/SuxFppp1xcb_delete_property -wrappedlibxcb/SuxFpCWp1xcb_intern_atom -wrappedlibxcb/SuxFpCWp1xcb_intern_atom_unchecked -wrappedlibxcb/SuxFpCuW1xcb_ungrab_button -wrappedlibxcb/SuxFpCuW1xcb_ungrab_button_checked -wrappedlibxcb/SuxFpCuW1xcb_ungrab_key -wrappedlibxcb/SuxFpCuW1xcb_ungrab_key_checked -wrappedlibxcb/SuxFpCuu1xcb_set_input_focus -wrappedlibxcb/SuxFpuWp1xcb_configure_window -wrappedlibxcb/SuxFpuWp1xcb_open_font -wrappedlibxcb/SuxFpuWp1xcb_open_font_checked -wrappedlibxcb/SuxFpuuu1xcb_set_selection_owner -wrappedlibxcb/SuxFpuup1xcb_change_gc -wrappedlibxcb/SuxFpuup1xcb_change_gc_checked -wrappedlibxcb/SuxFpuup1xcb_change_window_attributes -wrappedlibxcb/SuxFpuup1xcb_change_window_attributes_checked -wrappedlibxcb/SuxFpuup1xcb_query_text_extents -wrappedlibxcb/SuxFpCuup1xcb_send_event -wrappedlibxcb/SuxFpCppp1xcb_create_colormap -wrappedlibxcb/SuxFpuWWW1xcb_alloc_color -wrappedlibxcb/SuxFpuuWW1xcb_reparent_window -wrappedlibxcb/SuxFpuuWW1xcb_translate_coordinates -wrappedlibxcb/SuxFpuuWW1xcb_translate_coordinates_unchecked -wrappedlibxcb/SuxFpuuup1xcb_create_gc -wrappedlibxcb/SuxFpuuup1xcb_create_gc_checked -wrappedlibxcb/SuxFpuuup1xcb_poly_arc -wrappedlibxcb/SuxFpuuup1xcb_poly_fill_rectangle -wrappedlibxcb/SuxFpuuup1xcb_poly_rectangle -wrappedlibxcb/SuxFpuuup1xcb_poly_segment -wrappedlibxcb/SuxFpCuuCC1xcb_grab_keyboard -wrappedlibxcb/SuxFpCuuWW1xcb_create_pixmap -wrappedlibxcb/SuxFpCuuup1xcb_poly_line -wrappedlibxcb/SuxFpCuuup1xcb_poly_line_checked -wrappedlibxcb/SuxFpCuuup1xcb_poly_point -wrappedlibxcb/SuxFpuuuuu1xcb_convert_selection -wrappedlibxcb/SuxFpCuwwWW1xcb_clear_area -wrappedlibxcb/SuxFpCuWCCC1xcb_grab_key -wrappedlibxcb/SuxFpCuWCCC1xcb_grab_key_checked -wrappedlibxcb/SuxFpCuuwwp1xcb_image_text_8 -wrappedlibxcb/SuxFpCuuwwp1xcb_image_text_8_checked -wrappedlibxcb/SuxFpCuuuuu1xcb_get_property -wrappedlibxcb/SuxFpCuuuuu1xcb_get_property_unchecked -wrappedlibxcb/SuxFpCuwwWWu1xcb_get_image -wrappedlibxcb/SuxFpCuwwWWu1xcb_get_image_unchecked -wrappedlibxcb/SuxFpCuuuCup1xcb_change_property -wrappedlibxcb/SuxFpCuuuCup1xcb_change_property_checked -wrappedlibxcb/SuxFpCuWCCuuu1xcb_grab_pointer -wrappedlibxcb/SuxFpuuwwWWww1xcb_warp_pointer -wrappedlibxcb/SuxFpCuWCCuuCW1xcb_grab_button -wrappedlibxcb/SuxFpCuWCCuuCW1xcb_grab_button_checked -wrappedlibxcb/SuxFpuuuwwwwWW1xcb_copy_area -wrappedlibxcb/SuxFpCuuWWwwCCup1xcb_put_image -wrappedlibxcb/SuxFpuuuWWWWWWWW1xcb_create_cursor -wrappedlibxcb/SuxFpuuuWWWWWWWW1xcb_create_glyph_cursor -wrappedlibxcb/SuxFpCuuwwWWWWuup1xcb_create_window -wrappedlibxcb/SuxFpCuuwwWWWWuup1xcb_create_window_checked -wrappedlibxcbdri2/SuXFpuu1xcb_dri2_authenticate -wrappedlibxcbdri2/SuXFpuu1xcb_dri2_connect -wrappedlibxcbdri2/SuXFpuu1xcb_dri2_query_version -wrappedlibxcbdri3/SuXFpuu1xcb_dri3_open -wrappedlibxcbdri3/SuXFpuu1xcb_dri3_query_version -wrappedlibxcbdri3/SuXFpuuuWWWCCi1xcb_dri3_pixmap_from_buffer_checked -wrappedlibxcbimage/SuXFpuupwwC1xcb_image_put -wrappedlibxcbpresent/SuXFpuu1xcb_present_query_version -wrappedlibxcbpresent/SuXFpuuu1xcb_present_select_input_checked -wrappedlibxcbpresent/SuXFpuuUUU1xcb_present_notify_msc -wrappedlibxcbpresent/SuXFpuuuuuwwuuuuUUUup1xcb_present_pixmap -wrappedlibxcbpresent/SuXFpuuuuuwwuuuuUUUup1xcb_present_pixmap_checked -wrappedlibxcbrandr/SuTFp1xcb_randr_get_screen_resources_current_outputs_end -wrappedlibxcbrandr/SuXFpu1xcb_randr_get_output_primary -wrappedlibxcbrandr/SuXFpu1xcb_randr_get_output_primary_unchecked -wrappedlibxcbrandr/SuXFpu1xcb_randr_get_screen_resources -wrappedlibxcbrandr/SuXFpu1xcb_randr_get_screen_resources_current -wrappedlibxcbrandr/SuXFpu1xcb_randr_get_screen_resources_outputs -wrappedlibxcbrandr/SuXFpu1xcb_randr_get_screen_resources_unchecked -wrappedlibxcbrandr/SuXFpuW1xcb_randr_select_input -wrappedlibxcbrandr/SuXFpuW1xcb_randr_select_input_checked -wrappedlibxcbrandr/SuXFpuu1xcb_randr_query_version -wrappedlibxcbrandr/SuXFpuu1xcb_randr_query_version_unchecked -wrappedlibxcbrandr/SuXFppu1xcb_randr_get_crtc_info -wrappedlibxcbrandr/SuXFppu1xcb_randr_get_crtc_info_unchecked -wrappedlibxcbrandr/SuXFppu1xcb_randr_get_output_info -wrappedlibxcbrandr/SuXFppu1xcb_randr_get_output_info_unchecked -wrappedlibxcbshape/SuXFpuuuwwu1xcb_shape_mask -wrappedlibxcbshape/SuXFpuuuwwu1xcb_shape_mask_checked -wrappedlibxcbshm/SuXFp1xcb_shm_query_version -wrappedlibxcbshm/SuXFp1xcb_shm_query_version_unchecked -wrappedlibxcbshm/SuTFT0xcb_shm_seg_end -wrappedlibxcbshm/SuXFpu1xcb_shm_detach -wrappedlibxcbshm/SuXFpu1xcb_shm_detach_checked -wrappedlibxcbshm/SuXFpuuC1xcb_shm_attach -wrappedlibxcbshm/SuXFpuuC1xcb_shm_attach_checked -wrappedlibxcbshm/SuXFpuuC1xcb_shm_attach_fd -wrappedlibxcbshm/SuXFpuuC1xcb_shm_attach_fd_checked -wrappedlibxcbshm/SuXFpuuC1xcb_shm_create_segment -wrappedlibxcbshm/SuXFpuuC1xcb_shm_create_segment_unchecked -wrappedlibxcbshm/SuXFpuuWWCuu1xcb_shm_create_pixmap -wrappedlibxcbshm/SuXFpuuWWCuu1xcb_shm_create_pixmap_checked -wrappedlibxcbshm/SuXFpuwwWWuCuu1xcb_shm_get_image -wrappedlibxcbshm/SuXFpuwwWWuCuu1xcb_shm_get_image_unchecked -wrappedlibxcbshm/SuXFpuuWWWWWWwwCCCuu1xcb_shm_put_image -wrappedlibxcbshm/SuXFpuuWWWWWWwwCCCuu1xcb_shm_put_image_checked -wrappedlibxcbxfixes/SuXFpu1xcb_xfixes_destroy_region -wrappedlibxcbxfixes/SuXFpuu1xcb_xfixes_query_version_unchecked -wrappedlibxcbxfixes/SuXFpuup1xcb_xfixes_create_region -wrappedlibxcbxfixes/SuXFpuuwwu1xcb_xfixes_set_window_shape_region -wrappedlibxcbxfixes/SuXFpuuwwu1xcb_xfixes_set_window_shape_region_checked -wrappedlibxcbxtest/SuXFpCCuuwwC1xcb_test_fake_input -wrappedlibxcbxtest/SuXFpCCuuwwC1xcb_test_fake_input_checked -wrappedlibxext/SupFp3XSetExtensionErrorHandler -wrappedlibxext/SuiFpppiiu3XShmGetImage -wrappedlibxext/SupFppppip3XextAddDisplay -wrappedlibxext/SupFppuippuu3XShmCreateImage -wrappedlibxext/SuiFppppiiiiuui3XShmPutImage -wrappedlibxt/SuvFpuipp3XtAddEventHandler -wrappedlibxtst/SuiFpppp3XRecordEnableContext -wrappedlibxtst/SuiFpppp3XRecordEnableContextAsync -wrappedlibz/SuiFp3deflateEnd -wrappedlibz/SuiFp3inflateEnd -wrappedlibz/SuiFp3inflateInit -wrappedlibz/SuiFppi3inflateInit_ -wrappedlibz/SuiFpipi3deflateInit_ -wrappedlibz/SuiFpipi3inflateInit2_ -wrappedlibz/SuiFpiiiiipi3deflateInit2_ -wrappedmpg123/SuiFpppp3mpg123_replace_reader_handle -wrappedmpg123/SuiFpppp3mpg123_replace_reader_handle_32 -wrappedmpg123/SuiFpppp3mpg123_replace_reader_handle_64 -wrappedopenal/SuvFv3alRequestFoldbackStop -wrappedopenal/SupFp3alGetProcAddress -wrappedopenal/SupFpp3alcGetProcAddress -wrappedopenal/SuvFiiipp3alRequestFoldbackStart -wrappedpango/SuvFpp3pango_attribute_init -wrappedpng12/SuvFppp3png_set_read_fn -wrappedpng12/SuvFpppp3png_set_error_fn -wrappedpng12/SuvFpppp3png_set_write_fn -wrappedpng12/SupFpppp3png_create_read_struct -wrappedpng12/SuvFppppp3png_set_progressive_read_fn -wrappedpng12/SupFppppppp3png_create_read_struct_2 -wrappedpng12/SupFppppppp3png_create_write_struct_2 -wrappedpng16/SuvFpp3png_set_read_user_transform_fn -wrappedpng16/SuvFppp3png_set_read_fn -wrappedpng16/SuvFpppp3png_set_error_fn -wrappedpng16/SuvFpppp3png_set_write_fn -wrappedpng16/SupFpppp3png_create_read_struct -wrappedpng16/SuvFppppp3png_set_progressive_read_fn -wrappedpng16/SupFppppppp3png_create_read_struct_2 -wrappedpng16/SupFppppppp3png_create_write_struct_2 -wrappedpulse/SuvFp3pa_mainloop_free -wrappedpulse/SuvFp3pa_threaded_mainloop_free -wrappedpulse/SuiFp3pa_signal_init -wrappedpulse/SupFp3pa_mainloop_get_api -wrappedpulse/SupFp3pa_threaded_mainloop_get_api -wrappedpulse/SuvFpp3pa_signal_set_destroy -wrappedpulse/SupFpp3pa_context_new -wrappedpulse/SuvFppp3pa_context_set_event_callback -wrappedpulse/SuvFppp3pa_context_set_state_callback -wrappedpulse/SuvFppp3pa_context_set_subscribe_callback -wrappedpulse/SuvFppp3pa_mainloop_set_poll_func -wrappedpulse/SuvFppp3pa_stream_set_buffer_attr_callback -wrappedpulse/SuvFppp3pa_stream_set_event_callback -wrappedpulse/SuvFppp3pa_stream_set_latency_update_callback -wrappedpulse/SuvFppp3pa_stream_set_moved_callback -wrappedpulse/SuvFppp3pa_stream_set_overflow_callback -wrappedpulse/SuvFppp3pa_stream_set_read_callback -wrappedpulse/SuvFppp3pa_stream_set_started_callback -wrappedpulse/SuvFppp3pa_stream_set_state_callback -wrappedpulse/SuvFppp3pa_stream_set_suspended_callback -wrappedpulse/SuvFppp3pa_stream_set_underflow_callback -wrappedpulse/SuvFppp3pa_stream_set_write_callback -wrappedpulse/SupFipp3pa_signal_new -wrappedpulse/SupFppp3pa_context_drain -wrappedpulse/SupFppp3pa_context_exit_daemon -wrappedpulse/SupFppp3pa_context_get_client_info_list -wrappedpulse/SupFppp3pa_context_get_module_info_list -wrappedpulse/SupFppp3pa_context_get_server_info -wrappedpulse/SupFppp3pa_context_get_sink_info_list -wrappedpulse/SupFppp3pa_context_get_sink_input_info_list -wrappedpulse/SupFppp3pa_context_get_source_info_list -wrappedpulse/SupFppp3pa_context_new_with_proplist -wrappedpulse/SupFppp3pa_stream_drain -wrappedpulse/SupFppp3pa_stream_flush -wrappedpulse/SupFppp3pa_stream_prebuf -wrappedpulse/SupFppp3pa_stream_trigger -wrappedpulse/SupFppp3pa_stream_update_timing_info -wrappedpulse/SuiFppip3pa_context_connect -wrappedpulse/SuiFpppV3pa_proplist_setf -wrappedpulse/SupFpipp3pa_stream_cork -wrappedpulse/SupFpupp3pa_context_get_sink_info_by_index -wrappedpulse/SupFpupp3pa_context_get_sink_input_info -wrappedpulse/SupFpupp3pa_context_get_source_info_by_index -wrappedpulse/SupFpupp3pa_context_subscribe -wrappedpulse/SupFpupp3pa_context_unload_module -wrappedpulse/SupFpupp3pa_stream_update_sample_rate -wrappedpulse/SupFpppp3pa_context_get_sink_info_by_name -wrappedpulse/SupFpppp3pa_context_get_source_info_by_name -wrappedpulse/SupFpppp3pa_context_proplist_remove -wrappedpulse/SupFpppp3pa_context_set_default_sink -wrappedpulse/SupFpppp3pa_context_set_default_source -wrappedpulse/SupFpppp3pa_context_set_name -wrappedpulse/SupFpppp3pa_stream_proplist_remove -wrappedpulse/SupFpppp3pa_stream_set_buffer_attr -wrappedpulse/SupFpppp3pa_stream_set_name -wrappedpulse/SupFpippp3pa_context_proplist_update -wrappedpulse/SupFpippp3pa_stream_proplist_update -wrappedpulse/SupFpuipp3pa_context_set_sink_input_mute -wrappedpulse/SupFpuipp3pa_context_set_source_mute_by_index -wrappedpulse/SupFpuupp3pa_context_move_sink_input_by_index -wrappedpulse/SupFpuppp3pa_context_set_sink_input_volume -wrappedpulse/SupFpuppp3pa_context_set_sink_volume_by_index -wrappedpulse/SupFpuppp3pa_context_set_source_volume_by_index -wrappedpulse/SupFppppp3pa_context_load_module -wrappedpulse/SupFppppp3pa_context_set_source_volume_by_name -wrappedpulse/SuiFppupIi3pa_stream_write -wrappedsdl1/SuvFp3SDL_KillThread -wrappedsdl1/SuvFp3SDL_SetEventFilter -wrappedsdl1/SuvFp3SDL_UnloadObject -wrappedsdl1/SuiFp3SDL_GetWMInfo -wrappedsdl1/SuiFp3SDL_RemoveTimer -wrappedsdl1/SuuFp3SDL_ReadBE16 -wrappedsdl1/SuuFp3SDL_ReadBE32 -wrappedsdl1/SuuFp3SDL_ReadLE16 -wrappedsdl1/SuuFp3SDL_ReadLE32 -wrappedsdl1/SuUFp3SDL_ReadBE64 -wrappedsdl1/SuUFp3SDL_ReadLE64 -wrappedsdl1/SupFv3SDL_GetEventFilter -wrappedsdl1/SupFp3SDL_GL_GetProcAddress -wrappedsdl1/SupFp3SDL_LoadObject -wrappedsdl1/SuiFup3SDL_SetTimer -wrappedsdl1/SuiFpp3SDL_OpenAudio -wrappedsdl1/SuuFpW3SDL_WriteBE16 -wrappedsdl1/SuuFpW3SDL_WriteLE16 -wrappedsdl1/SuuFpu3SDL_WriteBE32 -wrappedsdl1/SuuFpu3SDL_WriteLE32 -wrappedsdl1/SuuFpU3SDL_WriteBE64 -wrappedsdl1/SuuFpU3SDL_WriteLE64 -wrappedsdl1/SupFpi3SDL_LoadBMP_RW -wrappedsdl1/SupFpi3SDL_RWFromConstMem -wrappedsdl1/SupFpi3SDL_RWFromFP -wrappedsdl1/SupFpi3SDL_RWFromMem -wrappedsdl1/SupFpp3SDL_CreateThread -wrappedsdl1/SupFpp3SDL_LoadFunction -wrappedsdl1/SupFpp3SDL_RWFromFile -wrappedsdl1/SuiFppi3SDL_SaveBMP_RW -wrappedsdl1/SupFupp3SDL_AddTimer -wrappedsdl1/SupFpippp3SDL_LoadWAV_RW -wrappedsdl1image/SupFp3IMG_LoadBMP_RW -wrappedsdl1image/SupFp3IMG_LoadCUR_RW -wrappedsdl1image/SupFp3IMG_LoadGIF_RW -wrappedsdl1image/SupFp3IMG_LoadICO_RW -wrappedsdl1image/SupFp3IMG_LoadJPG_RW -wrappedsdl1image/SupFp3IMG_LoadLBM_RW -wrappedsdl1image/SupFp3IMG_LoadPCX_RW -wrappedsdl1image/SupFp3IMG_LoadPNG_RW -wrappedsdl1image/SupFp3IMG_LoadPNM_RW -wrappedsdl1image/SupFp3IMG_LoadTGA_RW -wrappedsdl1image/SupFp3IMG_LoadTIF_RW -wrappedsdl1image/SupFp3IMG_LoadWEBP_RW -wrappedsdl1image/SupFp3IMG_LoadXCF_RW -wrappedsdl1image/SupFp3IMG_LoadXPM_RW -wrappedsdl1image/SupFp3IMG_LoadXV_RW -wrappedsdl1image/SupFpi3IMG_Load_RW -wrappedsdl1image/SupFpip3IMG_LoadTyped_RW -wrappedsdl1mixer/SuvFp3Mix_ChannelFinished -wrappedsdl1mixer/SuvFp3Mix_HookMusicFinished -wrappedsdl1mixer/SupFp3Mix_LoadMUS_RW -wrappedsdl1mixer/SuvFpp3Mix_HookMusic -wrappedsdl1mixer/SuvFpp3Mix_SetPostMix -wrappedsdl1mixer/SuiFip3Mix_UnregisterEffect -wrappedsdl1mixer/SupFpi3Mix_LoadWAV_RW -wrappedsdl1mixer/SupFpii3Mix_LoadMUSType_RW -wrappedsdl1mixer/SuiFippp3Mix_RegisterEffect -wrappedsdl1sound/SupFpppu3Sound_NewSample -wrappedsdl1ttf/SupFpii3TTF_OpenFontRW -wrappedsdl1ttf/SupFpiii3TTF_OpenFontIndexRW -wrappedsdl2/SuvFp3SDL_UnloadObject -wrappedsdl2/SuiFp3SDL_RWclose -wrappedsdl2/SuiFp3SDL_RemoveTimer -wrappedsdl2/SuiFp3SDL_SaveAllDollarTemplates -wrappedsdl2/SuiFJ2SDL_IsJoystickHIDAPI -wrappedsdl2/SuiFJ2SDL_IsJoystickXInput -wrappedsdl2/SuIFp3SDL_RWtell -wrappedsdl2/SuuFp3SDL_ReadBE16 -wrappedsdl2/SuuFp3SDL_ReadBE32 -wrappedsdl2/SuuFp3SDL_ReadLE16 -wrappedsdl2/SuuFp3SDL_ReadLE32 -wrappedsdl2/SuuFp3SDL_ReadU8 -wrappedsdl2/SuUFp3SDL_ReadBE64 -wrappedsdl2/SuUFp3SDL_ReadLE64 -wrappedsdl2/SupFv3SDL_GetBasePath -wrappedsdl2/SupFv3SDL_Vulkan_GetVkGetInstanceProcAddr -wrappedsdl2/SupFp3SDL_GL_GetProcAddress -wrappedsdl2/SupFp3SDL_LoadObject -wrappedsdl2/SupFJ2SDL_GameControllerMappingForGUID -wrappedsdl2/SuJFi1SDL_JoystickGetDeviceGUID -wrappedsdl2/SuJFp1SDL_JoystickGetGUID -wrappedsdl2/SuJFp1SDL_JoystickGetGUIDFromString -wrappedsdl2/SuvFpp3SDL_AddEventWatch -wrappedsdl2/SuvFpp3SDL_DelEventWatch -wrappedsdl2/SuvFpp3SDL_LogGetOutputFunction -wrappedsdl2/SuvFpp3SDL_LogSetOutputFunction -wrappedsdl2/SuvFpp3SDL_SetEventFilter -wrappedsdl2/SuvFpV3SDL_Log -wrappedsdl2/SuiFip3SDL_SaveDollarTemplate -wrappedsdl2/SuiFWW3SDL_IsJoystickNintendoSwitchPro -wrappedsdl2/SuiFWW3SDL_IsJoystickPS4 -wrappedsdl2/SuiFWW3SDL_IsJoystickSteamController -wrappedsdl2/SuiFWW3SDL_IsJoystickXbox360 -wrappedsdl2/SuiFWW3SDL_IsJoystickXboxOne -wrappedsdl2/SuiFpi3SDL_GameControllerAddMappingsFromRW -wrappedsdl2/SuiFpp3SDL_GetEventFilter -wrappedsdl2/SuiFpp3SDL_OpenAudio -wrappedsdl2/SuuFpW3SDL_WriteBE16 -wrappedsdl2/SuuFpW3SDL_WriteLE16 -wrappedsdl2/SuuFpu3SDL_WriteBE32 -wrappedsdl2/SuuFpu3SDL_WriteLE32 -wrappedsdl2/SuuFpu3SDL_WriteU8 -wrappedsdl2/SuuFpU3SDL_WriteBE64 -wrappedsdl2/SuuFpU3SDL_WriteLE64 -wrappedsdl2/SupFpi3SDL_LoadBMP_RW -wrappedsdl2/SupFpi3SDL_RWFromConstMem -wrappedsdl2/SupFpi3SDL_RWFromFP -wrappedsdl2/SupFpi3SDL_RWFromMem -wrappedsdl2/SupFpp3SDL_LoadFunction -wrappedsdl2/SupFpp3SDL_RWFromFile -wrappedsdl2/SugFpi1SDL_GameControllerGetBindForAxis -wrappedsdl2/SugFpi1SDL_GameControllerGetBindForButton -wrappedsdl2/SuvFipV3SDL_LogCritical -wrappedsdl2/SuvFipV3SDL_LogDebug -wrappedsdl2/SuvFipV3SDL_LogError -wrappedsdl2/SuvFipV3SDL_LogInfo -wrappedsdl2/SuvFipV3SDL_LogVerbose -wrappedsdl2/SuvFipV3SDL_LogWarn -wrappedsdl2/SuiFupp3SDL_TLSSet -wrappedsdl2/SuiFppi3SDL_SaveBMP_RW -wrappedsdl2/SuIFpIi3SDL_RWseek -wrappedsdl2/SupFupp3SDL_AddTimer -wrappedsdl2/SupFppi3SDL_LoadFile_RW -wrappedsdl2/SupFppp3SDL_CreateThread -wrappedsdl2/SuvFpuup3SDL_qsort -wrappedsdl2/SuvFJppp2SDL_GetJoystickGUIDInfo -wrappedsdl2/SuuFppuu3SDL_RWread -wrappedsdl2/SuuFppuu3SDL_RWwrite -wrappedsdl2/SuiFpippi3SDL_OpenAudioDevice -wrappedsdl2/SuiFpupVV3SDL_snprintf -wrappedsdl2/SuiFpupVV3SDL_vsnprintf -wrappedsdl2/SupFpippp3SDL_LoadWAV_RW -wrappedsdl2image/SupFp3IMG_LoadBMP_RW -wrappedsdl2image/SupFp3IMG_LoadCUR_RW -wrappedsdl2image/SupFp3IMG_LoadGIF_RW -wrappedsdl2image/SupFp3IMG_LoadICO_RW -wrappedsdl2image/SupFp3IMG_LoadJPG_RW -wrappedsdl2image/SupFp3IMG_LoadLBM_RW -wrappedsdl2image/SupFp3IMG_LoadPCX_RW -wrappedsdl2image/SupFp3IMG_LoadPNG_RW -wrappedsdl2image/SupFp3IMG_LoadPNM_RW -wrappedsdl2image/SupFp3IMG_LoadTGA_RW -wrappedsdl2image/SupFp3IMG_LoadTIF_RW -wrappedsdl2image/SupFp3IMG_LoadWEBP_RW -wrappedsdl2image/SupFp3IMG_LoadXCF_RW -wrappedsdl2image/SupFp3IMG_LoadXPM_RW -wrappedsdl2image/SupFp3IMG_LoadXV_RW -wrappedsdl2image/SupFpi3IMG_Load_RW -wrappedsdl2image/SuiFppi3IMG_SavePNG_RW -wrappedsdl2image/SupFpip3IMG_LoadTyped_RW -wrappedsdl2image/SupFppi3IMG_LoadTexture_RW -wrappedsdl2image/SupFppip3IMG_LoadTextureTyped_RW -wrappedsdl2mixer/SuvFp3Mix_ChannelFinished -wrappedsdl2mixer/SuvFp3Mix_HookMusicFinished -wrappedsdl2mixer/SuvFpp3Mix_HookMusic -wrappedsdl2mixer/SuvFpp3Mix_SetPostMix -wrappedsdl2mixer/SuiFiw3MinorityMix_SetPosition -wrappedsdl2mixer/SuiFip3Mix_UnregisterEffect -wrappedsdl2mixer/SupFpi3Mix_LoadMUS_RW -wrappedsdl2mixer/SupFpi3Mix_LoadWAV_RW -wrappedsdl2mixer/SupFpii3Mix_LoadMUSType_RW -wrappedsdl2mixer/SuiFippp3Mix_RegisterEffect -wrappedsdl2ttf/SupFpii3TTF_OpenFontRW -wrappedsdl2ttf/SupFpiii3TTF_OpenFontIndexRW -wrappedsmpeg/SuvFpp3SMPEG_getinfo -wrappedsmpeg/SupFipi3SMPEG_new_descr -wrappedsmpeg/SupFppi3SMPEG_new -wrappedsmpeg/SupFppi3SMPEG_new_rwops -wrappedsmpeg/SuvFpppp3SMPEG_setdisplay -wrappedsmpeg/SupFpipi3SMPEG_new_data -wrappedsmpeg2/SuvFpp3SMPEG_getinfo -wrappedsmpeg2/SupFipi3SMPEG_new_descr -wrappedsmpeg2/SupFppi3SMPEG_new -wrappedsmpeg2/SuvFpppp3SMPEG_setdisplay -wrappedsmpeg2/SupFpipi3SMPEG_new_data -wrappedsmpeg2/SupFppii3SMPEG_new_rwops -wrappedtcmallocminimal/SuiFpL3munmap -wrappedtcmallocminimal/SupFpLiiii3mmap -wrappedtcmallocminimal/SupFpLiiiI3mmap64 -wrappedutil/SuiFpppp3forkpty -wrappedvorbisfile/SuiFp3ov_bitrate_instant -wrappedvorbisfile/SuiFp3ov_clear -wrappedvorbisfile/SuiFp3ov_halfrate_p -wrappedvorbisfile/SuiFp3ov_seekable -wrappedvorbisfile/SuiFp3ov_streams -wrappedvorbisfile/SuiFp3ov_test_open -wrappedvorbisfile/SuIFp3ov_pcm_tell -wrappedvorbisfile/SuIFp3ov_raw_tell -wrappedvorbisfile/SudFp3ov_time_tell -wrappedvorbisfile/SuiFpi3ov_bitrate -wrappedvorbisfile/SuiFpi3ov_halfrate -wrappedvorbisfile/SuiFpi3ov_raw_seek -wrappedvorbisfile/SuiFpi3ov_raw_seek_lap -wrappedvorbisfile/SuiFpi3ov_serialnumber -wrappedvorbisfile/SuiFpI3ov_pcm_seek -wrappedvorbisfile/SuiFpI3ov_pcm_seek_lap -wrappedvorbisfile/SuiFpI3ov_pcm_seek_page -wrappedvorbisfile/SuiFpI3ov_pcm_seek_page_lap -wrappedvorbisfile/SuiFpd3ov_time_seek -wrappedvorbisfile/SuiFpd3ov_time_seek_lap -wrappedvorbisfile/SuiFpd3ov_time_seek_page -wrappedvorbisfile/SuiFpd3ov_time_seek_page_lap -wrappedvorbisfile/SuiFpp3ov_crosslap -wrappedvorbisfile/SuiFpp3ov_fopen -wrappedvorbisfile/SuIFpi3ov_pcm_total -wrappedvorbisfile/SuIFpi3ov_raw_total -wrappedvorbisfile/SudFpi3ov_time_total -wrappedvorbisfile/SupFpi3ov_comment -wrappedvorbisfile/SupFpi3ov_info -wrappedvorbisfile/SuiFppip3ov_read_float -wrappedvorbisfile/SuiFpppi3ov_open -wrappedvorbisfile/SuiFpppi3ov_test -wrappedvorbisfile/SuiFppiiiip3ov_read -wrappedvorbisfile/SuiFpppipppp3ov_open_callbacks -wrappedvorbisfile/SuiFppplpppp3ov_open_callbacks -wrappedvulkan/SuvFpp3vkDestroyDevice -wrappedvulkan/SuvFpp3vkDestroyInstance -wrappedvulkan/SuvFpp3vkGetPhysicalDeviceMemoryProperties -wrappedvulkan/SuvFpp3vkGetPhysicalDeviceProperties -wrappedvulkan/SupFpp3vkGetDeviceProcAddr -wrappedvulkan/SupFpp3vkGetInstanceProcAddr -wrappedvulkan/SuvFpUp3vkDestroyBuffer -wrappedvulkan/SuvFpUp3vkDestroyBufferView -wrappedvulkan/SuvFpUp3vkDestroyCommandPool -wrappedvulkan/SuvFpUp3vkDestroyDescriptorPool -wrappedvulkan/SuvFpUp3vkDestroyDescriptorSetLayout -wrappedvulkan/SuvFpUp3vkDestroyDescriptorUpdateTemplate -wrappedvulkan/SuvFpUp3vkDestroyDescriptorUpdateTemplateKHR -wrappedvulkan/SuvFpUp3vkDestroyEvent -wrappedvulkan/SuvFpUp3vkDestroyFence -wrappedvulkan/SuvFpUp3vkDestroyFramebuffer -wrappedvulkan/SuvFpUp3vkDestroyImage -wrappedvulkan/SuvFpUp3vkDestroyImageView -wrappedvulkan/SuvFpUp3vkDestroyPipeline -wrappedvulkan/SuvFpUp3vkDestroyPipelineCache -wrappedvulkan/SuvFpUp3vkDestroyPipelineLayout -wrappedvulkan/SuvFpUp3vkDestroyQueryPool -wrappedvulkan/SuvFpUp3vkDestroyRenderPass -wrappedvulkan/SuvFpUp3vkDestroySampler -wrappedvulkan/SuvFpUp3vkDestroySamplerYcbcrConversionKHR -wrappedvulkan/SuvFpUp3vkDestroySemaphore -wrappedvulkan/SuvFpUp3vkDestroyShaderModule -wrappedvulkan/SuvFpUp3vkDestroySurfaceKHR -wrappedvulkan/SuvFpUp3vkDestroySwapchainKHR -wrappedvulkan/SuvFppp3vkDestroyDebugUtilsMessengerEXT -wrappedvulkan/SuiFpUp3vkFreeMemory -wrappedvulkan/SuiFppp3vkGetPhysicalDeviceDisplayPropertiesKHR -wrappedvulkan/SuiFPpp3vkCreateInstance -wrappedvulkan/SuiFpUup3vkGetDisplayPlaneCapabilitiesKHR -wrappedvulkan/SuiFpppp3vkCreateDebugUtilsMessengerEXT -wrappedvulkan/SuiFpppp3vkCreateWaylandSurfaceKHR -wrappedvulkan/SuiFpPpp3vkAllocateMemory -wrappedvulkan/SuiFpPpp3vkCreateBuffer -wrappedvulkan/SuiFpPpp3vkCreateBufferView -wrappedvulkan/SuiFpPpp3vkCreateCommandPool -wrappedvulkan/SuiFpPpp3vkCreateDescriptorPool -wrappedvulkan/SuiFpPpp3vkCreateDescriptorSetLayout -wrappedvulkan/SuiFpPpp3vkCreateDescriptorUpdateTemplate -wrappedvulkan/SuiFpPpp3vkCreateDescriptorUpdateTemplateKHR -wrappedvulkan/SuiFpPpp3vkCreateDevice -wrappedvulkan/SuiFpPpp3vkCreateDisplayPlaneSurfaceKHR -wrappedvulkan/SuiFpPpp3vkCreateEvent -wrappedvulkan/SuiFpPpp3vkCreateFence -wrappedvulkan/SuiFpPpp3vkCreateFramebuffer -wrappedvulkan/SuiFpPpp3vkCreateImage -wrappedvulkan/SuiFpPpp3vkCreateImageView -wrappedvulkan/SuiFpPpp3vkCreatePipelineCache -wrappedvulkan/SuiFpPpp3vkCreatePipelineLayout -wrappedvulkan/SuiFpPpp3vkCreateQueryPool -wrappedvulkan/SuiFpPpp3vkCreateRenderPass -wrappedvulkan/SuiFpPpp3vkCreateSampler -wrappedvulkan/SuiFpPpp3vkCreateSamplerYcbcrConversion -wrappedvulkan/SuiFpPpp3vkCreateSamplerYcbcrConversionKHR -wrappedvulkan/SuiFpPpp3vkCreateSemaphore -wrappedvulkan/SuiFpPpp3vkCreateShaderModule -wrappedvulkan/SuiFpPpp3vkCreateSwapchainKHR -wrappedvulkan/SuiFpPpp3vkCreateXcbSurfaceKHR -wrappedvulkan/SuiFpPpp3vkCreateXlibSurfaceKHR -wrappedvulkan/SuvFpupup3vkUpdateDescriptorSets -wrappedvulkan/SuiFpuppp3vkCreateSharedSwapchainsKHR -wrappedvulkan/SuiFpUPpp3vkCreateDisplayModeKHR -wrappedvulkan/SuiFpUuppp3vkCreateComputePipelines -wrappedvulkan/SuiFpUuppp3vkCreateGraphicsPipelines -wrappedvulkan/SuvFpiiiiipp3vkGetPhysicalDeviceSparseImageFormatProperties -wrappedvulkan/SuvFpiiiupupup3vkCmdPipelineBarrier -wrappedxml2/SuvFp3xmlSetExternalEntityLoader -wrappedxml2/SuiFp3xmlParseDocument -wrappedxml2/SupFv3xmlGetExternalEntityLoader -wrappedxml2/SuvFpp3xmlHashFree -wrappedxml2/SupFpp3xmlHashCopy -wrappedxml2/SuvFppp3xmlHashScan -wrappedxml2/SuvFppp3xmlHashScanFull -wrappedxml2/SuvFppp3xmlSchemaSetParserStructuredErrors -wrappedxml2/SuvFppp3xmlSchemaSetValidStructuredErrors -wrappedxml2/SuiFppp3xmlHashRemoveEntry -wrappedxml2/SuiFppp3xmlXPathRegisterFunc -wrappedxml2/SupFppp3xmlNewCharEncodingHandler -wrappedxml2/SuvFpppp3xmlSchemaSetParserErrors -wrappedxml2/SuvFpppp3xmlSchemaSetValidErrors -wrappedxml2/SuiFpppp3xmlHashRemoveEntry2 -wrappedxml2/SuiFpppp3xmlHashUpdateEntry -wrappedxml2/SuiFpppp3xmlRegisterInputCallbacks -wrappedxml2/SupFpppi3xmlParserInputBufferCreateIO -wrappedxml2/SupFpppp3xmlOutputBufferCreateIO -wrappedxml2/SuiFppppp3xmlHashRemoveEntry3 -wrappedxml2/SuiFppppp3xmlHashUpdateEntry2 -wrappedxml2/SupFppppi3xmlSaveToIO -wrappedxml2/SuvFpppppp3xmlHashScan3 -wrappedxml2/SuvFpppppp3xmlHashScanFull3 -wrappedxml2/SuiFpppppp3xmlHashUpdateEntry3 -wrappedxslt/SuvFp3xsltSetLoaderFunc -wrappedxslt/SuiFppp3xsltRegisterExtModuleFunction +#defined(NOALIGN) iFpvpV -> iFppV +wrappedalure: +wrappedalut: +wrappedappindicator: +wrappedatk: +wrappedatkbridge: +wrappedbz2: +- iFp: + - BZ2_bzCompressEnd + - BZ2_bzDecompress + - BZ2_bzDecompressEnd +- iFpi: + - BZ2_bzCompress +- iFpii: + - BZ2_bzDecompressInit +- iFpiii: + - BZ2_bzCompressInit +wrappedcairo: +wrappedcrashhandler: +wrappedcrypto: +- vFv: + - OPENSSL_add_all_algorithms_conf + - OPENSSL_add_all_algorithms_noconf + - OpenSSL_add_all_ciphers + - OpenSSL_add_all_digests +- vFp: + - CRYPTO_set_id_callback + - CRYPTO_set_locking_callback +- pFp: + - sk_new +- vFpp: + - sk_pop_free +- pFpppp: + - PEM_read_bio_DSAPrivateKey + - PEM_read_bio_DSA_PUBKEY + - PEM_read_bio_ECPrivateKey + - PEM_read_bio_EC_PUBKEY + - PEM_read_bio_RSAPrivateKey + - PEM_read_bio_RSA_PUBKEY +- iFpiipp: + - ENGINE_ctrl +- iFpplppi: + - ENGINE_ctrl_cmd +- iFppppipp: + - PEM_write_bio_DSAPrivateKey + - PEM_write_bio_ECPrivateKey + - PEM_write_bio_RSAPrivateKey +wrappedcurl: +- uFpup: + - curl_easy_setopt +wrappedd3dadapter9: +- pFp: + - D3DAdapter9GetProc +wrappeddbus: +- vFppp: + - dbus_connection_remove_filter + - dbus_timeout_set_data + - dbus_watch_set_data +- vFpppp: + - dbus_connection_set_dispatch_status_function + - dbus_connection_set_wakeup_main_function +- iFpipp: + - dbus_connection_set_data + - dbus_message_set_data + - dbus_pending_call_set_data +- iFppip: + - dbus_message_get_args_valist +- iFppiV: + - dbus_message_get_args +- iFpppp: + - dbus_connection_add_filter + - dbus_pending_call_set_notify +- iFppppp: + - dbus_connection_try_register_object_path +- iFpppppp: + - dbus_connection_set_timeout_functions + - dbus_connection_set_watch_functions +wrappeddbusglib1: +- vFppp: + - dbus_g_type_collection_value_iterate + - dbus_g_type_map_value_iterate +- vFpppp: + - dbus_g_proxy_disconnect_signal +- vFppppp: + - dbus_g_proxy_connect_signal +- pFpppppiV: + - dbus_g_proxy_begin_call +- pFpppppiiV: + - dbus_g_proxy_begin_call_with_timeout +wrappeddbusmenuglib: +wrappeddbusmenugtk: +wrappedexpat: +- vFpp: + - XML_SetCharacterDataHandler +- vFppp: + - XML_SetElementHandler +wrappedfontconfig: +- iFppiuui: + - FcPatternAdd + - FcPatternAddWeak +wrappedfreetype: +- iFpplp: + - FT_Open_Face +- iFpuuLppp: + - FTC_Manager_New +wrappedgdk3: +- vFpp: + - gdk_init +- iFpp: + - gdk_init_check +- vFppp: + - gdk_event_handler_set + - gdk_window_add_filter + - gdk_window_remove_filter +- iFiipp: + - gdk_input_add +- iFiippp: + - gdk_input_add_full +wrappedgdkpixbuf2: +- pFpiiiiiipp: + - gdk_pixbuf_new_from_data +wrappedgdkx112: +- vFpp: + - gdk_init +- iFpp: + - gdk_init_check +- vFppp: + - gdk_event_handler_set + - gdk_window_add_filter + - gdk_window_remove_filter +- iFiipp: + - gdk_input_add +- iFiippp: + - gdk_input_add_full +wrappedgio2: +- vFppp: + - g_simple_async_result_set_op_res_gpointer +- vFippp: + - g_bus_get +- vFppip: + - g_simple_async_result_run_in_thread +- vFpppp: + - g_dbus_connection_close + - g_dbus_connection_flush + - g_simple_async_report_gerror_in_idle + - g_simple_async_report_take_gerror_in_idle +- uFpppp: + - g_dbus_connection_add_filter +- LFpppp: + - g_cancellable_connect +- pFpppp: + - g_simple_async_result_new + - g_simple_async_result_new_from_error + - g_simple_async_result_new_take_error +- vFpippp: + - g_async_initable_init_async +- vFpipppp: + - g_dbus_connection_new_for_address +- vFiippppV: + - g_async_initable_new_async +- vFiupippp: + - g_async_initable_newv_async +- vFippippp: + - g_async_initable_new_valist_async +- vFppipppp: + - g_dbus_connection_new +- vFpppuipV: + - g_simple_async_report_error_in_idle +- uFipipppp: + - g_bus_watch_name +- uFppipppp: + - g_bus_own_name_on_connection + - g_bus_watch_name_on_connection +- uFppppppp: + - g_dbus_connection_register_object +- pFpppuipV: + - g_simple_async_result_new_error +- vFppiipppp: + - g_dbus_connection_send_message_with_reply +- vFpppiippp: + - g_dbus_proxy_call +- uFipippppp: + - g_bus_own_name +- vFiippppppp: + - g_dbus_proxy_new_for_bus +- vFpippppppp: + - g_dbus_proxy_new +- vFpppiipppp: + - g_dbus_proxy_call_with_unix_fd_list +- pFiippppppp: + - g_dbus_object_manager_client_new_for_bus_sync +- uFppppppippp: + - g_dbus_connection_signal_subscribe +- vFpppppppiippp: + - g_dbus_connection_call +wrappedglib2: +- pFp: + - g_completion_new + - g_main_context_get_poll_func + - g_private_new + - g_ptr_array_new_with_free_func + - g_set_print_handler + - g_set_printerr_handler +- vFpp: + - g_array_set_clear_func + - g_array_sort + - g_completion_set_compare + - g_list_free_full + - g_main_context_set_poll_func + - g_ptr_array_set_free_func + - g_ptr_array_sort + - g_source_set_funcs + - g_thread_foreach +- vFpV: + - g_print + - g_printerr +- iFpp: + - g_source_remove_by_funcs_user_data + - g_vprintf +- uFpp: + - g_idle_add + - g_printf_string_upper_bound +- pFup: + - g_ptr_array_new_full +- pFpu: + - g_source_new +- pFpp: + - g_hash_table_new + - g_list_sort + - g_log_set_default_handler + - g_markup_vprintf_escaped + - g_slist_sort + - g_strdup_vprintf + - g_variant_new_parsed_va +- pFpV: + - g_build_filename + - g_markup_printf_escaped + - g_variant_new +- vFppp: + - g_array_sort_with_data + - g_hash_table_foreach + - g_ptr_array_foreach + - g_ptr_array_sort_with_data + - g_static_private_set +- vFppV: + - g_variant_get +- iFppp: + - g_vasprintf + - g_vfprintf + - g_vsprintf +- uFipp: + - g_child_watch_add +- uFupp: + - g_timeout_add + - g_timeout_add_seconds +- uFppp: + - g_hash_table_foreach_remove + - g_hash_table_foreach_steal +- pFppp: + - g_hash_table_find + - g_list_find_custom + - g_list_sort_with_data + - g_queue_find_custom + - g_slist_find_custom + - g_slist_foreach + - g_slist_insert_sorted + - g_slist_sort_with_data + - g_variant_new_va +- pFppV: + - g_build_path +- vFpupp: + - g_datalist_id_set_data_full +- vFpppp: + - g_source_set_callback +- iFpLpp: + - g_vsnprintf +- uFippp: + - g_idle_add_full +- uFpipp: + - g_io_add_watch + - g_log_set_handler +- pFpupp: + - g_datalist_id_dup_data +- pFppip: + - g_thread_create +- pFpppp: + - g_hash_table_new_full + - g_slist_insert_sorted_with_data +- vFpiLpp: + - g_qsort_with_data +- vFppipV: + - g_set_error +- uFiippp: + - g_child_watch_add_full +- uFiuppp: + - g_timeout_add_full + - g_timeout_add_seconds_full +- iFpupppp: + - g_datalist_id_replace_data +- uFpiippp: + - g_io_add_watch_full +- pFppuipp: + - g_variant_new_from_data +- pFppLiiip: + - g_thread_create_full +- iFpppipppp: + - g_spawn_async +- iFpppipppppp: + - g_spawn_sync +- iFpppippppppp: + - g_spawn_async_with_pipes +wrappedgmodule2: +wrappedgnutls: +- vFp: + - gnutls_global_set_log_function +- vFpp: + - gnutls_transport_set_pull_function + - gnutls_transport_set_pull_timeout_function + - gnutls_transport_set_push_function +wrappedgobject2: +- pFp: + - g_param_spec_get_default_value + - g_type_class_peek_parent + - g_value_reset +- iFpp: + - g_param_type_register_static +- pFpi: + - g_value_init +- pFpp: + - g_value_array_sort +- vFiip: + - g_type_add_interface_static + - g_value_register_transform_func +- iFppp: + - g_boxed_type_register_static +- pFipV: + - g_object_new +- pFppp: + - g_value_array_sort_with_data +- pFppV: + - g_object_connect +- vFpupp: + - g_param_spec_set_qdata_full +- vFpppp: + - g_object_set_data_full +- iFippi: + - g_type_register_static +- iFipppi: + - g_type_register_fundamental +- LFupppp: + - g_signal_add_emission_hook +- LFpppppu: + - g_signal_connect_data +- iFipupupi: + - g_type_register_static_simple +- uFpiupppp: + - g_signal_handlers_block_matched + - g_signal_handlers_disconnect_matched + - g_signal_handlers_unblock_matched +- LFpiupppp: + - g_signal_handler_find +- uFpiiupppiuV: + - g_signal_new +- uFpiippppiup: + - g_signal_new_valist + - g_signal_newv +wrappedgssapikrb5: +wrappedgstinterfaces010: +wrappedgstreamer010: +wrappedgthread2: +- vFp: + - g_thread_init + - g_thread_init_with_errorcheck_mutexes +wrappedgtk3: +- pFi: + - gtk_type_class +- vFpp: + - gtk_init +- iFpp: + - gtk_init_check + - gtk_type_unique +- vFppp: + - gtk_builder_connect_signals_full + - gtk_container_forall + - gtk_menu_attach_to_widget +- vFppV: + - gtk_dialog_add_buttons + - gtk_message_dialog_format_secondary_markup + - gtk_message_dialog_format_secondary_text +- uFupp: + - gtk_timeout_add +- vFpppp: + - gtk_object_set_data_full + - gtk_stock_set_translate_func + - gtk_tree_sortable_set_default_sort_func + - gtk_tree_view_set_search_equal_func +- iFpppp: + - gtk_text_iter_backward_find_char + - gtk_text_iter_forward_find_char +- vFpippp: + - gtk_tree_sortable_set_sort_func +- iFppuppp: + - gtk_clipboard_set_with_data + - gtk_clipboard_set_with_owner +- iFpppppp: + - gtk_init_with_args +- vFpppppuu: + - gtk_menu_popup +- pFppppppi: + - gtk_toolbar_insert_stock +- pFppppppp: + - gtk_toolbar_append_item + - gtk_toolbar_prepend_item +- LFppppppii: + - gtk_signal_connect_full +- pFpppppppi: + - gtk_toolbar_insert_item +- pFpippppppp: + - gtk_toolbar_append_element + - gtk_toolbar_prepend_element +- pFpipppppppi: + - gtk_toolbar_insert_element +wrappedgtkx112: +- fFp: + - gtk_spin_button_get_value_as_float +- pFi: + - gtk_type_class +- vFpp: + - gtk_builder_connect_signals + - gtk_init +- iFpp: + - gtk_init_check + - gtk_type_unique +- pFpi: + - gtk_type_check_object_cast +- vFppp: + - gtk_builder_connect_signals_full + - gtk_clipboard_request_text + - gtk_container_forall + - gtk_container_foreach + - gtk_menu_attach_to_widget + - gtk_tree_model_foreach +- vFppV: + - gtk_dialog_add_buttons + - gtk_message_dialog_format_secondary_markup + - gtk_message_dialog_format_secondary_text +- uFupp: + - gtk_timeout_add +- vFppup: + - gtk_action_group_add_actions +- vFpppp: + - gtk_clipboard_request_contents + - gtk_object_set_data_full + - gtk_stock_set_translate_func + - gtk_tree_sortable_set_default_sort_func + - gtk_tree_view_set_search_equal_func +- iFpppp: + - gtk_text_iter_backward_find_char + - gtk_text_iter_forward_find_char +- LFpppp: + - gtk_signal_connect +- vFpippp: + - gtk_tree_sortable_set_sort_func +- vFppupp: + - gtk_action_group_add_actions_full +- vFppppp: + - gtk_cell_layout_set_cell_data_func +- vFpuipuV: + - gtk_binding_entry_add_signal +- iFppuppp: + - gtk_clipboard_set_with_data + - gtk_clipboard_set_with_owner +- iFpppppp: + - gtk_init_with_args +- uFiipppp: + - gtk_input_add_full +- vFpppppuu: + - gtk_menu_popup +- pFppppppi: + - gtk_toolbar_insert_stock +- pFppppppp: + - gtk_toolbar_append_item + - gtk_toolbar_prepend_item +- LFppppppii: + - gtk_signal_connect_full +- pFpppppppi: + - gtk_toolbar_insert_item +- pFpippppppp: + - gtk_toolbar_append_element + - gtk_toolbar_prepend_element +- pFpipppppppi: + - gtk_toolbar_insert_element +wrappedgudev1: +wrappediconv: +wrappedkrb5: +- iFppppppipp: + - krb5_get_init_creds_password +wrappedlber: +wrappedlcms2: +- vFp: + - cmsSetLogErrorHandler +wrappedldapr: +- iFpppppupp: + - ldap_sasl_interactive_bind_s +wrappedldlinux: +- pFv: + - ___tls_get_addr +- pFp: + - __tls_get_addr +wrappedlibasound: +- iFp: + - snd_dlclose + - snd_lib_error_set_handler +- pFppp: + - snd_dlsym +- iFpipp: + - snd_async_add_handler +- iFpppp: + - snd_async_add_pcm_handler +- pFpipL: + - snd_dlopen +wrappedlibc: +- vFv: +- vFp: +- iFv: +- iFi: +- iFL: +- iFp: +- iFO: +- uFv: +- uFu: +- uFp: +- LFL: +- pFL: +- pFp: +- vFip: +- vFpi: +- vFpu: +- vFpp: +- vFpV: +- iFip: + - fstat +- iFpi: +- iFpL: +- iFpp: + - lstat + - stat +- iFpV: +- iFSp: + - _IO_file_stat +- IFII: +- UFUU: +- pFip: +- pFpi: +- pFpp: +- vFipV: +- vFpuu: +- vFpup: + - _ITM_addUserCommitAction +- vFppu: +- vFppp: +- iFvpp: +- iFvpV: +- iFiip: +- iFiiN: +- iFipL: + - modify_ldt +- iFipp: + - getopt +- iFipV: +- iFpuu: +- iFpLi: +- iFppi: +- iFppL: +- iFppp: +- iFppV: +- iFpOu: +- iFpOV: +- lFipL: +- pFpii: +- pFpip: +- pFpLL: +- vFpLLp: +- vFpppp: + - __libc_init +- iFiiip: +- iFiiiN: +- iFiiII: +- iFipii: +- iFipuu: +- iFippi: +- iFpvpp: +- iFpvpV: +- iFpipp: +- iFpipV: +- iFpuii: +- iFpupV: +- iFpLpV: +- iFppii: +- iFppiV: +- iFpppp: +- lFipiI: +- lFpupp: +- vFpLLpp: +- iFiippi: +- iFipipu: +- iFipuup: +- iFipppp: + - getopt_long + - getopt_long_only +- iFpvvpV: +- iFpiLpp: +- iFpippp: +- iFpuppp: +- iFpLLpp: +- iFpLppp: +- pFpLLiN: +- pFppLLp: +- pFpppLp: +- iFpuiupV: +- iFpLiipV: +- iFpppppp: +- pFpLiiii: +- pFpLiiiI: +- pFpppppp: +- iFpippppp: +- iFpuvvppp: +wrappedlibcrypt: +wrappedlibcups: +wrappedlibdl: +- iFp: + - dlclose +- pFv: + - dlerror +- iFpp: + - dladdr +- pFpi: + - dlopen +- pFpp: + - dlsym +- iFpip: + - dlinfo +- pFppi: + - dlmopen +- pFppp: + - dlvsym +wrappedlibdrm: +wrappedlibformw: +wrappedlibgl: +- iFi: + - glXSwapIntervalMESA +- pFp: + - glXGetProcAddress + - glXGetProcAddressARB +- vFpp: + - glDebugMessageCallback + - glDebugMessageCallbackAMD + - glDebugMessageCallbackARB +- vFipp: + - glProgramCallbackMESA +wrappedlibglu: +- vFpip: + - gluNurbsCallback + - gluQuadricCallback + - gluTessCallback +wrappedlibice: +wrappedlibjpeg: +- iFv: + - jpeg_simd_cpu_support +- iFp: + - jpeg_finish_decompress + - jpeg_start_decompress +- pFp: + - jpeg_std_error +- iFpi: + - jpeg_read_header +- vFpiL: + - jpeg_CreateDecompress +- vFpip: + - jpeg_set_marker_processor +- uFppu: + - jpeg_read_scanlines +wrappedlibjpeg62: +- vFp: + - jpeg_destroy_compress + - jpeg_destroy_decompress + - jpeg_finish_compress + - jpeg_set_defaults +- iFv: + - jpeg_simd_cpu_support +- iFp: + - jpeg_finish_decompress + - jpeg_start_decompress +- pFp: + - jpeg_std_error +- vFpi: + - jpeg_start_compress +- iFpi: + - jpeg_read_header + - jpeg_resync_to_restart +- vFpii: + - jpeg_set_quality +- vFpiL: + - jpeg_CreateCompress + - jpeg_CreateDecompress +- vFpip: + - jpeg_set_marker_processor +- vFppp: + - jpeg_mem_dest +- uFppu: + - jpeg_read_scanlines + - jpeg_write_scanlines +- vFpipu: + - jpeg_write_marker +wrappedlibm: +- UFs: + - cacosf + - cacoshf + - casinf + - casinhf + - catanf + - catanhf + - ccosf + - ccoshf + - cexpf + - clogf + - cprojf + - csinf + - csinhf + - csqrtf + - ctanf + - ctanhf +- fFf: + - __acosf_finite + - __acoshf_finite + - __asinf_finite + - __coshf_finite + - __exp2f_finite + - __expf_finite + - __log10f_finite + - __log2f_finite + - __logf_finite + - __sinhf_finite + - __sqrtf_finite +- dFd: + - __acos_finite + - __acosh_finite + - __asin_finite + - __cosh_finite + - __exp2_finite + - __exp_finite + - __log10_finite + - __log2_finite + - __log_finite + - __sinh_finite + - __sqrt_finite +- fFff: + - __atan2f_finite + - __hypotf_finite + - __powf_finite +- dFdd: + - __atan2_finite + - __hypot_finite + - __pow_finite +- pFps: +- UFsvvs: + - cpowf +- pFpsvvvvs: +wrappedlibncurses: +- pFv: + - initscr +- iFpV: + - printw +- iFppV: + - vw_printw + - vwprintw +- iFiipV: + - mvprintw +- iFpiipV: + - mvwprintw +wrappedlibncurses6: +- pFv: + - initscr +- iFpV: + - printw +- iFppV: + - vw_printw +- iFiipV: + - mvprintw +- iFpiipV: + - mvwprintw +wrappedlibncursesw: +- pFv: + - initscr +- iFpV: + - printw +- iFppV: + - vw_printw + - vwprintw +- iFiipV: + - mvprintw +- iFpiipV: + - mvwprintw +wrappedlibnm: +wrappedlibogg: +wrappedlibpanel: +wrappedlibpthread: +- vFv: + - __pthread_initialize +- vFp: + - __pthread_register_cancel + - __pthread_unregister_cancel + - __pthread_unwind_next +- iFp: + - __pthread_mutex_destroy + - __pthread_mutex_lock + - __pthread_mutex_trylock + - __pthread_mutex_unlock + - pthread_attr_destroy + - pthread_mutex_destroy + - pthread_mutex_lock + - pthread_mutex_trylock + - pthread_mutex_unlock +- vFpi: + - _pthread_cleanup_pop + - _pthread_cleanup_pop_restore +- iFpi: + - pthread_attr_setscope + - pthread_kill + - pthread_mutexattr_setkind_np +- iFpp: + - __pthread_key_create + - __pthread_mutex_init + - __pthread_once + - pthread_attr_setschedparam + - pthread_cond_wait + - pthread_key_create + - pthread_mutex_init + - pthread_mutex_timedlock + - pthread_once + - pthread_setname_np +- vFppp: + - _pthread_cleanup_push + - _pthread_cleanup_push_defer +- iFLup: + - pthread_setaffinity_np +- iFpup: + - pthread_attr_setaffinity_np + - pthread_getaffinity_np +- iFppu: + - pthread_getname_np +- iFppL: + - pthread_attr_setstack +- iFppp: + - __pthread_atfork + - pthread_atfork + - pthread_attr_getstack + - pthread_cond_timedwait +- iFpppp: + - pthread_create +wrappedlibresolv: +wrappedlibrt: +- iFupp: + - timer_create +wrappedlibsm: +- iFppp: + - SmcRequestSaveYourselfPhase2 +- iFpipp: + - SmcInteractRequest +- pFppiiLpppip: + - SmcOpenConnection +wrappedlibsndfile: +- iFp: + - sf_close +- pFpipp: + - sf_open_virtual +wrappedlibssl: +- vFpp: + - SSL_CTX_sess_set_new_cb + - SSL_CTX_set_default_passwd_cb + - SSL_set_psk_client_callback +- vFpip: + - SSL_CTX_set_verify + - SSL_set_verify +- vFppp: + - SSL_CTX_set_next_proto_select_cb +- lFpip: + - SSL_CTX_callback_ctrl + - SSL_callback_ctrl +- iFlpppp: + - SSL_get_ex_new_index +wrappedlibtiff: +- pFpppppppppp: + - TIFFClientOpen +wrappedlibtinfo: +- iFpip: + - tputs +wrappedlibtinfo6: +- iFpip: + - tputs +wrappedlibusb1: +- iFp: + - libusb_cancel_transfer + - libusb_submit_transfer +- pFi: + - libusb_alloc_transfer +- iFpiiiiippp: + - libusb_hotplug_register_callback +wrappedlibuuid: +wrappedlibv4l2: +- iFpL: + - v4l2_munmap +- pFpLiiii: + - v4l2_mmap +wrappedlibvorbis: +- vFp: + - vorbis_dsp_clear +- iFp: + - vorbis_bitrate_addblock + - vorbis_block_clear + - vorbis_synthesis_restart +- iFpi: + - vorbis_analysis_wrote + - vorbis_synthesis_read +- iFpp: + - vorbis_analysis + - vorbis_analysis_blockout + - vorbis_analysis_init + - vorbis_bitrate_flushpacket + - vorbis_block_init + - vorbis_synthesis + - vorbis_synthesis_blockin + - vorbis_synthesis_init + - vorbis_synthesis_lapout + - vorbis_synthesis_pcmout + - vorbis_synthesis_trackonly +- pFpi: + - vorbis_analysis_buffer + - vorbis_window +- iFppppp: + - vorbis_analysis_headerout +wrappedlibx11: +- iFp: + - XCloseDisplay + - XDestroyImage + - XInitImage +- pFp: + - XOpenDisplay + - XSetErrorHandler + - XSetIOErrorHandler +- vFpp: + - _XDeqAsyncHandler +- iFpi: + - XSynchronize +- pFpp: + - XLoadQueryFont + - XSetAfterFunction +- iFppu: + - XSetBackground + - XSetForeground +- iFppp: + - XAddConnectionWatch + - XRemoveConnectionWatch +- pFpip: + - XESetCloseDisplay + - XESetError + - XESetEventToWire + - XESetWireToEvent +- iFpppp: + - XCheckIfEvent + - XIfEvent + - XPeekIfEvent +- pFppup: + - XCreateGC +- iFppppp: + - XQueryExtension +- iFpppppp: + - XRegisterIMInstantiateCallback + - XUnregisterIMInstantiateCallback +- pFppiiuuui: + - XGetImage +- iFppppiiiiuu: + - XPutImage +- pFppuiipuuii: + - XCreateImage +- pFppiiuuuipii: + - XGetSubImage +wrappedlibx11xcb: +wrappedlibxau: +wrappedlibxcb: +% X my_xcb_XXX_iterator_t pii +% x my_xcb_cookie_t u +- xFp: + - xcb_get_input_focus + - xcb_get_modifier_mapping + - xcb_grab_server + - xcb_ungrab_server +- XFp: + - xcb_depth_visuals_iterator + - xcb_screen_allowed_depths_iterator + - xcb_setup_pixmap_formats_iterator + - xcb_setup_roots_iterator +- xFpC: + - xcb_bell +- xFpu: + - xcb_close_font + - xcb_close_font_checked + - xcb_destroy_window + - xcb_free_colormap + - xcb_free_colormap_checked + - xcb_free_gc + - xcb_free_pixmap + - xcb_get_atom_name + - xcb_get_geometry + - xcb_get_geometry_unchecked + - xcb_get_selection_owner + - xcb_get_selection_owner_unchecked + - xcb_get_window_attributes + - xcb_get_window_attributes_unchecked + - xcb_map_subwindows + - xcb_map_window + - xcb_map_window_checked + - xcb_query_pointer + - xcb_query_tree + - xcb_query_tree_unchecked + - xcb_ungrab_keyboard + - xcb_ungrab_keyboard_checked + - xcb_ungrab_pointer + - xcb_unmap_window +- xFpp: + - xcb_free_cursor +- xFpCC: + - xcb_get_keyboard_mapping +- xFpup: + - xcb_change_keyboard_control +- xFppp: + - xcb_delete_property +- xFpCWp: + - xcb_intern_atom + - xcb_intern_atom_unchecked +- xFpCuW: + - xcb_ungrab_button + - xcb_ungrab_button_checked + - xcb_ungrab_key + - xcb_ungrab_key_checked +- xFpCuu: + - xcb_set_input_focus +- xFpuWp: + - xcb_configure_window + - xcb_open_font + - xcb_open_font_checked +- xFpuuu: + - xcb_set_selection_owner +- xFpuup: + - xcb_change_gc + - xcb_change_gc_checked + - xcb_change_window_attributes + - xcb_change_window_attributes_checked + - xcb_query_text_extents +- xFpCuup: + - xcb_send_event +- xFpCppp: + - xcb_create_colormap +- xFpuWWW: + - xcb_alloc_color +- xFpuuWW: + - xcb_reparent_window + - xcb_translate_coordinates + - xcb_translate_coordinates_unchecked +- xFpuuup: + - xcb_create_gc + - xcb_create_gc_checked + - xcb_poly_arc + - xcb_poly_fill_rectangle + - xcb_poly_rectangle + - xcb_poly_segment +- xFpCuuCC: + - xcb_grab_keyboard +- xFpCuuWW: + - xcb_create_pixmap +- xFpCuuup: + - xcb_poly_line + - xcb_poly_line_checked + - xcb_poly_point +- xFpuuuuu: + - xcb_convert_selection +- xFpCuwwWW: + - xcb_clear_area +- xFpCuWCCC: + - xcb_grab_key + - xcb_grab_key_checked +- xFpCuuwwp: + - xcb_image_text_8 + - xcb_image_text_8_checked +- xFpCuuuuu: + - xcb_get_property + - xcb_get_property_unchecked +- xFpCuwwWWu: + - xcb_get_image + - xcb_get_image_unchecked +- xFpCuuuCup: + - xcb_change_property + - xcb_change_property_checked +- xFpCuWCCuuu: + - xcb_grab_pointer +- xFpuuwwWWww: + - xcb_warp_pointer +- xFpCuWCCuuCW: + - xcb_grab_button + - xcb_grab_button_checked +- xFpuuuwwwwWW: + - xcb_copy_area +- xFpCuuWWwwCCup: + - xcb_put_image +- xFpuuuWWWWWWWW: + - xcb_create_cursor + - xcb_create_glyph_cursor +- xFpCuuwwWWWWuup: + - xcb_create_window + - xcb_create_window_checked +% XFEp -> pFEpp +% xFEp -> pFEpp +% xFEpC -> pFEppC +% xFEpu -> pFEppu +% xFEpp -> pFEppp +% xFEpCC -> pFEppCC +% xFEpup -> pFEppup +% xFEppp -> pFEpppp +% xFEpCWp -> pFEppCWp +% xFEpCuW -> pFEppCuW +% xFEpCuu -> pFEppCuu +% xFEpuWp -> pFEppuWp +% xFEpuuu -> pFEppuuu +% xFEpuup -> pFEppuup +% xFEpCuup -> pFEppCuup +% xFEpCppp -> pFEppCppp +% xFEpuWWW -> pFEppuWWW +% xFEpuuWW -> pFEppuuWW +% xFEpuuup -> pFEppuuup +% xFEpCuuCC -> pFEppCuuCC +% xFEpCuuWW -> pFEppCuuWW +% xFEpCuuup -> pFEppCuuup +% xFEpuuuuu -> pFEppuuuuu +% xFEpCuwwWW -> pFEppCuwwWW +% xFEpCuWCCC -> pFEppCuWCCC +% xFEpCuuwwp -> pFEppCuuwwp +% xFEpCuuuuu -> pFEppCuuuuu +% xFEpCuwwWWu -> pFEppCuwwWWu +% xFEpCuuuCup -> pFEppCuuuCup +% xFEpCuWCCuuu -> pFEppCuWCCuuu +% xFEpuuwwWWww -> pFEppuuwwWWww +% xFEpCuWCCuuCW -> pFEppCuWCCuuCW +% xFEpuuuwwwwWW -> pFEppuuuwwwwWW +% xFEpCuuWWwwCCup -> pFEppCuuWWwwCCup +% xFEpuuuWWWWWWWW -> pFEppuuuWWWWWWWW +% xFEpCuuwwWWWWuup -> pFEppCuuwwWWWWuup +wrappedlibxcbdri2: +% x my_xcb_cookie_t u +- xFpuu: + - xcb_dri2_authenticate + - xcb_dri2_connect + - xcb_dri2_query_version +% xFEpuu -> pFEppuu +wrappedlibxcbdri3: +% x my_xcb_cookie_t u +- xFpuu: + - xcb_dri3_open + - xcb_dri3_query_version +- xFpuuuWWWCCi: + - xcb_dri3_pixmap_from_buffer_checked +% xFEpuu -> pFEppuu +% xFEpuuuWWWCCi -> pFEppuuuWWWCCi +wrappedlibxcbimage: +% x my_xcb_cookie_t u +- xFpuupwwC: + - xcb_image_put +% xFEpuupwwC -> pFEppuupwwC +wrappedlibxcbkeysyms: +wrappedlibxcbpresent: +% x my_xcb_cookie_t u +- xFpuu: + - xcb_present_query_version +- xFpuuu: + - xcb_present_select_input_checked +- xFpuuUUU: + - xcb_present_notify_msc +- xFpuuuuuwwuuuuUUUup: + - xcb_present_pixmap + - xcb_present_pixmap_checked +% xFEpuu -> pFEppuu +% xFEpuuu -> pFEppuuu +% xFEpuuUUU -> pFEppuuUUU +% xFEpuuuuuwwuuuuUUUup -> pFEppuuuuuwwuuuuUUUup +wrappedlibxcbrandr: +% X my_xcb_iterator_t pii +% x my_xcb_cookie_t u +- XFp: + - xcb_randr_get_screen_resources_current_outputs_end +- xFpu: + - xcb_randr_get_output_primary + - xcb_randr_get_output_primary_unchecked + - xcb_randr_get_screen_resources + - xcb_randr_get_screen_resources_current + - xcb_randr_get_screen_resources_outputs + - xcb_randr_get_screen_resources_unchecked +- xFpuW: + - xcb_randr_select_input + - xcb_randr_select_input_checked +- xFpuu: + - xcb_randr_query_version + - xcb_randr_query_version_unchecked +- xFppu: + - xcb_randr_get_crtc_info + - xcb_randr_get_crtc_info_unchecked + - xcb_randr_get_output_info + - xcb_randr_get_output_info_unchecked +% XFEp -> pFEpp +% xFEpu -> pFEppu +% xFEpuu -> pFEppuu +% xFEpuW -> pFEppuW +% xFEppu -> pFEpppu +wrappedlibxcbshape: +% x my_xcb_cookie_t u +- xFpuuuwwu: + - xcb_shape_mask + - xcb_shape_mask_checked +% xFEpuuuwwu -> pFEppuuuwwu +wrappedlibxcbshm: +% X my_xcb_iterator_t pii +% x my_xcb_cookie_t u +- xFp: + - xcb_shm_query_version + - xcb_shm_query_version_unchecked +- XFX: + - xcb_shm_seg_end +- xFpu: + - xcb_shm_detach + - xcb_shm_detach_checked +- xFpuuC: + - xcb_shm_attach + - xcb_shm_attach_checked + - xcb_shm_attach_fd + - xcb_shm_attach_fd_checked + - xcb_shm_create_segment + - xcb_shm_create_segment_unchecked +- xFpuuWWCuu: + - xcb_shm_create_pixmap + - xcb_shm_create_pixmap_checked +- xFpuwwWWuCuu: + - xcb_shm_get_image + - xcb_shm_get_image_unchecked +- xFpuuWWWWWWwwCCCuu: + - xcb_shm_put_image + - xcb_shm_put_image_checked +% XFEX -> pFEppii +% xFEp -> pFEpp +% xFEpu -> pFEppu +% xFEpuuC -> pFEppuuC +% xFEpuuWWCuu -> pFEppuuWWCuu +% xFEpuwwWWuCuu -> pFEppuwwWWuCuu +% xFEpuuWWWWWWwwCCCuu -> pFEppuuWWWWWWwwCCCuu +wrappedlibxcbxfixes: +% x my_xcb_cookie_t u +- xFpu: + - xcb_xfixes_destroy_region +- xFpuu: + - xcb_xfixes_query_version_unchecked +- xFpuup: + - xcb_xfixes_create_region +- xFpuuwwu: + - xcb_xfixes_set_window_shape_region + - xcb_xfixes_set_window_shape_region_checked +% xFEpu -> pFEppu +% xFEpuu -> pFEppuu +% xFEpuup -> pFEppuup +% xFEpuuwwu -> pFEppuuwwu +wrappedlibxcbxtest: +% x my_xcb_cookie_t u +- xFpCCuuwwC: + - xcb_test_fake_input + - xcb_test_fake_input_checked +% xFEpCCuuwwC -> pFEppCCuuwwC +wrappedlibxcomposite: +wrappedlibxcursor: +wrappedlibxdamage: +wrappedlibxdmcp: +wrappedlibxext: +- pFp: + - XSetExtensionErrorHandler +- iFpppiiu: + - XShmGetImage +- pFppppip: + - XextAddDisplay +- pFppuippuu: + - XShmCreateImage +- iFppppiiiiuui: + - XShmPutImage +wrappedlibxfixes: +wrappedlibxft: +wrappedlibxi: +wrappedlibxmu: +wrappedlibxpm: +wrappedlibxrandr: +wrappedlibxrender: +wrappedlibxss: +wrappedlibxt: +- vFpuipp: + - XtAddEventHandler +wrappedlibxtst: +- iFpppp: + - XRecordEnableContext + - XRecordEnableContextAsync +wrappedlibxxf86vm: +- iFpip: + - XF86VidModeGetGamma + - XF86VidModeSetGamma +wrappedlibz: +- iFppi: + - inflateInit_ +- iFpipi: + - deflateInit_ + - inflateInit2_ +- iFpippi: + - inflateBackInit_ +- iFpiiiiipi: + - deflateInit2_ +wrappedmpg123: +- iFpppp: + - mpg123_replace_reader_handle + - mpg123_replace_reader_handle_32 + - mpg123_replace_reader_handle_64 +wrappednsl: +wrappedopenal: +- vFv: + - alRequestFoldbackStop +- pFp: + - alGetProcAddress +- pFpp: + - alcGetProcAddress +- vFiiipp: + - alRequestFoldbackStart +wrappedpango: +- vFpp: + - pango_attribute_init +wrappedpangocairo: +wrappedpangoft2: +wrappedpng12: +- vFppp: + - png_set_read_fn +- vFpppp: + - png_set_error_fn + - png_set_write_fn +- pFpppp: + - png_create_read_struct +- vFppppp: + - png_set_progressive_read_fn +- pFppppppp: + - png_create_read_struct_2 + - png_create_write_struct_2 +wrappedpng16: +- vFpp: + - png_set_read_user_transform_fn +- vFppp: + - png_set_read_fn +- vFpppp: + - png_set_error_fn + - png_set_write_fn +- pFpppp: + - png_create_read_struct +- vFppppp: + - png_set_progressive_read_fn +- pFppppppp: + - png_create_read_struct_2 + - png_create_write_struct_2 +wrappedpulse: +- vFp: + - pa_mainloop_free + - pa_threaded_mainloop_free +- iFp: + - pa_signal_init +- pFp: + - pa_mainloop_get_api + - pa_threaded_mainloop_get_api +- vFpp: + - pa_signal_set_destroy +- pFpp: + - pa_context_new +- vFppp: + - pa_context_set_event_callback + - pa_context_set_state_callback + - pa_context_set_subscribe_callback + - pa_mainloop_set_poll_func + - pa_stream_set_buffer_attr_callback + - pa_stream_set_event_callback + - pa_stream_set_latency_update_callback + - pa_stream_set_moved_callback + - pa_stream_set_overflow_callback + - pa_stream_set_read_callback + - pa_stream_set_started_callback + - pa_stream_set_state_callback + - pa_stream_set_suspended_callback + - pa_stream_set_underflow_callback + - pa_stream_set_write_callback +- pFipp: + - pa_signal_new +- pFppp: + - pa_context_drain + - pa_context_exit_daemon + - pa_context_get_client_info_list + - pa_context_get_module_info_list + - pa_context_get_server_info + - pa_context_get_sink_info_list + - pa_context_get_sink_input_info_list + - pa_context_get_source_info_list + - pa_context_new_with_proplist + - pa_stream_drain + - pa_stream_flush + - pa_stream_prebuf + - pa_stream_trigger + - pa_stream_update_timing_info +- iFppip: + - pa_context_connect +- iFpppV: + - pa_proplist_setf +- pFpipp: + - pa_stream_cork +- pFpupp: + - pa_context_get_sink_info_by_index + - pa_context_get_sink_input_info + - pa_context_get_source_info_by_index + - pa_context_subscribe + - pa_context_unload_module + - pa_stream_update_sample_rate +- pFpppp: + - pa_context_get_sink_info_by_name + - pa_context_get_source_info_by_name + - pa_context_proplist_remove + - pa_context_set_default_sink + - pa_context_set_default_source + - pa_context_set_name + - pa_stream_proplist_remove + - pa_stream_set_buffer_attr + - pa_stream_set_name +- pFpippp: + - pa_context_proplist_update + - pa_stream_proplist_update +- pFpuipp: + - pa_context_set_sink_input_mute + - pa_context_set_source_mute_by_index +- pFpuupp: + - pa_context_move_sink_input_by_index +- pFpuppp: + - pa_context_set_sink_input_volume + - pa_context_set_sink_volume_by_index + - pa_context_set_source_volume_by_index +- pFppppp: + - pa_context_load_module + - pa_context_set_source_volume_by_name +- iFppupIi: + - pa_stream_write +wrappedpulsesimple: +wrappedsdl1: +- vFp: + - SDL_KillThread + - SDL_SetEventFilter + - SDL_UnloadObject +- iFv: + - SDL_Has3DNow + - SDL_Has3DNowExt + - SDL_HasAltiVec + - SDL_HasMMX + - SDL_HasMMXExt + - SDL_HasRDTSC + - SDL_HasSSE + - SDL_HasSSE2 +- iFp: + - SDL_GetWMInfo + - SDL_RemoveTimer +- uFp: + - SDL_ReadBE16 + - SDL_ReadBE32 + - SDL_ReadLE16 + - SDL_ReadLE32 +- UFp: + - SDL_ReadBE64 + - SDL_ReadLE64 +- pFv: + - SDL_GetEventFilter +- pFp: + - SDL_GL_GetProcAddress + - SDL_LoadObject +- iFup: + - SDL_SetTimer +- iFpp: + - SDL_OpenAudio +- uFpW: + - SDL_WriteBE16 + - SDL_WriteLE16 +- uFpu: + - SDL_WriteBE32 + - SDL_WriteLE32 +- uFpU: + - SDL_WriteBE64 + - SDL_WriteLE64 +- pFpi: + - SDL_LoadBMP_RW + - SDL_RWFromConstMem + - SDL_RWFromFP + - SDL_RWFromMem +- pFpp: + - SDL_CreateThread + - SDL_LoadFunction + - SDL_RWFromFile +- iFppi: + - SDL_SaveBMP_RW +- pFupp: + - SDL_AddTimer +- pFpippp: + - SDL_LoadWAV_RW +wrappedsdl1image: +- pFp: + - IMG_LoadBMP_RW + - IMG_LoadCUR_RW + - IMG_LoadGIF_RW + - IMG_LoadICO_RW + - IMG_LoadJPG_RW + - IMG_LoadLBM_RW + - IMG_LoadPCX_RW + - IMG_LoadPNG_RW + - IMG_LoadPNM_RW + - IMG_LoadTGA_RW + - IMG_LoadTIF_RW + - IMG_LoadWEBP_RW + - IMG_LoadXCF_RW + - IMG_LoadXPM_RW + - IMG_LoadXV_RW +- pFpi: + - IMG_Load_RW +- pFpip: + - IMG_LoadTyped_RW +wrappedsdl1mixer: +- vFp: + - Mix_ChannelFinished + - Mix_HookMusicFinished +- pFp: + - Mix_LoadMUS_RW +- vFpp: + - Mix_HookMusic + - Mix_SetPostMix +- iFip: + - Mix_UnregisterEffect +- pFpi: + - Mix_LoadWAV_RW +- pFpii: + - Mix_LoadMUSType_RW +- iFippp: + - Mix_RegisterEffect +wrappedsdl1net: +wrappedsdl1sound: +- pFpppu: + - Sound_NewSample +wrappedsdl1ttf: +- pFpii: + - TTF_OpenFontRW +- pFpiii: + - TTF_OpenFontIndexRW +wrappedsdl2: +% J SDL_JoystickGUID uuuu +% g SDL_GameControllerButtonBind uii +- vFp: + - SDL_UnloadObject +- iFv: +- iFp: + - SDL_RWclose + - SDL_RemoveTimer + - SDL_SaveAllDollarTemplates +- iFJ: + - SDL_IsJoystickHIDAPI + - SDL_IsJoystickXInput +- IFp: + - SDL_RWtell +- uFp: + - SDL_ReadBE16 + - SDL_ReadBE32 + - SDL_ReadLE16 + - SDL_ReadLE32 + - SDL_ReadU8 +- UFp: + - SDL_ReadBE64 + - SDL_ReadLE64 +- pFv: + - SDL_GetBasePath + - SDL_Vulkan_GetVkGetInstanceProcAddr +- pFp: + - SDL_GL_GetProcAddress + - SDL_LoadObject +- JFi: + - SDL_JoystickGetDeviceGUID +- JFp: + - SDL_JoystickGetGUID + - SDL_JoystickGetGUIDFromString +- vFpp: + - SDL_AddEventWatch + - SDL_DelEventWatch + - SDL_LogGetOutputFunction + - SDL_LogSetOutputFunction + - SDL_SetEventFilter +- vFpV: + - SDL_Log +- iFip: + - SDL_SaveDollarTemplate +- iFWW: + - SDL_IsJoystickNintendoSwitchPro + - SDL_IsJoystickPS4 + - SDL_IsJoystickSteamController + - SDL_IsJoystickXbox360 + - SDL_IsJoystickXboxOne +- iFpi: + - SDL_GameControllerAddMappingsFromRW +- iFpp: + - SDL_GetEventFilter + - SDL_OpenAudio +- uFpW: + - SDL_WriteBE16 + - SDL_WriteLE16 +- uFpu: + - SDL_WriteBE32 + - SDL_WriteLE32 + - SDL_WriteU8 +- uFpU: + - SDL_WriteBE64 + - SDL_WriteLE64 +- pFpi: + - SDL_LoadBMP_RW + - SDL_RWFromConstMem + - SDL_RWFromFP + - SDL_RWFromMem +- pFpp: + - SDL_LoadFunction + - SDL_RWFromFile +- gFpi: + - SDL_GameControllerGetBindForAxis + - SDL_GameControllerGetBindForButton +- vFipV: + - SDL_LogCritical + - SDL_LogDebug + - SDL_LogError + - SDL_LogInfo + - SDL_LogVerbose + - SDL_LogWarn +- iFupp: + - SDL_TLSSet +- iFppi: + - SDL_SaveBMP_RW +- IFpIi: + - SDL_RWseek +- pFupp: + - SDL_AddTimer +- pFppi: + - SDL_LoadFile_RW +- pFppp: + - SDL_CreateThread +- vFJppp: + - SDL_GetJoystickGUIDInfo +- iFpupV: + - SDL_snprintf + - SDL_vsnprintf +- uFppuu: + - SDL_RWread + - SDL_RWwrite +- iFpippi: + - SDL_OpenAudioDevice +- pFpippp: + - SDL_LoadWAV_RW +% pFJ -> pFuuuu +% iFEJ -> iFEuuuu +% JFEi -> pFEpi +% JFEp -> pFEpp +% gFEpi -> pFEppi +% vFEJppp -> vFEuuuuppp +wrappedsdl2image: +- pFp: + - IMG_LoadBMP_RW + - IMG_LoadCUR_RW + - IMG_LoadGIF_RW + - IMG_LoadICO_RW + - IMG_LoadJPG_RW + - IMG_LoadLBM_RW + - IMG_LoadPCX_RW + - IMG_LoadPNG_RW + - IMG_LoadPNM_RW + - IMG_LoadTGA_RW + - IMG_LoadTIF_RW + - IMG_LoadWEBP_RW + - IMG_LoadXCF_RW + - IMG_LoadXPM_RW + - IMG_LoadXV_RW +- pFpi: + - IMG_Load_RW +- iFppi: + - IMG_SavePNG_RW +- pFpip: + - IMG_LoadTyped_RW +- pFppi: + - IMG_LoadTexture_RW +- pFppip: + - IMG_LoadTextureTyped_RW +wrappedsdl2mixer: +- vFp: + - Mix_ChannelFinished + - Mix_HookMusicFinished +- vFpp: + - Mix_HookMusic + - Mix_SetPostMix +- iFiw: + - MinorityMix_SetPosition +- iFip: + - Mix_UnregisterEffect +- pFpi: + - Mix_LoadMUS_RW + - Mix_LoadWAV_RW +- pFpii: + - Mix_LoadMUSType_RW +- iFippp: + - Mix_RegisterEffect +wrappedsdl2net: +wrappedsdl2ttf: +- pFpii: + - TTF_OpenFontRW +- pFpiii: + - TTF_OpenFontIndexRW +wrappedsmpeg: +- vFpp: + - SMPEG_getinfo +- pFipi: + - SMPEG_new_descr +- pFppi: + - SMPEG_new + - SMPEG_new_rwops +- vFpppp: + - SMPEG_setdisplay +- pFpipi: + - SMPEG_new_data +wrappedsmpeg2: +- vFpp: + - SMPEG_getinfo +- pFipi: + - SMPEG_new_descr +- pFppi: + - SMPEG_new +- vFpppp: + - SMPEG_setdisplay +- pFpipi: + - SMPEG_new_data +- pFppii: + - SMPEG_new_rwops +wrappedtcmallocminimal: +- iFpL: + - munmap +- pFpLiiii: + - mmap +- pFpLiiiI: + - mmap64 +wrappedturbojpeg: +wrappedudev0: +wrappedudev1: +wrappedutil: +- iFpppp: + - forkpty +wrappedvorbisfile: +- iFp: + - ov_bitrate_instant + - ov_clear + - ov_halfrate_p + - ov_seekable + - ov_streams + - ov_test_open +- IFp: + - ov_pcm_tell + - ov_raw_tell +- dFp: + - ov_time_tell +- iFpi: + - ov_bitrate + - ov_halfrate + - ov_raw_seek + - ov_raw_seek_lap + - ov_serialnumber +- iFpI: + - ov_pcm_seek + - ov_pcm_seek_lap + - ov_pcm_seek_page + - ov_pcm_seek_page_lap +- iFpd: + - ov_time_seek + - ov_time_seek_lap + - ov_time_seek_page + - ov_time_seek_page_lap +- iFpp: + - ov_crosslap + - ov_fopen +- IFpi: + - ov_pcm_total + - ov_raw_total +- dFpi: + - ov_time_total +- pFpi: + - ov_comment + - ov_info +- iFppip: + - ov_read_float +- iFpppi: + - ov_open + - ov_test +- iFppiiiip: + - ov_read +- iFpppipppp: + - ov_open_callbacks +- iFppplpppp: + - ov_open_callbacks +wrappedvulkan: +- vFpp: + - vkDestroyDevice + - vkDestroyInstance + - vkGetPhysicalDeviceMemoryProperties + - vkGetPhysicalDeviceProperties +- pFpp: + - vkGetDeviceProcAddr + - vkGetInstanceProcAddr +- vFpUp: + - vkDestroyBuffer + - vkDestroyBufferView + - vkDestroyCommandPool + - vkDestroyDescriptorPool + - vkDestroyDescriptorSetLayout + - vkDestroyDescriptorUpdateTemplate + - vkDestroyDescriptorUpdateTemplateKHR + - vkDestroyEvent + - vkDestroyFence + - vkDestroyFramebuffer + - vkDestroyImage + - vkDestroyImageView + - vkDestroyPipeline + - vkDestroyPipelineCache + - vkDestroyPipelineLayout + - vkDestroyQueryPool + - vkDestroyRenderPass + - vkDestroySampler + - vkDestroySamplerYcbcrConversionKHR + - vkDestroySemaphore + - vkDestroyShaderModule + - vkDestroySurfaceKHR + - vkDestroySwapchainKHR +- vFppp: + - vkDestroyDebugUtilsMessengerEXT +- iFpUp: + - vkFreeMemory +- iFppp: + - vkGetPhysicalDeviceDisplayPropertiesKHR +- iFPpp: + - vkCreateInstance +- iFpUup: + - vkGetDisplayPlaneCapabilitiesKHR +- iFpppp: + - vkCreateDebugUtilsMessengerEXT + - vkCreateWaylandSurfaceKHR +- iFpPpp: + - vkAllocateMemory + - vkCreateBuffer + - vkCreateBufferView + - vkCreateCommandPool + - vkCreateDescriptorPool + - vkCreateDescriptorSetLayout + - vkCreateDescriptorUpdateTemplate + - vkCreateDescriptorUpdateTemplateKHR + - vkCreateDevice + - vkCreateDisplayPlaneSurfaceKHR + - vkCreateEvent + - vkCreateFence + - vkCreateFramebuffer + - vkCreateImage + - vkCreateImageView + - vkCreatePipelineCache + - vkCreatePipelineLayout + - vkCreateQueryPool + - vkCreateRenderPass + - vkCreateSampler + - vkCreateSamplerYcbcrConversion + - vkCreateSamplerYcbcrConversionKHR + - vkCreateSemaphore + - vkCreateShaderModule + - vkCreateSwapchainKHR + - vkCreateXcbSurfaceKHR + - vkCreateXlibSurfaceKHR +- vFpupup: + - vkUpdateDescriptorSets +- iFpuppp: + - vkCreateSharedSwapchainsKHR +- iFpUPpp: + - vkCreateDisplayModeKHR +- iFpUuppp: + - vkCreateComputePipelines + - vkCreateGraphicsPipelines +- vFpiiiiipp: + - vkGetPhysicalDeviceSparseImageFormatProperties +- vFpiiiupupup: + - vkCmdPipelineBarrier +wrappedwaylandclient: +wrappedxinerama: +wrappedxml2: +- vFp: + - xmlSetExternalEntityLoader +- iFp: + - xmlParseDocument +- pFv: + - xmlGetExternalEntityLoader +- vFpp: + - xmlHashFree +- pFpp: + - xmlHashCopy +- vFppp: + - xmlHashScan + - xmlHashScanFull + - xmlSchemaSetParserStructuredErrors + - xmlSchemaSetValidStructuredErrors +- iFppp: + - xmlHashRemoveEntry + - xmlXPathRegisterFunc +- pFppp: + - xmlNewCharEncodingHandler +- vFpppp: + - xmlSchemaSetParserErrors + - xmlSchemaSetValidErrors +- iFpppp: + - xmlHashRemoveEntry2 + - xmlHashUpdateEntry + - xmlRegisterInputCallbacks +- pFpppi: + - xmlParserInputBufferCreateIO +- pFpppp: + - xmlOutputBufferCreateIO +- iFppppp: + - xmlHashRemoveEntry3 + - xmlHashUpdateEntry2 +- pFppppi: + - xmlSaveToIO +- vFpppppp: + - xmlHashScan3 + - xmlHashScanFull3 +- iFpppppp: + - xmlHashUpdateEntry3 +wrappedxslt: +- vFp: + - xsltSetLoaderFunc +- iFppp: + - xsltRegisterExtModuleFunction diff --git a/src/wrapped/generated/wrappedaluredefs.h b/src/wrapped/generated/wrappedaluredefs.h new file mode 100644 index 0000000000..4f717a04c5 --- /dev/null +++ b/src/wrapped/generated/wrappedaluredefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedalureDEFS_H_ +#define __wrappedalureDEFS_H_ + + +#endif // __wrappedalureDEFS_H_ diff --git a/src/wrapped/generated/wrappedaluretypes.h b/src/wrapped/generated/wrappedaluretypes.h new file mode 100644 index 0000000000..425ef1accd --- /dev/null +++ b/src/wrapped/generated/wrappedaluretypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedalureTYPES_H_ +#define __wrappedalureTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedalureTYPES_H_ diff --git a/src/wrapped/generated/wrappedalureundefs.h b/src/wrapped/generated/wrappedalureundefs.h new file mode 100644 index 0000000000..0677ca1d68 --- /dev/null +++ b/src/wrapped/generated/wrappedalureundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedalureUNDEFS_H_ +#define __wrappedalureUNDEFS_H_ + + +#endif // __wrappedalureUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedalutdefs.h b/src/wrapped/generated/wrappedalutdefs.h new file mode 100644 index 0000000000..f011b03eaa --- /dev/null +++ b/src/wrapped/generated/wrappedalutdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedalutDEFS_H_ +#define __wrappedalutDEFS_H_ + + +#endif // __wrappedalutDEFS_H_ diff --git a/src/wrapped/generated/wrappedaluttypes.h b/src/wrapped/generated/wrappedaluttypes.h new file mode 100644 index 0000000000..49ad54062c --- /dev/null +++ b/src/wrapped/generated/wrappedaluttypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedalutTYPES_H_ +#define __wrappedalutTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedalutTYPES_H_ diff --git a/src/wrapped/generated/wrappedalutundefs.h b/src/wrapped/generated/wrappedalutundefs.h new file mode 100644 index 0000000000..e7b6be4d39 --- /dev/null +++ b/src/wrapped/generated/wrappedalutundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedalutUNDEFS_H_ +#define __wrappedalutUNDEFS_H_ + + +#endif // __wrappedalutUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedappindicatordefs.h b/src/wrapped/generated/wrappedappindicatordefs.h new file mode 100644 index 0000000000..0fefaa6663 --- /dev/null +++ b/src/wrapped/generated/wrappedappindicatordefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedappindicatorDEFS_H_ +#define __wrappedappindicatorDEFS_H_ + + +#endif // __wrappedappindicatorDEFS_H_ diff --git a/src/wrapped/generated/wrappedappindicatortypes.h b/src/wrapped/generated/wrappedappindicatortypes.h new file mode 100644 index 0000000000..51c7830a43 --- /dev/null +++ b/src/wrapped/generated/wrappedappindicatortypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedappindicatorTYPES_H_ +#define __wrappedappindicatorTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedappindicatorTYPES_H_ diff --git a/src/wrapped/generated/wrappedappindicatorundefs.h b/src/wrapped/generated/wrappedappindicatorundefs.h new file mode 100644 index 0000000000..607efdfce3 --- /dev/null +++ b/src/wrapped/generated/wrappedappindicatorundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedappindicatorUNDEFS_H_ +#define __wrappedappindicatorUNDEFS_H_ + + +#endif // __wrappedappindicatorUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedatkbridgedefs.h b/src/wrapped/generated/wrappedatkbridgedefs.h new file mode 100644 index 0000000000..f9b6c69a44 --- /dev/null +++ b/src/wrapped/generated/wrappedatkbridgedefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedatkbridgeDEFS_H_ +#define __wrappedatkbridgeDEFS_H_ + + +#endif // __wrappedatkbridgeDEFS_H_ diff --git a/src/wrapped/generated/wrappedatkbridgetypes.h b/src/wrapped/generated/wrappedatkbridgetypes.h new file mode 100644 index 0000000000..9f89dbb250 --- /dev/null +++ b/src/wrapped/generated/wrappedatkbridgetypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedatkbridgeTYPES_H_ +#define __wrappedatkbridgeTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedatkbridgeTYPES_H_ diff --git a/src/wrapped/generated/wrappedatkbridgeundefs.h b/src/wrapped/generated/wrappedatkbridgeundefs.h new file mode 100644 index 0000000000..7b3a552d7a --- /dev/null +++ b/src/wrapped/generated/wrappedatkbridgeundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedatkbridgeUNDEFS_H_ +#define __wrappedatkbridgeUNDEFS_H_ + + +#endif // __wrappedatkbridgeUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedatkdefs.h b/src/wrapped/generated/wrappedatkdefs.h new file mode 100644 index 0000000000..1edf5f0179 --- /dev/null +++ b/src/wrapped/generated/wrappedatkdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedatkDEFS_H_ +#define __wrappedatkDEFS_H_ + + +#endif // __wrappedatkDEFS_H_ diff --git a/src/wrapped/generated/wrappedatktypes.h b/src/wrapped/generated/wrappedatktypes.h new file mode 100644 index 0000000000..8132f74398 --- /dev/null +++ b/src/wrapped/generated/wrappedatktypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedatkTYPES_H_ +#define __wrappedatkTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedatkTYPES_H_ diff --git a/src/wrapped/generated/wrappedatkundefs.h b/src/wrapped/generated/wrappedatkundefs.h new file mode 100644 index 0000000000..de41349f54 --- /dev/null +++ b/src/wrapped/generated/wrappedatkundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedatkUNDEFS_H_ +#define __wrappedatkUNDEFS_H_ + + +#endif // __wrappedatkUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedbz2defs.h b/src/wrapped/generated/wrappedbz2defs.h new file mode 100644 index 0000000000..761873002b --- /dev/null +++ b/src/wrapped/generated/wrappedbz2defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedbz2DEFS_H_ +#define __wrappedbz2DEFS_H_ + + +#endif // __wrappedbz2DEFS_H_ diff --git a/src/wrapped/generated/wrappedbz2types.h b/src/wrapped/generated/wrappedbz2types.h index d2dcb7771f..070d8f7876 100644 --- a/src/wrapped/generated/wrappedbz2types.h +++ b/src/wrapped/generated/wrappedbz2types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedbz2TYPES_H_ #define __wrappedbz2TYPES_H_ diff --git a/src/wrapped/generated/wrappedbz2undefs.h b/src/wrapped/generated/wrappedbz2undefs.h new file mode 100644 index 0000000000..2b93bcaeaf --- /dev/null +++ b/src/wrapped/generated/wrappedbz2undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedbz2UNDEFS_H_ +#define __wrappedbz2UNDEFS_H_ + + +#endif // __wrappedbz2UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedcairodefs.h b/src/wrapped/generated/wrappedcairodefs.h new file mode 100644 index 0000000000..adb0ba0d1c --- /dev/null +++ b/src/wrapped/generated/wrappedcairodefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedcairoDEFS_H_ +#define __wrappedcairoDEFS_H_ + + +#endif // __wrappedcairoDEFS_H_ diff --git a/src/wrapped/generated/wrappedcairotypes.h b/src/wrapped/generated/wrappedcairotypes.h new file mode 100644 index 0000000000..60fcbc0f7d --- /dev/null +++ b/src/wrapped/generated/wrappedcairotypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedcairoTYPES_H_ +#define __wrappedcairoTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedcairoTYPES_H_ diff --git a/src/wrapped/generated/wrappedcairoundefs.h b/src/wrapped/generated/wrappedcairoundefs.h new file mode 100644 index 0000000000..6cde66c698 --- /dev/null +++ b/src/wrapped/generated/wrappedcairoundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedcairoUNDEFS_H_ +#define __wrappedcairoUNDEFS_H_ + + +#endif // __wrappedcairoUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedcrashhandlerdefs.h b/src/wrapped/generated/wrappedcrashhandlerdefs.h new file mode 100644 index 0000000000..7fef684ef1 --- /dev/null +++ b/src/wrapped/generated/wrappedcrashhandlerdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedcrashhandlerDEFS_H_ +#define __wrappedcrashhandlerDEFS_H_ + + +#endif // __wrappedcrashhandlerDEFS_H_ diff --git a/src/wrapped/generated/wrappedcrashhandlertypes.h b/src/wrapped/generated/wrappedcrashhandlertypes.h new file mode 100644 index 0000000000..ad2a431074 --- /dev/null +++ b/src/wrapped/generated/wrappedcrashhandlertypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedcrashhandlerTYPES_H_ +#define __wrappedcrashhandlerTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedcrashhandlerTYPES_H_ diff --git a/src/wrapped/generated/wrappedcrashhandlerundefs.h b/src/wrapped/generated/wrappedcrashhandlerundefs.h new file mode 100644 index 0000000000..6791078e9a --- /dev/null +++ b/src/wrapped/generated/wrappedcrashhandlerundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedcrashhandlerUNDEFS_H_ +#define __wrappedcrashhandlerUNDEFS_H_ + + +#endif // __wrappedcrashhandlerUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedcryptodefs.h b/src/wrapped/generated/wrappedcryptodefs.h new file mode 100644 index 0000000000..b805b316df --- /dev/null +++ b/src/wrapped/generated/wrappedcryptodefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedcryptoDEFS_H_ +#define __wrappedcryptoDEFS_H_ + + +#endif // __wrappedcryptoDEFS_H_ diff --git a/src/wrapped/generated/wrappedcryptotypes.h b/src/wrapped/generated/wrappedcryptotypes.h index 88d136dd03..f8a9a3c08e 100644 --- a/src/wrapped/generated/wrappedcryptotypes.h +++ b/src/wrapped/generated/wrappedcryptotypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedcryptoTYPES_H_ #define __wrappedcryptoTYPES_H_ @@ -11,6 +11,7 @@ #define ADDED_FUNCTIONS() #endif +typedef void (*vFv_t)(void); typedef void (*vFp_t)(void*); typedef void* (*pFp_t)(void*); typedef void (*vFpp_t)(void*, void*); @@ -20,6 +21,10 @@ typedef int32_t (*iFpplppi_t)(void*, void*, intptr_t, void*, void*, int32_t); typedef int32_t (*iFppppipp_t)(void*, void*, void*, void*, int32_t, void*, void*); #define SUPER() ADDED_FUNCTIONS() \ + GO(OPENSSL_add_all_algorithms_conf, vFv_t) \ + GO(OPENSSL_add_all_algorithms_noconf, vFv_t) \ + GO(OpenSSL_add_all_ciphers, vFv_t) \ + GO(OpenSSL_add_all_digests, vFv_t) \ GO(CRYPTO_set_id_callback, vFp_t) \ GO(CRYPTO_set_locking_callback, vFp_t) \ GO(sk_new, pFp_t) \ diff --git a/src/wrapped/generated/wrappedcryptoundefs.h b/src/wrapped/generated/wrappedcryptoundefs.h new file mode 100644 index 0000000000..989e3e842b --- /dev/null +++ b/src/wrapped/generated/wrappedcryptoundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedcryptoUNDEFS_H_ +#define __wrappedcryptoUNDEFS_H_ + + +#endif // __wrappedcryptoUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedcurldefs.h b/src/wrapped/generated/wrappedcurldefs.h new file mode 100644 index 0000000000..5bcf6652a4 --- /dev/null +++ b/src/wrapped/generated/wrappedcurldefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedcurlDEFS_H_ +#define __wrappedcurlDEFS_H_ + + +#endif // __wrappedcurlDEFS_H_ diff --git a/src/wrapped/generated/wrappedcurltypes.h b/src/wrapped/generated/wrappedcurltypes.h index 24064db257..8302c1b41b 100644 --- a/src/wrapped/generated/wrappedcurltypes.h +++ b/src/wrapped/generated/wrappedcurltypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedcurlTYPES_H_ #define __wrappedcurlTYPES_H_ diff --git a/src/wrapped/generated/wrappedcurlundefs.h b/src/wrapped/generated/wrappedcurlundefs.h new file mode 100644 index 0000000000..16cb3f8ff0 --- /dev/null +++ b/src/wrapped/generated/wrappedcurlundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedcurlUNDEFS_H_ +#define __wrappedcurlUNDEFS_H_ + + +#endif // __wrappedcurlUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedd3dadapter9defs.h b/src/wrapped/generated/wrappedd3dadapter9defs.h new file mode 100644 index 0000000000..61c4eeb850 --- /dev/null +++ b/src/wrapped/generated/wrappedd3dadapter9defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedd3dadapter9DEFS_H_ +#define __wrappedd3dadapter9DEFS_H_ + + +#endif // __wrappedd3dadapter9DEFS_H_ diff --git a/src/wrapped/generated/wrappedd3dadapter9types.h b/src/wrapped/generated/wrappedd3dadapter9types.h index bf2e7ee9e0..21dea0a58a 100644 --- a/src/wrapped/generated/wrappedd3dadapter9types.h +++ b/src/wrapped/generated/wrappedd3dadapter9types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedd3dadapter9TYPES_H_ #define __wrappedd3dadapter9TYPES_H_ diff --git a/src/wrapped/generated/wrappedd3dadapter9undefs.h b/src/wrapped/generated/wrappedd3dadapter9undefs.h new file mode 100644 index 0000000000..7e307093c7 --- /dev/null +++ b/src/wrapped/generated/wrappedd3dadapter9undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedd3dadapter9UNDEFS_H_ +#define __wrappedd3dadapter9UNDEFS_H_ + + +#endif // __wrappedd3dadapter9UNDEFS_H_ diff --git a/src/wrapped/generated/wrappeddbusdefs.h b/src/wrapped/generated/wrappeddbusdefs.h new file mode 100644 index 0000000000..2e818d6156 --- /dev/null +++ b/src/wrapped/generated/wrappeddbusdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappeddbusDEFS_H_ +#define __wrappeddbusDEFS_H_ + + +#endif // __wrappeddbusDEFS_H_ diff --git a/src/wrapped/generated/wrappeddbusglib1defs.h b/src/wrapped/generated/wrappeddbusglib1defs.h new file mode 100644 index 0000000000..281d897e58 --- /dev/null +++ b/src/wrapped/generated/wrappeddbusglib1defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappeddbusglib1DEFS_H_ +#define __wrappeddbusglib1DEFS_H_ + + +#endif // __wrappeddbusglib1DEFS_H_ diff --git a/src/wrapped/generated/wrappeddbusglib1types.h b/src/wrapped/generated/wrappeddbusglib1types.h index b0e2a397a7..29b5be66be 100644 --- a/src/wrapped/generated/wrappeddbusglib1types.h +++ b/src/wrapped/generated/wrappeddbusglib1types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappeddbusglib1TYPES_H_ #define __wrappeddbusglib1TYPES_H_ @@ -14,8 +14,8 @@ typedef void (*vFppp_t)(void*, void*, void*); typedef void (*vFpppp_t)(void*, void*, void*, void*); typedef void (*vFppppp_t)(void*, void*, void*, void*, void*); -typedef void* (*pFpppppiV_t)(void*, void*, void*, void*, void*, int32_t, void*); -typedef void* (*pFpppppiiV_t)(void*, void*, void*, void*, void*, int32_t, int32_t, void*); +typedef void* (*pFpppppiV_t)(void*, void*, void*, void*, void*, int32_t, ...); +typedef void* (*pFpppppiiV_t)(void*, void*, void*, void*, void*, int32_t, int32_t, ...); #define SUPER() ADDED_FUNCTIONS() \ GO(dbus_g_type_collection_value_iterate, vFppp_t) \ diff --git a/src/wrapped/generated/wrappeddbusglib1undefs.h b/src/wrapped/generated/wrappeddbusglib1undefs.h new file mode 100644 index 0000000000..cb37d75bf9 --- /dev/null +++ b/src/wrapped/generated/wrappeddbusglib1undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappeddbusglib1UNDEFS_H_ +#define __wrappeddbusglib1UNDEFS_H_ + + +#endif // __wrappeddbusglib1UNDEFS_H_ diff --git a/src/wrapped/generated/wrappeddbusmenuglibdefs.h b/src/wrapped/generated/wrappeddbusmenuglibdefs.h new file mode 100644 index 0000000000..6140596d24 --- /dev/null +++ b/src/wrapped/generated/wrappeddbusmenuglibdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappeddbusmenuglibDEFS_H_ +#define __wrappeddbusmenuglibDEFS_H_ + + +#endif // __wrappeddbusmenuglibDEFS_H_ diff --git a/src/wrapped/generated/wrappeddbusmenuglibtypes.h b/src/wrapped/generated/wrappeddbusmenuglibtypes.h new file mode 100644 index 0000000000..78cea70397 --- /dev/null +++ b/src/wrapped/generated/wrappeddbusmenuglibtypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappeddbusmenuglibTYPES_H_ +#define __wrappeddbusmenuglibTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappeddbusmenuglibTYPES_H_ diff --git a/src/wrapped/generated/wrappeddbusmenuglibundefs.h b/src/wrapped/generated/wrappeddbusmenuglibundefs.h new file mode 100644 index 0000000000..de88a762a5 --- /dev/null +++ b/src/wrapped/generated/wrappeddbusmenuglibundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappeddbusmenuglibUNDEFS_H_ +#define __wrappeddbusmenuglibUNDEFS_H_ + + +#endif // __wrappeddbusmenuglibUNDEFS_H_ diff --git a/src/wrapped/generated/wrappeddbusmenugtkdefs.h b/src/wrapped/generated/wrappeddbusmenugtkdefs.h new file mode 100644 index 0000000000..2f28bd2f5d --- /dev/null +++ b/src/wrapped/generated/wrappeddbusmenugtkdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappeddbusmenugtkDEFS_H_ +#define __wrappeddbusmenugtkDEFS_H_ + + +#endif // __wrappeddbusmenugtkDEFS_H_ diff --git a/src/wrapped/generated/wrappeddbusmenugtktypes.h b/src/wrapped/generated/wrappeddbusmenugtktypes.h new file mode 100644 index 0000000000..5dabfd0bf9 --- /dev/null +++ b/src/wrapped/generated/wrappeddbusmenugtktypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappeddbusmenugtkTYPES_H_ +#define __wrappeddbusmenugtkTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappeddbusmenugtkTYPES_H_ diff --git a/src/wrapped/generated/wrappeddbusmenugtkundefs.h b/src/wrapped/generated/wrappeddbusmenugtkundefs.h new file mode 100644 index 0000000000..e2bd8114a3 --- /dev/null +++ b/src/wrapped/generated/wrappeddbusmenugtkundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappeddbusmenugtkUNDEFS_H_ +#define __wrappeddbusmenugtkUNDEFS_H_ + + +#endif // __wrappeddbusmenugtkUNDEFS_H_ diff --git a/src/wrapped/generated/wrappeddbustypes.h b/src/wrapped/generated/wrappeddbustypes.h index 46df39c13c..ee51693239 100644 --- a/src/wrapped/generated/wrappeddbustypes.h +++ b/src/wrapped/generated/wrappeddbustypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappeddbusTYPES_H_ #define __wrappeddbusTYPES_H_ @@ -15,7 +15,7 @@ typedef void (*vFppp_t)(void*, void*, void*); typedef void (*vFpppp_t)(void*, void*, void*, void*); typedef int32_t (*iFpipp_t)(void*, int32_t, void*, void*); typedef int32_t (*iFppip_t)(void*, void*, int32_t, void*); -typedef int32_t (*iFppiV_t)(void*, void*, int32_t, void*); +typedef int32_t (*iFppiV_t)(void*, void*, int32_t, ...); typedef int32_t (*iFpppp_t)(void*, void*, void*, void*); typedef int32_t (*iFppppp_t)(void*, void*, void*, void*, void*); typedef int32_t (*iFpppppp_t)(void*, void*, void*, void*, void*, void*); diff --git a/src/wrapped/generated/wrappeddbusundefs.h b/src/wrapped/generated/wrappeddbusundefs.h new file mode 100644 index 0000000000..cc7a9365f9 --- /dev/null +++ b/src/wrapped/generated/wrappeddbusundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappeddbusUNDEFS_H_ +#define __wrappeddbusUNDEFS_H_ + + +#endif // __wrappeddbusUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedexpatdefs.h b/src/wrapped/generated/wrappedexpatdefs.h new file mode 100644 index 0000000000..906deb50b0 --- /dev/null +++ b/src/wrapped/generated/wrappedexpatdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedexpatDEFS_H_ +#define __wrappedexpatDEFS_H_ + + +#endif // __wrappedexpatDEFS_H_ diff --git a/src/wrapped/generated/wrappedexpattypes.h b/src/wrapped/generated/wrappedexpattypes.h index c451c6c81f..eba60913da 100644 --- a/src/wrapped/generated/wrappedexpattypes.h +++ b/src/wrapped/generated/wrappedexpattypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedexpatTYPES_H_ #define __wrappedexpatTYPES_H_ diff --git a/src/wrapped/generated/wrappedexpatundefs.h b/src/wrapped/generated/wrappedexpatundefs.h new file mode 100644 index 0000000000..315e23a5b7 --- /dev/null +++ b/src/wrapped/generated/wrappedexpatundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedexpatUNDEFS_H_ +#define __wrappedexpatUNDEFS_H_ + + +#endif // __wrappedexpatUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedfontconfigdefs.h b/src/wrapped/generated/wrappedfontconfigdefs.h new file mode 100644 index 0000000000..3646469f52 --- /dev/null +++ b/src/wrapped/generated/wrappedfontconfigdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedfontconfigDEFS_H_ +#define __wrappedfontconfigDEFS_H_ + + +#endif // __wrappedfontconfigDEFS_H_ diff --git a/src/wrapped/generated/wrappedfontconfigtypes.h b/src/wrapped/generated/wrappedfontconfigtypes.h index 45f5fd6466..599dfb1f7d 100644 --- a/src/wrapped/generated/wrappedfontconfigtypes.h +++ b/src/wrapped/generated/wrappedfontconfigtypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedfontconfigTYPES_H_ #define __wrappedfontconfigTYPES_H_ diff --git a/src/wrapped/generated/wrappedfontconfigundefs.h b/src/wrapped/generated/wrappedfontconfigundefs.h new file mode 100644 index 0000000000..a5a241b13c --- /dev/null +++ b/src/wrapped/generated/wrappedfontconfigundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedfontconfigUNDEFS_H_ +#define __wrappedfontconfigUNDEFS_H_ + + +#endif // __wrappedfontconfigUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedfreetypedefs.h b/src/wrapped/generated/wrappedfreetypedefs.h new file mode 100644 index 0000000000..cf9e93a342 --- /dev/null +++ b/src/wrapped/generated/wrappedfreetypedefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedfreetypeDEFS_H_ +#define __wrappedfreetypeDEFS_H_ + + +#endif // __wrappedfreetypeDEFS_H_ diff --git a/src/wrapped/generated/wrappedfreetypetypes.h b/src/wrapped/generated/wrappedfreetypetypes.h index dd30e1b51d..86834c3289 100644 --- a/src/wrapped/generated/wrappedfreetypetypes.h +++ b/src/wrapped/generated/wrappedfreetypetypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedfreetypeTYPES_H_ #define __wrappedfreetypeTYPES_H_ diff --git a/src/wrapped/generated/wrappedfreetypeundefs.h b/src/wrapped/generated/wrappedfreetypeundefs.h new file mode 100644 index 0000000000..519f211115 --- /dev/null +++ b/src/wrapped/generated/wrappedfreetypeundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedfreetypeUNDEFS_H_ +#define __wrappedfreetypeUNDEFS_H_ + + +#endif // __wrappedfreetypeUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedgdk3defs.h b/src/wrapped/generated/wrappedgdk3defs.h new file mode 100644 index 0000000000..7734b30c80 --- /dev/null +++ b/src/wrapped/generated/wrappedgdk3defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgdk3DEFS_H_ +#define __wrappedgdk3DEFS_H_ + + +#endif // __wrappedgdk3DEFS_H_ diff --git a/src/wrapped/generated/wrappedgdk3types.h b/src/wrapped/generated/wrappedgdk3types.h index 1173e24a86..52b42de825 100644 --- a/src/wrapped/generated/wrappedgdk3types.h +++ b/src/wrapped/generated/wrappedgdk3types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedgdk3TYPES_H_ #define __wrappedgdk3TYPES_H_ diff --git a/src/wrapped/generated/wrappedgdk3undefs.h b/src/wrapped/generated/wrappedgdk3undefs.h new file mode 100644 index 0000000000..67cd6395b1 --- /dev/null +++ b/src/wrapped/generated/wrappedgdk3undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgdk3UNDEFS_H_ +#define __wrappedgdk3UNDEFS_H_ + + +#endif // __wrappedgdk3UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedgdkpixbuf2defs.h b/src/wrapped/generated/wrappedgdkpixbuf2defs.h new file mode 100644 index 0000000000..34407af5e7 --- /dev/null +++ b/src/wrapped/generated/wrappedgdkpixbuf2defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgdkpixbuf2DEFS_H_ +#define __wrappedgdkpixbuf2DEFS_H_ + + +#endif // __wrappedgdkpixbuf2DEFS_H_ diff --git a/src/wrapped/generated/wrappedgdkpixbuf2types.h b/src/wrapped/generated/wrappedgdkpixbuf2types.h index 3acc00fa4d..957c3253c4 100644 --- a/src/wrapped/generated/wrappedgdkpixbuf2types.h +++ b/src/wrapped/generated/wrappedgdkpixbuf2types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedgdkpixbuf2TYPES_H_ #define __wrappedgdkpixbuf2TYPES_H_ diff --git a/src/wrapped/generated/wrappedgdkpixbuf2undefs.h b/src/wrapped/generated/wrappedgdkpixbuf2undefs.h new file mode 100644 index 0000000000..3fb283b0b4 --- /dev/null +++ b/src/wrapped/generated/wrappedgdkpixbuf2undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgdkpixbuf2UNDEFS_H_ +#define __wrappedgdkpixbuf2UNDEFS_H_ + + +#endif // __wrappedgdkpixbuf2UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedgdkx112defs.h b/src/wrapped/generated/wrappedgdkx112defs.h new file mode 100644 index 0000000000..a3d6b11874 --- /dev/null +++ b/src/wrapped/generated/wrappedgdkx112defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgdkx112DEFS_H_ +#define __wrappedgdkx112DEFS_H_ + + +#endif // __wrappedgdkx112DEFS_H_ diff --git a/src/wrapped/generated/wrappedgdkx112types.h b/src/wrapped/generated/wrappedgdkx112types.h index ff97df7110..a0ae0245b4 100644 --- a/src/wrapped/generated/wrappedgdkx112types.h +++ b/src/wrapped/generated/wrappedgdkx112types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedgdkx112TYPES_H_ #define __wrappedgdkx112TYPES_H_ diff --git a/src/wrapped/generated/wrappedgdkx112undefs.h b/src/wrapped/generated/wrappedgdkx112undefs.h new file mode 100644 index 0000000000..df29f4b130 --- /dev/null +++ b/src/wrapped/generated/wrappedgdkx112undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgdkx112UNDEFS_H_ +#define __wrappedgdkx112UNDEFS_H_ + + +#endif // __wrappedgdkx112UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedgio2defs.h b/src/wrapped/generated/wrappedgio2defs.h new file mode 100644 index 0000000000..31219a635f --- /dev/null +++ b/src/wrapped/generated/wrappedgio2defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgio2DEFS_H_ +#define __wrappedgio2DEFS_H_ + + +#endif // __wrappedgio2DEFS_H_ diff --git a/src/wrapped/generated/wrappedgio2types.h b/src/wrapped/generated/wrappedgio2types.h index 0ecf86dc03..c9fc50d856 100644 --- a/src/wrapped/generated/wrappedgio2types.h +++ b/src/wrapped/generated/wrappedgio2types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedgio2TYPES_H_ #define __wrappedgio2TYPES_H_ @@ -20,15 +20,15 @@ typedef uintptr_t (*LFpppp_t)(void*, void*, void*, void*); typedef void* (*pFpppp_t)(void*, void*, void*, void*); typedef void (*vFpippp_t)(void*, int32_t, void*, void*, void*); typedef void (*vFpipppp_t)(void*, int32_t, void*, void*, void*, void*); -typedef void (*vFiippppV_t)(int32_t, int32_t, void*, void*, void*, void*, void*); +typedef void (*vFiippppV_t)(int32_t, int32_t, void*, void*, void*, void*, ...); typedef void (*vFiupippp_t)(int32_t, uint32_t, void*, int32_t, void*, void*, void*); typedef void (*vFippippp_t)(int32_t, void*, void*, int32_t, void*, void*, void*); typedef void (*vFppipppp_t)(void*, void*, int32_t, void*, void*, void*, void*); -typedef void (*vFpppuipV_t)(void*, void*, void*, uint32_t, int32_t, void*, void*); +typedef void (*vFpppuipV_t)(void*, void*, void*, uint32_t, int32_t, void*, ...); typedef uint32_t (*uFipipppp_t)(int32_t, void*, int32_t, void*, void*, void*, void*); typedef uint32_t (*uFppipppp_t)(void*, void*, int32_t, void*, void*, void*, void*); typedef uint32_t (*uFppppppp_t)(void*, void*, void*, void*, void*, void*, void*); -typedef void* (*pFpppuipV_t)(void*, void*, void*, uint32_t, int32_t, void*, void*); +typedef void* (*pFpppuipV_t)(void*, void*, void*, uint32_t, int32_t, void*, ...); typedef void (*vFppiipppp_t)(void*, void*, int32_t, int32_t, void*, void*, void*, void*); typedef void (*vFpppiippp_t)(void*, void*, void*, int32_t, int32_t, void*, void*, void*); typedef uint32_t (*uFipippppp_t)(int32_t, void*, int32_t, void*, void*, void*, void*, void*); diff --git a/src/wrapped/generated/wrappedgio2undefs.h b/src/wrapped/generated/wrappedgio2undefs.h new file mode 100644 index 0000000000..63eab6b17d --- /dev/null +++ b/src/wrapped/generated/wrappedgio2undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgio2UNDEFS_H_ +#define __wrappedgio2UNDEFS_H_ + + +#endif // __wrappedgio2UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedglib2defs.h b/src/wrapped/generated/wrappedglib2defs.h new file mode 100644 index 0000000000..dbb6b0a022 --- /dev/null +++ b/src/wrapped/generated/wrappedglib2defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedglib2DEFS_H_ +#define __wrappedglib2DEFS_H_ + + +#endif // __wrappedglib2DEFS_H_ diff --git a/src/wrapped/generated/wrappedglib2types.h b/src/wrapped/generated/wrappedglib2types.h index 518b5aeb31..06c12f4fb7 100644 --- a/src/wrapped/generated/wrappedglib2types.h +++ b/src/wrapped/generated/wrappedglib2types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedglib2TYPES_H_ #define __wrappedglib2TYPES_H_ @@ -11,37 +11,33 @@ #define ADDED_FUNCTIONS() #endif -typedef void (*vFp_t)(void*); typedef void* (*pFp_t)(void*); typedef void (*vFpp_t)(void*, void*); -typedef void (*vFpV_t)(void*, void*); +typedef void (*vFpV_t)(void*, ...); typedef int32_t (*iFpp_t)(void*, void*); -typedef int32_t (*iFpV_t)(void*, void*); typedef uint32_t (*uFpp_t)(void*, void*); typedef void* (*pFup_t)(uint32_t, void*); typedef void* (*pFpu_t)(void*, uint32_t); typedef void* (*pFpp_t)(void*, void*); -typedef void* (*pFpV_t)(void*, void*); +typedef void* (*pFpV_t)(void*, ...); typedef void (*vFppp_t)(void*, void*, void*); -typedef void (*vFppV_t)(void*, void*, void*); +typedef void (*vFppV_t)(void*, void*, ...); typedef int32_t (*iFppp_t)(void*, void*, void*); -typedef int32_t (*iFppV_t)(void*, void*, void*); typedef uint32_t (*uFipp_t)(int32_t, void*, void*); typedef uint32_t (*uFupp_t)(uint32_t, void*, void*); typedef uint32_t (*uFppp_t)(void*, void*, void*); typedef void* (*pFppp_t)(void*, void*, void*); -typedef void* (*pFppV_t)(void*, void*, void*); +typedef void* (*pFppV_t)(void*, void*, ...); typedef void (*vFpupp_t)(void*, uint32_t, void*, void*); typedef void (*vFpppp_t)(void*, void*, void*, void*); typedef int32_t (*iFpLpp_t)(void*, uintptr_t, void*, void*); -typedef int32_t (*iFpLpV_t)(void*, uintptr_t, void*, void*); typedef uint32_t (*uFippp_t)(int32_t, void*, void*, void*); typedef uint32_t (*uFpipp_t)(void*, int32_t, void*, void*); typedef void* (*pFpupp_t)(void*, uint32_t, void*, void*); typedef void* (*pFppip_t)(void*, void*, int32_t, void*); typedef void* (*pFpppp_t)(void*, void*, void*, void*); typedef void (*vFpiLpp_t)(void*, int32_t, uintptr_t, void*, void*); -typedef void (*vFppipV_t)(void*, void*, int32_t, void*, void*); +typedef void (*vFppipV_t)(void*, void*, int32_t, void*, ...); typedef uint32_t (*uFiippp_t)(int32_t, int32_t, void*, void*, void*); typedef uint32_t (*uFiuppp_t)(int32_t, uint32_t, void*, void*, void*); typedef int32_t (*iFpupppp_t)(void*, uint32_t, void*, void*, void*, void*); @@ -53,7 +49,6 @@ typedef int32_t (*iFpppipppppp_t)(void*, void*, void*, int32_t, void*, void*, vo typedef int32_t (*iFpppippppppp_t)(void*, void*, void*, int32_t, void*, void*, void*, void*, void*, void*, void*); #define SUPER() ADDED_FUNCTIONS() \ - GO(g_atexit, vFp_t) \ GO(g_completion_new, pFp_t) \ GO(g_main_context_get_poll_func, pFp_t) \ GO(g_private_new, pFp_t) \ @@ -73,7 +68,6 @@ typedef int32_t (*iFpppippppppp_t)(void*, void*, void*, int32_t, void*, void*, v GO(g_printerr, vFpV_t) \ GO(g_source_remove_by_funcs_user_data, iFpp_t) \ GO(g_vprintf, iFpp_t) \ - GO(g_printf, iFpV_t) \ GO(g_idle_add, uFpp_t) \ GO(g_printf_string_upper_bound, uFpp_t) \ GO(g_ptr_array_new_full, pFup_t) \ @@ -87,9 +81,7 @@ typedef int32_t (*iFpppippppppp_t)(void*, void*, void*, int32_t, void*, void*, v GO(g_variant_new_parsed_va, pFpp_t) \ GO(g_build_filename, pFpV_t) \ GO(g_markup_printf_escaped, pFpV_t) \ - GO(g_strdup_printf, pFpV_t) \ GO(g_variant_new, pFpV_t) \ - GO(g_variant_new_parsed, pFpV_t) \ GO(g_array_sort_with_data, vFppp_t) \ GO(g_hash_table_foreach, vFppp_t) \ GO(g_ptr_array_foreach, vFppp_t) \ @@ -99,8 +91,6 @@ typedef int32_t (*iFpppippppppp_t)(void*, void*, void*, int32_t, void*, void*, v GO(g_vasprintf, iFppp_t) \ GO(g_vfprintf, iFppp_t) \ GO(g_vsprintf, iFppp_t) \ - GO(g_fprintf, iFppV_t) \ - GO(g_sprintf, iFppV_t) \ GO(g_child_watch_add, uFipp_t) \ GO(g_timeout_add, uFupp_t) \ GO(g_timeout_add_seconds, uFupp_t) \ @@ -119,7 +109,6 @@ typedef int32_t (*iFpppippppppp_t)(void*, void*, void*, int32_t, void*, void*, v GO(g_datalist_id_set_data_full, vFpupp_t) \ GO(g_source_set_callback, vFpppp_t) \ GO(g_vsnprintf, iFpLpp_t) \ - GO(g_snprintf, iFpLpV_t) \ GO(g_idle_add_full, uFippp_t) \ GO(g_io_add_watch, uFpipp_t) \ GO(g_log_set_handler, uFpipp_t) \ diff --git a/src/wrapped/generated/wrappedglib2undefs.h b/src/wrapped/generated/wrappedglib2undefs.h new file mode 100644 index 0000000000..d2fe4f1e62 --- /dev/null +++ b/src/wrapped/generated/wrappedglib2undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedglib2UNDEFS_H_ +#define __wrappedglib2UNDEFS_H_ + + +#endif // __wrappedglib2UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedgmodule2defs.h b/src/wrapped/generated/wrappedgmodule2defs.h new file mode 100644 index 0000000000..b77cf14ba9 --- /dev/null +++ b/src/wrapped/generated/wrappedgmodule2defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgmodule2DEFS_H_ +#define __wrappedgmodule2DEFS_H_ + + +#endif // __wrappedgmodule2DEFS_H_ diff --git a/src/wrapped/generated/wrappedgmodule2types.h b/src/wrapped/generated/wrappedgmodule2types.h new file mode 100644 index 0000000000..1e8cdb88db --- /dev/null +++ b/src/wrapped/generated/wrappedgmodule2types.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgmodule2TYPES_H_ +#define __wrappedgmodule2TYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedgmodule2TYPES_H_ diff --git a/src/wrapped/generated/wrappedgmodule2undefs.h b/src/wrapped/generated/wrappedgmodule2undefs.h new file mode 100644 index 0000000000..b31c3ad8b0 --- /dev/null +++ b/src/wrapped/generated/wrappedgmodule2undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgmodule2UNDEFS_H_ +#define __wrappedgmodule2UNDEFS_H_ + + +#endif // __wrappedgmodule2UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedgnutlsdefs.h b/src/wrapped/generated/wrappedgnutlsdefs.h new file mode 100644 index 0000000000..ad35d83fe1 --- /dev/null +++ b/src/wrapped/generated/wrappedgnutlsdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgnutlsDEFS_H_ +#define __wrappedgnutlsDEFS_H_ + + +#endif // __wrappedgnutlsDEFS_H_ diff --git a/src/wrapped/generated/wrappedgnutlstypes.h b/src/wrapped/generated/wrappedgnutlstypes.h index 2c9659a51d..ffc4678b32 100644 --- a/src/wrapped/generated/wrappedgnutlstypes.h +++ b/src/wrapped/generated/wrappedgnutlstypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedgnutlsTYPES_H_ #define __wrappedgnutlsTYPES_H_ diff --git a/src/wrapped/generated/wrappedgnutlsundefs.h b/src/wrapped/generated/wrappedgnutlsundefs.h new file mode 100644 index 0000000000..62614263ae --- /dev/null +++ b/src/wrapped/generated/wrappedgnutlsundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgnutlsUNDEFS_H_ +#define __wrappedgnutlsUNDEFS_H_ + + +#endif // __wrappedgnutlsUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedgobject2defs.h b/src/wrapped/generated/wrappedgobject2defs.h new file mode 100644 index 0000000000..e1066493f3 --- /dev/null +++ b/src/wrapped/generated/wrappedgobject2defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgobject2DEFS_H_ +#define __wrappedgobject2DEFS_H_ + + +#endif // __wrappedgobject2DEFS_H_ diff --git a/src/wrapped/generated/wrappedgobject2types.h b/src/wrapped/generated/wrappedgobject2types.h index e3382a7a80..b22627d98d 100644 --- a/src/wrapped/generated/wrappedgobject2types.h +++ b/src/wrapped/generated/wrappedgobject2types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedgobject2TYPES_H_ #define __wrappedgobject2TYPES_H_ @@ -13,12 +13,13 @@ typedef void* (*pFp_t)(void*); typedef int32_t (*iFpp_t)(void*, void*); +typedef void* (*pFpi_t)(void*, int32_t); typedef void* (*pFpp_t)(void*, void*); typedef void (*vFiip_t)(int32_t, int32_t, void*); typedef int32_t (*iFppp_t)(void*, void*, void*); -typedef void* (*pFipV_t)(int32_t, void*, void*); +typedef void* (*pFipV_t)(int32_t, void*, ...); typedef void* (*pFppp_t)(void*, void*, void*); -typedef void* (*pFppV_t)(void*, void*, void*); +typedef void* (*pFppV_t)(void*, void*, ...); typedef void (*vFpupp_t)(void*, uint32_t, void*, void*); typedef void (*vFpppp_t)(void*, void*, void*, void*); typedef int32_t (*iFippi_t)(int32_t, void*, void*, int32_t); @@ -28,12 +29,15 @@ typedef uintptr_t (*LFpppppu_t)(void*, void*, void*, void*, void*, uint32_t); typedef int32_t (*iFipupupi_t)(int32_t, void*, uint32_t, void*, uint32_t, void*, int32_t); typedef uint32_t (*uFpiupppp_t)(void*, int32_t, uint32_t, void*, void*, void*, void*); typedef uintptr_t (*LFpiupppp_t)(void*, int32_t, uint32_t, void*, void*, void*, void*); -typedef uint32_t (*uFpiiupppiuV_t)(void*, int32_t, int32_t, uint32_t, void*, void*, void*, int32_t, uint32_t, void*); +typedef uint32_t (*uFpiiupppiuV_t)(void*, int32_t, int32_t, uint32_t, void*, void*, void*, int32_t, uint32_t, ...); typedef uint32_t (*uFpiippppiup_t)(void*, int32_t, int32_t, void*, void*, void*, void*, int32_t, uint32_t, void*); #define SUPER() ADDED_FUNCTIONS() \ + GO(g_param_spec_get_default_value, pFp_t) \ GO(g_type_class_peek_parent, pFp_t) \ + GO(g_value_reset, pFp_t) \ GO(g_param_type_register_static, iFpp_t) \ + GO(g_value_init, pFpi_t) \ GO(g_value_array_sort, pFpp_t) \ GO(g_type_add_interface_static, vFiip_t) \ GO(g_value_register_transform_func, vFiip_t) \ diff --git a/src/wrapped/generated/wrappedgobject2undefs.h b/src/wrapped/generated/wrappedgobject2undefs.h new file mode 100644 index 0000000000..4b7bd7b408 --- /dev/null +++ b/src/wrapped/generated/wrappedgobject2undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgobject2UNDEFS_H_ +#define __wrappedgobject2UNDEFS_H_ + + +#endif // __wrappedgobject2UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedgssapikrb5defs.h b/src/wrapped/generated/wrappedgssapikrb5defs.h new file mode 100644 index 0000000000..28e99c3d7c --- /dev/null +++ b/src/wrapped/generated/wrappedgssapikrb5defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgssapikrb5DEFS_H_ +#define __wrappedgssapikrb5DEFS_H_ + + +#endif // __wrappedgssapikrb5DEFS_H_ diff --git a/src/wrapped/generated/wrappedgssapikrb5types.h b/src/wrapped/generated/wrappedgssapikrb5types.h new file mode 100644 index 0000000000..b0428ad470 --- /dev/null +++ b/src/wrapped/generated/wrappedgssapikrb5types.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgssapikrb5TYPES_H_ +#define __wrappedgssapikrb5TYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedgssapikrb5TYPES_H_ diff --git a/src/wrapped/generated/wrappedgssapikrb5undefs.h b/src/wrapped/generated/wrappedgssapikrb5undefs.h new file mode 100644 index 0000000000..e7ffc5f411 --- /dev/null +++ b/src/wrapped/generated/wrappedgssapikrb5undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgssapikrb5UNDEFS_H_ +#define __wrappedgssapikrb5UNDEFS_H_ + + +#endif // __wrappedgssapikrb5UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedgstinterfaces010defs.h b/src/wrapped/generated/wrappedgstinterfaces010defs.h new file mode 100644 index 0000000000..816c6fdca9 --- /dev/null +++ b/src/wrapped/generated/wrappedgstinterfaces010defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgstinterfaces010DEFS_H_ +#define __wrappedgstinterfaces010DEFS_H_ + + +#endif // __wrappedgstinterfaces010DEFS_H_ diff --git a/src/wrapped/generated/wrappedgstinterfaces010types.h b/src/wrapped/generated/wrappedgstinterfaces010types.h new file mode 100644 index 0000000000..7723767ce0 --- /dev/null +++ b/src/wrapped/generated/wrappedgstinterfaces010types.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgstinterfaces010TYPES_H_ +#define __wrappedgstinterfaces010TYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedgstinterfaces010TYPES_H_ diff --git a/src/wrapped/generated/wrappedgstinterfaces010undefs.h b/src/wrapped/generated/wrappedgstinterfaces010undefs.h new file mode 100644 index 0000000000..83ad760e2f --- /dev/null +++ b/src/wrapped/generated/wrappedgstinterfaces010undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgstinterfaces010UNDEFS_H_ +#define __wrappedgstinterfaces010UNDEFS_H_ + + +#endif // __wrappedgstinterfaces010UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedgstreamer010defs.h b/src/wrapped/generated/wrappedgstreamer010defs.h new file mode 100644 index 0000000000..6a1f230b88 --- /dev/null +++ b/src/wrapped/generated/wrappedgstreamer010defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgstreamer010DEFS_H_ +#define __wrappedgstreamer010DEFS_H_ + + +#endif // __wrappedgstreamer010DEFS_H_ diff --git a/src/wrapped/generated/wrappedgstreamer010types.h b/src/wrapped/generated/wrappedgstreamer010types.h new file mode 100644 index 0000000000..5f26344d83 --- /dev/null +++ b/src/wrapped/generated/wrappedgstreamer010types.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgstreamer010TYPES_H_ +#define __wrappedgstreamer010TYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedgstreamer010TYPES_H_ diff --git a/src/wrapped/generated/wrappedgstreamer010undefs.h b/src/wrapped/generated/wrappedgstreamer010undefs.h new file mode 100644 index 0000000000..0be3ae8731 --- /dev/null +++ b/src/wrapped/generated/wrappedgstreamer010undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgstreamer010UNDEFS_H_ +#define __wrappedgstreamer010UNDEFS_H_ + + +#endif // __wrappedgstreamer010UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedgthread2defs.h b/src/wrapped/generated/wrappedgthread2defs.h new file mode 100644 index 0000000000..90dca9c78f --- /dev/null +++ b/src/wrapped/generated/wrappedgthread2defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgthread2DEFS_H_ +#define __wrappedgthread2DEFS_H_ + + +#endif // __wrappedgthread2DEFS_H_ diff --git a/src/wrapped/generated/wrappedgthread2types.h b/src/wrapped/generated/wrappedgthread2types.h index a96d7b40a9..0d8e80b18c 100644 --- a/src/wrapped/generated/wrappedgthread2types.h +++ b/src/wrapped/generated/wrappedgthread2types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedgthread2TYPES_H_ #define __wrappedgthread2TYPES_H_ diff --git a/src/wrapped/generated/wrappedgthread2undefs.h b/src/wrapped/generated/wrappedgthread2undefs.h new file mode 100644 index 0000000000..8e3b71622b --- /dev/null +++ b/src/wrapped/generated/wrappedgthread2undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgthread2UNDEFS_H_ +#define __wrappedgthread2UNDEFS_H_ + + +#endif // __wrappedgthread2UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedgtk3defs.h b/src/wrapped/generated/wrappedgtk3defs.h new file mode 100644 index 0000000000..8b48984c7a --- /dev/null +++ b/src/wrapped/generated/wrappedgtk3defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgtk3DEFS_H_ +#define __wrappedgtk3DEFS_H_ + + +#endif // __wrappedgtk3DEFS_H_ diff --git a/src/wrapped/generated/wrappedgtk3types.h b/src/wrapped/generated/wrappedgtk3types.h index 63d0141bad..31512b9e82 100644 --- a/src/wrapped/generated/wrappedgtk3types.h +++ b/src/wrapped/generated/wrappedgtk3types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedgtk3TYPES_H_ #define __wrappedgtk3TYPES_H_ @@ -15,7 +15,7 @@ typedef void* (*pFi_t)(int32_t); typedef void (*vFpp_t)(void*, void*); typedef int32_t (*iFpp_t)(void*, void*); typedef void (*vFppp_t)(void*, void*, void*); -typedef void (*vFppV_t)(void*, void*, void*); +typedef void (*vFppV_t)(void*, void*, ...); typedef uint32_t (*uFupp_t)(uint32_t, void*, void*); typedef void (*vFpppp_t)(void*, void*, void*, void*); typedef int32_t (*iFpppp_t)(void*, void*, void*, void*); diff --git a/src/wrapped/generated/wrappedgtk3undefs.h b/src/wrapped/generated/wrappedgtk3undefs.h new file mode 100644 index 0000000000..54ba3b9440 --- /dev/null +++ b/src/wrapped/generated/wrappedgtk3undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgtk3UNDEFS_H_ +#define __wrappedgtk3UNDEFS_H_ + + +#endif // __wrappedgtk3UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedgtkx112defs.h b/src/wrapped/generated/wrappedgtkx112defs.h new file mode 100644 index 0000000000..778812117e --- /dev/null +++ b/src/wrapped/generated/wrappedgtkx112defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgtkx112DEFS_H_ +#define __wrappedgtkx112DEFS_H_ + + +#endif // __wrappedgtkx112DEFS_H_ diff --git a/src/wrapped/generated/wrappedgtkx112types.h b/src/wrapped/generated/wrappedgtkx112types.h index 11ba9e3638..9bb542ab16 100644 --- a/src/wrapped/generated/wrappedgtkx112types.h +++ b/src/wrapped/generated/wrappedgtkx112types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedgtkx112TYPES_H_ #define __wrappedgtkx112TYPES_H_ @@ -17,7 +17,7 @@ typedef void (*vFpp_t)(void*, void*); typedef int32_t (*iFpp_t)(void*, void*); typedef void* (*pFpi_t)(void*, int32_t); typedef void (*vFppp_t)(void*, void*, void*); -typedef void (*vFppV_t)(void*, void*, void*); +typedef void (*vFppV_t)(void*, void*, ...); typedef uint32_t (*uFupp_t)(uint32_t, void*, void*); typedef void (*vFppup_t)(void*, void*, uint32_t, void*); typedef void (*vFpppp_t)(void*, void*, void*, void*); @@ -26,7 +26,7 @@ typedef uintptr_t (*LFpppp_t)(void*, void*, void*, void*); typedef void (*vFpippp_t)(void*, int32_t, void*, void*, void*); typedef void (*vFppupp_t)(void*, void*, uint32_t, void*, void*); typedef void (*vFppppp_t)(void*, void*, void*, void*, void*); -typedef void (*vFpuipuV_t)(void*, uint32_t, int32_t, void*, uint32_t, void*); +typedef void (*vFpuipuV_t)(void*, uint32_t, int32_t, void*, uint32_t, ...); typedef int32_t (*iFppuppp_t)(void*, void*, uint32_t, void*, void*, void*); typedef int32_t (*iFpppppp_t)(void*, void*, void*, void*, void*, void*); typedef uint32_t (*uFiipppp_t)(int32_t, int32_t, void*, void*, void*, void*); diff --git a/src/wrapped/generated/wrappedgtkx112undefs.h b/src/wrapped/generated/wrappedgtkx112undefs.h new file mode 100644 index 0000000000..d1bce020ce --- /dev/null +++ b/src/wrapped/generated/wrappedgtkx112undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgtkx112UNDEFS_H_ +#define __wrappedgtkx112UNDEFS_H_ + + +#endif // __wrappedgtkx112UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedgudev1defs.h b/src/wrapped/generated/wrappedgudev1defs.h new file mode 100644 index 0000000000..9380567178 --- /dev/null +++ b/src/wrapped/generated/wrappedgudev1defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgudev1DEFS_H_ +#define __wrappedgudev1DEFS_H_ + + +#endif // __wrappedgudev1DEFS_H_ diff --git a/src/wrapped/generated/wrappedgudev1types.h b/src/wrapped/generated/wrappedgudev1types.h new file mode 100644 index 0000000000..f551a951c2 --- /dev/null +++ b/src/wrapped/generated/wrappedgudev1types.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgudev1TYPES_H_ +#define __wrappedgudev1TYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedgudev1TYPES_H_ diff --git a/src/wrapped/generated/wrappedgudev1undefs.h b/src/wrapped/generated/wrappedgudev1undefs.h new file mode 100644 index 0000000000..8875fae699 --- /dev/null +++ b/src/wrapped/generated/wrappedgudev1undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedgudev1UNDEFS_H_ +#define __wrappedgudev1UNDEFS_H_ + + +#endif // __wrappedgudev1UNDEFS_H_ diff --git a/src/wrapped/generated/wrappediconvdefs.h b/src/wrapped/generated/wrappediconvdefs.h new file mode 100644 index 0000000000..0d49c087b9 --- /dev/null +++ b/src/wrapped/generated/wrappediconvdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappediconvDEFS_H_ +#define __wrappediconvDEFS_H_ + + +#endif // __wrappediconvDEFS_H_ diff --git a/src/wrapped/generated/wrappediconvtypes.h b/src/wrapped/generated/wrappediconvtypes.h new file mode 100644 index 0000000000..aedd94f9ef --- /dev/null +++ b/src/wrapped/generated/wrappediconvtypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappediconvTYPES_H_ +#define __wrappediconvTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappediconvTYPES_H_ diff --git a/src/wrapped/generated/wrappediconvundefs.h b/src/wrapped/generated/wrappediconvundefs.h new file mode 100644 index 0000000000..6dced24c4a --- /dev/null +++ b/src/wrapped/generated/wrappediconvundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappediconvUNDEFS_H_ +#define __wrappediconvUNDEFS_H_ + + +#endif // __wrappediconvUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedkrb5defs.h b/src/wrapped/generated/wrappedkrb5defs.h new file mode 100644 index 0000000000..43a48122cc --- /dev/null +++ b/src/wrapped/generated/wrappedkrb5defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedkrb5DEFS_H_ +#define __wrappedkrb5DEFS_H_ + + +#endif // __wrappedkrb5DEFS_H_ diff --git a/src/wrapped/generated/wrappedkrb5types.h b/src/wrapped/generated/wrappedkrb5types.h index bc06543f21..8ed98c8efc 100644 --- a/src/wrapped/generated/wrappedkrb5types.h +++ b/src/wrapped/generated/wrappedkrb5types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedkrb5TYPES_H_ #define __wrappedkrb5TYPES_H_ diff --git a/src/wrapped/generated/wrappedkrb5undefs.h b/src/wrapped/generated/wrappedkrb5undefs.h new file mode 100644 index 0000000000..b6cddaf6f2 --- /dev/null +++ b/src/wrapped/generated/wrappedkrb5undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedkrb5UNDEFS_H_ +#define __wrappedkrb5UNDEFS_H_ + + +#endif // __wrappedkrb5UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlberdefs.h b/src/wrapped/generated/wrappedlberdefs.h new file mode 100644 index 0000000000..7c07a63b42 --- /dev/null +++ b/src/wrapped/generated/wrappedlberdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlberDEFS_H_ +#define __wrappedlberDEFS_H_ + + +#endif // __wrappedlberDEFS_H_ diff --git a/src/wrapped/generated/wrappedlbertypes.h b/src/wrapped/generated/wrappedlbertypes.h new file mode 100644 index 0000000000..197be242d6 --- /dev/null +++ b/src/wrapped/generated/wrappedlbertypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlberTYPES_H_ +#define __wrappedlberTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlberTYPES_H_ diff --git a/src/wrapped/generated/wrappedlberundefs.h b/src/wrapped/generated/wrappedlberundefs.h new file mode 100644 index 0000000000..b11c15cd70 --- /dev/null +++ b/src/wrapped/generated/wrappedlberundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlberUNDEFS_H_ +#define __wrappedlberUNDEFS_H_ + + +#endif // __wrappedlberUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlcms2defs.h b/src/wrapped/generated/wrappedlcms2defs.h new file mode 100644 index 0000000000..1874ef96d3 --- /dev/null +++ b/src/wrapped/generated/wrappedlcms2defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlcms2DEFS_H_ +#define __wrappedlcms2DEFS_H_ + + +#endif // __wrappedlcms2DEFS_H_ diff --git a/src/wrapped/generated/wrappedlcms2types.h b/src/wrapped/generated/wrappedlcms2types.h index 53e9863b2b..711cbd156b 100644 --- a/src/wrapped/generated/wrappedlcms2types.h +++ b/src/wrapped/generated/wrappedlcms2types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlcms2TYPES_H_ #define __wrappedlcms2TYPES_H_ diff --git a/src/wrapped/generated/wrappedlcms2undefs.h b/src/wrapped/generated/wrappedlcms2undefs.h new file mode 100644 index 0000000000..303e0b5f10 --- /dev/null +++ b/src/wrapped/generated/wrappedlcms2undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlcms2UNDEFS_H_ +#define __wrappedlcms2UNDEFS_H_ + + +#endif // __wrappedlcms2UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedldaprdefs.h b/src/wrapped/generated/wrappedldaprdefs.h new file mode 100644 index 0000000000..d7b29a0255 --- /dev/null +++ b/src/wrapped/generated/wrappedldaprdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedldaprDEFS_H_ +#define __wrappedldaprDEFS_H_ + + +#endif // __wrappedldaprDEFS_H_ diff --git a/src/wrapped/generated/wrappedldaprtypes.h b/src/wrapped/generated/wrappedldaprtypes.h index db381c40d8..624582affa 100644 --- a/src/wrapped/generated/wrappedldaprtypes.h +++ b/src/wrapped/generated/wrappedldaprtypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedldaprTYPES_H_ #define __wrappedldaprTYPES_H_ diff --git a/src/wrapped/generated/wrappedldaprundefs.h b/src/wrapped/generated/wrappedldaprundefs.h new file mode 100644 index 0000000000..a97c8f02a0 --- /dev/null +++ b/src/wrapped/generated/wrappedldaprundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedldaprUNDEFS_H_ +#define __wrappedldaprUNDEFS_H_ + + +#endif // __wrappedldaprUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedldlinuxdefs.h b/src/wrapped/generated/wrappedldlinuxdefs.h new file mode 100644 index 0000000000..8437879b0b --- /dev/null +++ b/src/wrapped/generated/wrappedldlinuxdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedldlinuxDEFS_H_ +#define __wrappedldlinuxDEFS_H_ + + +#endif // __wrappedldlinuxDEFS_H_ diff --git a/src/wrapped/generated/wrappedldlinuxtypes.h b/src/wrapped/generated/wrappedldlinuxtypes.h index ed61cbaf25..446a0195d1 100644 --- a/src/wrapped/generated/wrappedldlinuxtypes.h +++ b/src/wrapped/generated/wrappedldlinuxtypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedldlinuxTYPES_H_ #define __wrappedldlinuxTYPES_H_ diff --git a/src/wrapped/generated/wrappedldlinuxundefs.h b/src/wrapped/generated/wrappedldlinuxundefs.h new file mode 100644 index 0000000000..f42f8689c0 --- /dev/null +++ b/src/wrapped/generated/wrappedldlinuxundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedldlinuxUNDEFS_H_ +#define __wrappedldlinuxUNDEFS_H_ + + +#endif // __wrappedldlinuxUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibasounddefs.h b/src/wrapped/generated/wrappedlibasounddefs.h new file mode 100644 index 0000000000..997033035f --- /dev/null +++ b/src/wrapped/generated/wrappedlibasounddefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibasoundDEFS_H_ +#define __wrappedlibasoundDEFS_H_ + + +#endif // __wrappedlibasoundDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibasoundtypes.h b/src/wrapped/generated/wrappedlibasoundtypes.h index c3ba78fc90..1af6a3d5b1 100644 --- a/src/wrapped/generated/wrappedlibasoundtypes.h +++ b/src/wrapped/generated/wrappedlibasoundtypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibasoundTYPES_H_ #define __wrappedlibasoundTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibasoundundefs.h b/src/wrapped/generated/wrappedlibasoundundefs.h new file mode 100644 index 0000000000..4f3edfb45c --- /dev/null +++ b/src/wrapped/generated/wrappedlibasoundundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibasoundUNDEFS_H_ +#define __wrappedlibasoundUNDEFS_H_ + + +#endif // __wrappedlibasoundUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibcdefs.h b/src/wrapped/generated/wrappedlibcdefs.h new file mode 100644 index 0000000000..e909bd8cdd --- /dev/null +++ b/src/wrapped/generated/wrappedlibcdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibcDEFS_H_ +#define __wrappedlibcDEFS_H_ + + +#endif // __wrappedlibcDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibcryptdefs.h b/src/wrapped/generated/wrappedlibcryptdefs.h new file mode 100644 index 0000000000..099eab982b --- /dev/null +++ b/src/wrapped/generated/wrappedlibcryptdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibcryptDEFS_H_ +#define __wrappedlibcryptDEFS_H_ + + +#endif // __wrappedlibcryptDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibcrypttypes.h b/src/wrapped/generated/wrappedlibcrypttypes.h new file mode 100644 index 0000000000..d5e40c343a --- /dev/null +++ b/src/wrapped/generated/wrappedlibcrypttypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibcryptTYPES_H_ +#define __wrappedlibcryptTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibcryptTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibcryptundefs.h b/src/wrapped/generated/wrappedlibcryptundefs.h new file mode 100644 index 0000000000..2728182252 --- /dev/null +++ b/src/wrapped/generated/wrappedlibcryptundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibcryptUNDEFS_H_ +#define __wrappedlibcryptUNDEFS_H_ + + +#endif // __wrappedlibcryptUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibctypes.h b/src/wrapped/generated/wrappedlibctypes.h index f036e5fe08..cf5caf1925 100644 --- a/src/wrapped/generated/wrappedlibctypes.h +++ b/src/wrapped/generated/wrappedlibctypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibcTYPES_H_ #define __wrappedlibcTYPES_H_ @@ -11,23 +11,112 @@ #define ADDED_FUNCTIONS() #endif +typedef void (*vFv_t)(void); +typedef void (*vFp_t)(void*); +typedef int32_t (*iFv_t)(void); +typedef int32_t (*iFi_t)(int32_t); +typedef int32_t (*iFL_t)(uintptr_t); +typedef int32_t (*iFp_t)(void*); +typedef int32_t (*iFO_t)(int32_t); +typedef uint32_t (*uFv_t)(void); +typedef uint32_t (*uFu_t)(uint32_t); +typedef uint32_t (*uFp_t)(void*); +typedef uintptr_t (*LFL_t)(uintptr_t); +typedef void* (*pFL_t)(uintptr_t); +typedef void* (*pFp_t)(void*); +typedef void (*vFip_t)(int32_t, void*); +typedef void (*vFpi_t)(void*, int32_t); +typedef void (*vFpu_t)(void*, uint32_t); +typedef void (*vFpp_t)(void*, void*); +typedef void (*vFpV_t)(void*, ...); +typedef int32_t (*iFip_t)(int32_t, void*); +typedef int32_t (*iFpi_t)(void*, int32_t); +typedef int32_t (*iFpL_t)(void*, uintptr_t); typedef int32_t (*iFpp_t)(void*, void*); -typedef int32_t (*iFpV_t)(void*, void*); +typedef int32_t (*iFpV_t)(void*, ...); typedef int32_t (*iFSp_t)(void*, void*); +typedef int64_t (*IFII_t)(int64_t, int64_t); +typedef uint64_t (*UFUU_t)(uint64_t, uint64_t); +typedef void* (*pFip_t)(int32_t, void*); +typedef void* (*pFpi_t)(void*, int32_t); +typedef void* (*pFpp_t)(void*, void*); +typedef void (*vFipV_t)(int32_t, void*, ...); +typedef void (*vFpuu_t)(void*, uint32_t, uint32_t); typedef void (*vFpup_t)(void*, uint32_t, void*); +typedef void (*vFppu_t)(void*, void*, uint32_t); +typedef void (*vFppp_t)(void*, void*, void*); +typedef int32_t (*iFvpp_t)(void, void*, void*); +typedef int32_t (*iFvpV_t)(void, void*, ...); +typedef int32_t (*iFiip_t)(int32_t, int32_t, void*); +typedef int32_t (*iFiiN_t)(int32_t, int32_t, ...); typedef int32_t (*iFipL_t)(int32_t, void*, uintptr_t); +typedef int32_t (*iFipp_t)(int32_t, void*, void*); +typedef int32_t (*iFipV_t)(int32_t, void*, ...); +typedef int32_t (*iFpuu_t)(void*, uint32_t, uint32_t); +typedef int32_t (*iFpLi_t)(void*, uintptr_t, int32_t); +typedef int32_t (*iFppi_t)(void*, void*, int32_t); +typedef int32_t (*iFppL_t)(void*, void*, uintptr_t); typedef int32_t (*iFppp_t)(void*, void*, void*); +typedef int32_t (*iFppV_t)(void*, void*, ...); +typedef int32_t (*iFpOu_t)(void*, int32_t, uint32_t); +typedef int32_t (*iFpOV_t)(void*, int32_t, ...); +typedef intptr_t (*lFipL_t)(int32_t, void*, uintptr_t); +typedef void* (*pFpii_t)(void*, int32_t, int32_t); +typedef void* (*pFpip_t)(void*, int32_t, void*); +typedef void* (*pFpLL_t)(void*, uintptr_t, uintptr_t); +typedef void (*vFpLLp_t)(void*, uintptr_t, uintptr_t, void*); typedef void (*vFpppp_t)(void*, void*, void*, void*); +typedef int32_t (*iFiiip_t)(int32_t, int32_t, int32_t, void*); +typedef int32_t (*iFiiiN_t)(int32_t, int32_t, int32_t, ...); +typedef int32_t (*iFiiII_t)(int32_t, int32_t, int64_t, int64_t); +typedef int32_t (*iFipii_t)(int32_t, void*, int32_t, int32_t); +typedef int32_t (*iFipuu_t)(int32_t, void*, uint32_t, uint32_t); +typedef int32_t (*iFippi_t)(int32_t, void*, void*, int32_t); +typedef int32_t (*iFpvpp_t)(void*, void, void*, void*); +typedef int32_t (*iFpvpV_t)(void*, void, void*, ...); +typedef int32_t (*iFpipp_t)(void*, int32_t, void*, void*); +typedef int32_t (*iFpipV_t)(void*, int32_t, void*, ...); +typedef int32_t (*iFpuii_t)(void*, uint32_t, int32_t, int32_t); +typedef int32_t (*iFpupV_t)(void*, uint32_t, void*, ...); +typedef int32_t (*iFpLpV_t)(void*, uintptr_t, void*, ...); +typedef int32_t (*iFppii_t)(void*, void*, int32_t, int32_t); +typedef int32_t (*iFppiV_t)(void*, void*, int32_t, ...); +typedef int32_t (*iFpppp_t)(void*, void*, void*, void*); +typedef intptr_t (*lFipiI_t)(int32_t, void*, int32_t, int64_t); +typedef intptr_t (*lFpupp_t)(void*, uint32_t, void*, void*); +typedef void (*vFpLLpp_t)(void*, uintptr_t, uintptr_t, void*, void*); +typedef int32_t (*iFiippi_t)(int32_t, int32_t, void*, void*, int32_t); +typedef int32_t (*iFipipu_t)(int32_t, void*, int32_t, void*, uint32_t); +typedef int32_t (*iFipuup_t)(int32_t, void*, uint32_t, uint32_t, void*); +typedef int32_t (*iFipppp_t)(int32_t, void*, void*, void*, void*); +typedef int32_t (*iFpvvpV_t)(void*, void, void, void*, ...); +typedef int32_t (*iFpiLpp_t)(void*, int32_t, uintptr_t, void*, void*); +typedef int32_t (*iFpippp_t)(void*, int32_t, void*, void*, void*); +typedef int32_t (*iFpuppp_t)(void*, uint32_t, void*, void*, void*); +typedef int32_t (*iFpLLpp_t)(void*, uintptr_t, uintptr_t, void*, void*); +typedef int32_t (*iFpLppp_t)(void*, uintptr_t, void*, void*, void*); +typedef void* (*pFpLLiN_t)(void*, uintptr_t, uintptr_t, int32_t, ...); +typedef void* (*pFppLLp_t)(void*, void*, uintptr_t, uintptr_t, void*); +typedef void* (*pFpppLp_t)(void*, void*, void*, uintptr_t, void*); +typedef int32_t (*iFpuiupV_t)(void*, uint32_t, int32_t, uint32_t, void*, ...); +typedef int32_t (*iFpLiipV_t)(void*, uintptr_t, int32_t, int32_t, void*, ...); +typedef int32_t (*iFpppppp_t)(void*, void*, void*, void*, void*, void*); +typedef void* (*pFpLiiii_t)(void*, uintptr_t, int32_t, int32_t, int32_t, int32_t); +typedef void* (*pFpLiiiI_t)(void*, uintptr_t, int32_t, int32_t, int32_t, int64_t); +typedef void* (*pFpppppp_t)(void*, void*, void*, void*, void*, void*); +typedef int32_t (*iFpippppp_t)(void*, int32_t, void*, void*, void*, void*, void*); +typedef int32_t (*iFpuvvppp_t)(void*, uint32_t, void, void, void*, void*, void*); #define SUPER() ADDED_FUNCTIONS() \ - GO(__vwprintf_chk, iFpp_t) \ - GO(execl, iFpV_t) \ - GO(execle, iFpV_t) \ - GO(execlp, iFpV_t) \ + GO(fstat, iFip_t) \ + GO(lstat, iFpp_t) \ + GO(stat, iFpp_t) \ GO(_IO_file_stat, iFSp_t) \ GO(_ITM_addUserCommitAction, vFpup_t) \ GO(modify_ldt, iFipL_t) \ - GO(__vfwprintf_chk, iFppp_t) \ - GO(__libc_init, vFpppp_t) + GO(getopt, iFipp_t) \ + GO(__libc_init, vFpppp_t) \ + GO(getopt_long, iFipppp_t) \ + GO(getopt_long_only, iFipppp_t) #endif // __wrappedlibcTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibcundefs.h b/src/wrapped/generated/wrappedlibcundefs.h new file mode 100644 index 0000000000..c63d2aeb37 --- /dev/null +++ b/src/wrapped/generated/wrappedlibcundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibcUNDEFS_H_ +#define __wrappedlibcUNDEFS_H_ + + +#endif // __wrappedlibcUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibcupsdefs.h b/src/wrapped/generated/wrappedlibcupsdefs.h new file mode 100644 index 0000000000..3dec9e1229 --- /dev/null +++ b/src/wrapped/generated/wrappedlibcupsdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibcupsDEFS_H_ +#define __wrappedlibcupsDEFS_H_ + + +#endif // __wrappedlibcupsDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibcupstypes.h b/src/wrapped/generated/wrappedlibcupstypes.h new file mode 100644 index 0000000000..776e3087c1 --- /dev/null +++ b/src/wrapped/generated/wrappedlibcupstypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibcupsTYPES_H_ +#define __wrappedlibcupsTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibcupsTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibcupsundefs.h b/src/wrapped/generated/wrappedlibcupsundefs.h new file mode 100644 index 0000000000..70e8f1959f --- /dev/null +++ b/src/wrapped/generated/wrappedlibcupsundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibcupsUNDEFS_H_ +#define __wrappedlibcupsUNDEFS_H_ + + +#endif // __wrappedlibcupsUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibdldefs.h b/src/wrapped/generated/wrappedlibdldefs.h new file mode 100644 index 0000000000..4c3f5b3ee3 --- /dev/null +++ b/src/wrapped/generated/wrappedlibdldefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibdlDEFS_H_ +#define __wrappedlibdlDEFS_H_ + + +#endif // __wrappedlibdlDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibdltypes.h b/src/wrapped/generated/wrappedlibdltypes.h index 4f66c5012a..d7396ef8d2 100644 --- a/src/wrapped/generated/wrappedlibdltypes.h +++ b/src/wrapped/generated/wrappedlibdltypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibdlTYPES_H_ #define __wrappedlibdlTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibdlundefs.h b/src/wrapped/generated/wrappedlibdlundefs.h new file mode 100644 index 0000000000..8ca2f7479b --- /dev/null +++ b/src/wrapped/generated/wrappedlibdlundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibdlUNDEFS_H_ +#define __wrappedlibdlUNDEFS_H_ + + +#endif // __wrappedlibdlUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibdrmdefs.h b/src/wrapped/generated/wrappedlibdrmdefs.h new file mode 100644 index 0000000000..0c07e3a4a7 --- /dev/null +++ b/src/wrapped/generated/wrappedlibdrmdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibdrmDEFS_H_ +#define __wrappedlibdrmDEFS_H_ + + +#endif // __wrappedlibdrmDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibdrmtypes.h b/src/wrapped/generated/wrappedlibdrmtypes.h new file mode 100644 index 0000000000..ebfa23e702 --- /dev/null +++ b/src/wrapped/generated/wrappedlibdrmtypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibdrmTYPES_H_ +#define __wrappedlibdrmTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibdrmTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibdrmundefs.h b/src/wrapped/generated/wrappedlibdrmundefs.h new file mode 100644 index 0000000000..cf054affb2 --- /dev/null +++ b/src/wrapped/generated/wrappedlibdrmundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibdrmUNDEFS_H_ +#define __wrappedlibdrmUNDEFS_H_ + + +#endif // __wrappedlibdrmUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibformwdefs.h b/src/wrapped/generated/wrappedlibformwdefs.h new file mode 100644 index 0000000000..3cd397102f --- /dev/null +++ b/src/wrapped/generated/wrappedlibformwdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibformwDEFS_H_ +#define __wrappedlibformwDEFS_H_ + + +#endif // __wrappedlibformwDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibformwtypes.h b/src/wrapped/generated/wrappedlibformwtypes.h new file mode 100644 index 0000000000..c937fe2897 --- /dev/null +++ b/src/wrapped/generated/wrappedlibformwtypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibformwTYPES_H_ +#define __wrappedlibformwTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibformwTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibformwundefs.h b/src/wrapped/generated/wrappedlibformwundefs.h new file mode 100644 index 0000000000..f12fbfbd2e --- /dev/null +++ b/src/wrapped/generated/wrappedlibformwundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibformwUNDEFS_H_ +#define __wrappedlibformwUNDEFS_H_ + + +#endif // __wrappedlibformwUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibgldefs.h b/src/wrapped/generated/wrappedlibgldefs.h new file mode 100644 index 0000000000..cacbee6a8b --- /dev/null +++ b/src/wrapped/generated/wrappedlibgldefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibglDEFS_H_ +#define __wrappedlibglDEFS_H_ + + +#endif // __wrappedlibglDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibgltypes.h b/src/wrapped/generated/wrappedlibgltypes.h index c4715a2a4e..345ffc04aa 100644 --- a/src/wrapped/generated/wrappedlibgltypes.h +++ b/src/wrapped/generated/wrappedlibgltypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibglTYPES_H_ #define __wrappedlibglTYPES_H_ @@ -11,11 +11,13 @@ #define ADDED_FUNCTIONS() #endif +typedef int32_t (*iFi_t)(int32_t); typedef void* (*pFp_t)(void*); typedef void (*vFpp_t)(void*, void*); typedef void (*vFipp_t)(int32_t, void*, void*); #define SUPER() ADDED_FUNCTIONS() \ + GO(glXSwapIntervalMESA, iFi_t) \ GO(glXGetProcAddress, pFp_t) \ GO(glXGetProcAddressARB, pFp_t) \ GO(glDebugMessageCallback, vFpp_t) \ diff --git a/src/wrapped/generated/wrappedlibgludefs.h b/src/wrapped/generated/wrappedlibgludefs.h new file mode 100644 index 0000000000..0c2888a8eb --- /dev/null +++ b/src/wrapped/generated/wrappedlibgludefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibgluDEFS_H_ +#define __wrappedlibgluDEFS_H_ + + +#endif // __wrappedlibgluDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibglundefs.h b/src/wrapped/generated/wrappedlibglundefs.h new file mode 100644 index 0000000000..c381ea3334 --- /dev/null +++ b/src/wrapped/generated/wrappedlibglundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibglUNDEFS_H_ +#define __wrappedlibglUNDEFS_H_ + + +#endif // __wrappedlibglUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibglutypes.h b/src/wrapped/generated/wrappedlibglutypes.h index 969918eaf4..71b11f4032 100644 --- a/src/wrapped/generated/wrappedlibglutypes.h +++ b/src/wrapped/generated/wrappedlibglutypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibgluTYPES_H_ #define __wrappedlibgluTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibgluundefs.h b/src/wrapped/generated/wrappedlibgluundefs.h new file mode 100644 index 0000000000..32ee5c6d9a --- /dev/null +++ b/src/wrapped/generated/wrappedlibgluundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibgluUNDEFS_H_ +#define __wrappedlibgluUNDEFS_H_ + + +#endif // __wrappedlibgluUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibicedefs.h b/src/wrapped/generated/wrappedlibicedefs.h new file mode 100644 index 0000000000..1d36558256 --- /dev/null +++ b/src/wrapped/generated/wrappedlibicedefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibiceDEFS_H_ +#define __wrappedlibiceDEFS_H_ + + +#endif // __wrappedlibiceDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibicetypes.h b/src/wrapped/generated/wrappedlibicetypes.h new file mode 100644 index 0000000000..2b8b3fe05a --- /dev/null +++ b/src/wrapped/generated/wrappedlibicetypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibiceTYPES_H_ +#define __wrappedlibiceTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibiceTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibiceundefs.h b/src/wrapped/generated/wrappedlibiceundefs.h new file mode 100644 index 0000000000..207d12a2da --- /dev/null +++ b/src/wrapped/generated/wrappedlibiceundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibiceUNDEFS_H_ +#define __wrappedlibiceUNDEFS_H_ + + +#endif // __wrappedlibiceUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibjpeg62defs.h b/src/wrapped/generated/wrappedlibjpeg62defs.h new file mode 100644 index 0000000000..2e09298902 --- /dev/null +++ b/src/wrapped/generated/wrappedlibjpeg62defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibjpeg62DEFS_H_ +#define __wrappedlibjpeg62DEFS_H_ + + +#endif // __wrappedlibjpeg62DEFS_H_ diff --git a/src/wrapped/generated/wrappedlibjpeg62types.h b/src/wrapped/generated/wrappedlibjpeg62types.h index 66a6c86aae..cbcb58aab4 100644 --- a/src/wrapped/generated/wrappedlibjpeg62types.h +++ b/src/wrapped/generated/wrappedlibjpeg62types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibjpeg62TYPES_H_ #define __wrappedlibjpeg62TYPES_H_ @@ -12,6 +12,7 @@ #endif typedef void (*vFp_t)(void*); +typedef int32_t (*iFv_t)(void); typedef int32_t (*iFp_t)(void*); typedef void* (*pFp_t)(void*); typedef void (*vFpi_t)(void*, int32_t); @@ -28,6 +29,7 @@ typedef void (*vFpipu_t)(void*, int32_t, void*, uint32_t); GO(jpeg_destroy_decompress, vFp_t) \ GO(jpeg_finish_compress, vFp_t) \ GO(jpeg_set_defaults, vFp_t) \ + GO(jpeg_simd_cpu_support, iFv_t) \ GO(jpeg_finish_decompress, iFp_t) \ GO(jpeg_start_decompress, iFp_t) \ GO(jpeg_std_error, pFp_t) \ diff --git a/src/wrapped/generated/wrappedlibjpeg62undefs.h b/src/wrapped/generated/wrappedlibjpeg62undefs.h new file mode 100644 index 0000000000..89c89d7c52 --- /dev/null +++ b/src/wrapped/generated/wrappedlibjpeg62undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibjpeg62UNDEFS_H_ +#define __wrappedlibjpeg62UNDEFS_H_ + + +#endif // __wrappedlibjpeg62UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibjpegdefs.h b/src/wrapped/generated/wrappedlibjpegdefs.h new file mode 100644 index 0000000000..6f1e7e918d --- /dev/null +++ b/src/wrapped/generated/wrappedlibjpegdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibjpegDEFS_H_ +#define __wrappedlibjpegDEFS_H_ + + +#endif // __wrappedlibjpegDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibjpegtypes.h b/src/wrapped/generated/wrappedlibjpegtypes.h index 0ce3e079a2..e3643e3f18 100644 --- a/src/wrapped/generated/wrappedlibjpegtypes.h +++ b/src/wrapped/generated/wrappedlibjpegtypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibjpegTYPES_H_ #define __wrappedlibjpegTYPES_H_ @@ -11,6 +11,7 @@ #define ADDED_FUNCTIONS() #endif +typedef int32_t (*iFv_t)(void); typedef int32_t (*iFp_t)(void*); typedef void* (*pFp_t)(void*); typedef int32_t (*iFpi_t)(void*, int32_t); @@ -19,6 +20,7 @@ typedef void (*vFpip_t)(void*, int32_t, void*); typedef uint32_t (*uFppu_t)(void*, void*, uint32_t); #define SUPER() ADDED_FUNCTIONS() \ + GO(jpeg_simd_cpu_support, iFv_t) \ GO(jpeg_finish_decompress, iFp_t) \ GO(jpeg_start_decompress, iFp_t) \ GO(jpeg_std_error, pFp_t) \ diff --git a/src/wrapped/generated/wrappedlibjpegundefs.h b/src/wrapped/generated/wrappedlibjpegundefs.h new file mode 100644 index 0000000000..328befef4e --- /dev/null +++ b/src/wrapped/generated/wrappedlibjpegundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibjpegUNDEFS_H_ +#define __wrappedlibjpegUNDEFS_H_ + + +#endif // __wrappedlibjpegUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibmdefs.h b/src/wrapped/generated/wrappedlibmdefs.h new file mode 100644 index 0000000000..edc76f7371 --- /dev/null +++ b/src/wrapped/generated/wrappedlibmdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibmDEFS_H_ +#define __wrappedlibmDEFS_H_ + + +#endif // __wrappedlibmDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibmtypes.h b/src/wrapped/generated/wrappedlibmtypes.h new file mode 100644 index 0000000000..4fff69ab49 --- /dev/null +++ b/src/wrapped/generated/wrappedlibmtypes.h @@ -0,0 +1,70 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibmTYPES_H_ +#define __wrappedlibmTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + +typedef uint64_t (*UFs_t)(void*); +typedef float (*fFf_t)(float); +typedef double (*dFd_t)(double); +typedef float (*fFff_t)(float, float); +typedef double (*dFdd_t)(double, double); +typedef void* (*pFps_t)(void*, void*); +typedef uint64_t (*UFsvvs_t)(void*, void, void, void*); +typedef void* (*pFpsvvvvs_t)(void*, void*, void, void, void, void, void*); + +#define SUPER() ADDED_FUNCTIONS() \ + GO(cacosf, UFs_t) \ + GO(cacoshf, UFs_t) \ + GO(casinf, UFs_t) \ + GO(casinhf, UFs_t) \ + GO(catanf, UFs_t) \ + GO(catanhf, UFs_t) \ + GO(ccosf, UFs_t) \ + GO(ccoshf, UFs_t) \ + GO(cexpf, UFs_t) \ + GO(clogf, UFs_t) \ + GO(cprojf, UFs_t) \ + GO(csinf, UFs_t) \ + GO(csinhf, UFs_t) \ + GO(csqrtf, UFs_t) \ + GO(ctanf, UFs_t) \ + GO(ctanhf, UFs_t) \ + GO(__acosf_finite, fFf_t) \ + GO(__acoshf_finite, fFf_t) \ + GO(__asinf_finite, fFf_t) \ + GO(__coshf_finite, fFf_t) \ + GO(__exp2f_finite, fFf_t) \ + GO(__expf_finite, fFf_t) \ + GO(__log10f_finite, fFf_t) \ + GO(__log2f_finite, fFf_t) \ + GO(__logf_finite, fFf_t) \ + GO(__sinhf_finite, fFf_t) \ + GO(__sqrtf_finite, fFf_t) \ + GO(__acos_finite, dFd_t) \ + GO(__acosh_finite, dFd_t) \ + GO(__asin_finite, dFd_t) \ + GO(__cosh_finite, dFd_t) \ + GO(__exp2_finite, dFd_t) \ + GO(__exp_finite, dFd_t) \ + GO(__log10_finite, dFd_t) \ + GO(__log2_finite, dFd_t) \ + GO(__log_finite, dFd_t) \ + GO(__sinh_finite, dFd_t) \ + GO(__sqrt_finite, dFd_t) \ + GO(__atan2f_finite, fFff_t) \ + GO(__hypotf_finite, fFff_t) \ + GO(__powf_finite, fFff_t) \ + GO(__atan2_finite, dFdd_t) \ + GO(__hypot_finite, dFdd_t) \ + GO(__pow_finite, dFdd_t) \ + GO(cpowf, UFsvvs_t) + +#endif // __wrappedlibmTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibmundefs.h b/src/wrapped/generated/wrappedlibmundefs.h new file mode 100644 index 0000000000..cb89f889d1 --- /dev/null +++ b/src/wrapped/generated/wrappedlibmundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibmUNDEFS_H_ +#define __wrappedlibmUNDEFS_H_ + + +#endif // __wrappedlibmUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibncurses6defs.h b/src/wrapped/generated/wrappedlibncurses6defs.h new file mode 100644 index 0000000000..6ea82a8539 --- /dev/null +++ b/src/wrapped/generated/wrappedlibncurses6defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibncurses6DEFS_H_ +#define __wrappedlibncurses6DEFS_H_ + + +#endif // __wrappedlibncurses6DEFS_H_ diff --git a/src/wrapped/generated/wrappedlibncurses6types.h b/src/wrapped/generated/wrappedlibncurses6types.h index 4f42353d76..3430dc7928 100644 --- a/src/wrapped/generated/wrappedlibncurses6types.h +++ b/src/wrapped/generated/wrappedlibncurses6types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibncurses6TYPES_H_ #define __wrappedlibncurses6TYPES_H_ @@ -11,11 +11,17 @@ #define ADDED_FUNCTIONS() #endif -typedef int32_t (*iFpV_t)(void*, void*); -typedef int32_t (*iFpiipV_t)(void*, int32_t, int32_t, void*, void*); +typedef void* (*pFv_t)(void); +typedef int32_t (*iFpV_t)(void*, ...); +typedef int32_t (*iFppV_t)(void*, void*, ...); +typedef int32_t (*iFiipV_t)(int32_t, int32_t, void*, ...); +typedef int32_t (*iFpiipV_t)(void*, int32_t, int32_t, void*, ...); #define SUPER() ADDED_FUNCTIONS() \ + GO(initscr, pFv_t) \ GO(printw, iFpV_t) \ + GO(vw_printw, iFppV_t) \ + GO(mvprintw, iFiipV_t) \ GO(mvwprintw, iFpiipV_t) #endif // __wrappedlibncurses6TYPES_H_ diff --git a/src/wrapped/generated/wrappedlibncurses6undefs.h b/src/wrapped/generated/wrappedlibncurses6undefs.h new file mode 100644 index 0000000000..ee621282f8 --- /dev/null +++ b/src/wrapped/generated/wrappedlibncurses6undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibncurses6UNDEFS_H_ +#define __wrappedlibncurses6UNDEFS_H_ + + +#endif // __wrappedlibncurses6UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibncursesdefs.h b/src/wrapped/generated/wrappedlibncursesdefs.h new file mode 100644 index 0000000000..de11bd0ca8 --- /dev/null +++ b/src/wrapped/generated/wrappedlibncursesdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibncursesDEFS_H_ +#define __wrappedlibncursesDEFS_H_ + + +#endif // __wrappedlibncursesDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibncursestypes.h b/src/wrapped/generated/wrappedlibncursestypes.h index 8655795fb6..7175315e6c 100644 --- a/src/wrapped/generated/wrappedlibncursestypes.h +++ b/src/wrapped/generated/wrappedlibncursestypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibncursesTYPES_H_ #define __wrappedlibncursesTYPES_H_ @@ -11,12 +11,17 @@ #define ADDED_FUNCTIONS() #endif -typedef int32_t (*iFpV_t)(void*, void*); -typedef int32_t (*iFiipV_t)(int32_t, int32_t, void*, void*); -typedef int32_t (*iFpiipV_t)(void*, int32_t, int32_t, void*, void*); +typedef void* (*pFv_t)(void); +typedef int32_t (*iFpV_t)(void*, ...); +typedef int32_t (*iFppV_t)(void*, void*, ...); +typedef int32_t (*iFiipV_t)(int32_t, int32_t, void*, ...); +typedef int32_t (*iFpiipV_t)(void*, int32_t, int32_t, void*, ...); #define SUPER() ADDED_FUNCTIONS() \ + GO(initscr, pFv_t) \ GO(printw, iFpV_t) \ + GO(vw_printw, iFppV_t) \ + GO(vwprintw, iFppV_t) \ GO(mvprintw, iFiipV_t) \ GO(mvwprintw, iFpiipV_t) diff --git a/src/wrapped/generated/wrappedlibncursesundefs.h b/src/wrapped/generated/wrappedlibncursesundefs.h new file mode 100644 index 0000000000..7862e203a4 --- /dev/null +++ b/src/wrapped/generated/wrappedlibncursesundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibncursesUNDEFS_H_ +#define __wrappedlibncursesUNDEFS_H_ + + +#endif // __wrappedlibncursesUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibncurseswdefs.h b/src/wrapped/generated/wrappedlibncurseswdefs.h new file mode 100644 index 0000000000..6535ea665f --- /dev/null +++ b/src/wrapped/generated/wrappedlibncurseswdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibncurseswDEFS_H_ +#define __wrappedlibncurseswDEFS_H_ + + +#endif // __wrappedlibncurseswDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibncurseswtypes.h b/src/wrapped/generated/wrappedlibncurseswtypes.h index 0528b306f5..72b8467a3d 100644 --- a/src/wrapped/generated/wrappedlibncurseswtypes.h +++ b/src/wrapped/generated/wrappedlibncurseswtypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibncurseswTYPES_H_ #define __wrappedlibncurseswTYPES_H_ @@ -11,11 +11,18 @@ #define ADDED_FUNCTIONS() #endif -typedef int32_t (*iFpV_t)(void*, void*); -typedef int32_t (*iFpiipV_t)(void*, int32_t, int32_t, void*, void*); +typedef void* (*pFv_t)(void); +typedef int32_t (*iFpV_t)(void*, ...); +typedef int32_t (*iFppV_t)(void*, void*, ...); +typedef int32_t (*iFiipV_t)(int32_t, int32_t, void*, ...); +typedef int32_t (*iFpiipV_t)(void*, int32_t, int32_t, void*, ...); #define SUPER() ADDED_FUNCTIONS() \ + GO(initscr, pFv_t) \ GO(printw, iFpV_t) \ + GO(vw_printw, iFppV_t) \ + GO(vwprintw, iFppV_t) \ + GO(mvprintw, iFiipV_t) \ GO(mvwprintw, iFpiipV_t) #endif // __wrappedlibncurseswTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibncurseswundefs.h b/src/wrapped/generated/wrappedlibncurseswundefs.h new file mode 100644 index 0000000000..349b7a6235 --- /dev/null +++ b/src/wrapped/generated/wrappedlibncurseswundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibncurseswUNDEFS_H_ +#define __wrappedlibncurseswUNDEFS_H_ + + +#endif // __wrappedlibncurseswUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibnmdefs.h b/src/wrapped/generated/wrappedlibnmdefs.h new file mode 100644 index 0000000000..6c0b00a75c --- /dev/null +++ b/src/wrapped/generated/wrappedlibnmdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibnmDEFS_H_ +#define __wrappedlibnmDEFS_H_ + + +#endif // __wrappedlibnmDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibnmtypes.h b/src/wrapped/generated/wrappedlibnmtypes.h new file mode 100644 index 0000000000..f7b1316905 --- /dev/null +++ b/src/wrapped/generated/wrappedlibnmtypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibnmTYPES_H_ +#define __wrappedlibnmTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibnmTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibnmundefs.h b/src/wrapped/generated/wrappedlibnmundefs.h new file mode 100644 index 0000000000..0e0b692233 --- /dev/null +++ b/src/wrapped/generated/wrappedlibnmundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibnmUNDEFS_H_ +#define __wrappedlibnmUNDEFS_H_ + + +#endif // __wrappedlibnmUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedliboggdefs.h b/src/wrapped/generated/wrappedliboggdefs.h new file mode 100644 index 0000000000..5f59393c63 --- /dev/null +++ b/src/wrapped/generated/wrappedliboggdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedliboggDEFS_H_ +#define __wrappedliboggDEFS_H_ + + +#endif // __wrappedliboggDEFS_H_ diff --git a/src/wrapped/generated/wrappedliboggtypes.h b/src/wrapped/generated/wrappedliboggtypes.h new file mode 100644 index 0000000000..82d83daa5f --- /dev/null +++ b/src/wrapped/generated/wrappedliboggtypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedliboggTYPES_H_ +#define __wrappedliboggTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedliboggTYPES_H_ diff --git a/src/wrapped/generated/wrappedliboggundefs.h b/src/wrapped/generated/wrappedliboggundefs.h new file mode 100644 index 0000000000..487deb7b3b --- /dev/null +++ b/src/wrapped/generated/wrappedliboggundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedliboggUNDEFS_H_ +#define __wrappedliboggUNDEFS_H_ + + +#endif // __wrappedliboggUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibpaneldefs.h b/src/wrapped/generated/wrappedlibpaneldefs.h new file mode 100644 index 0000000000..865fde0f99 --- /dev/null +++ b/src/wrapped/generated/wrappedlibpaneldefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibpanelDEFS_H_ +#define __wrappedlibpanelDEFS_H_ + + +#endif // __wrappedlibpanelDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibpaneltypes.h b/src/wrapped/generated/wrappedlibpaneltypes.h new file mode 100644 index 0000000000..53e44886f2 --- /dev/null +++ b/src/wrapped/generated/wrappedlibpaneltypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibpanelTYPES_H_ +#define __wrappedlibpanelTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibpanelTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibpanelundefs.h b/src/wrapped/generated/wrappedlibpanelundefs.h new file mode 100644 index 0000000000..c86044bdb0 --- /dev/null +++ b/src/wrapped/generated/wrappedlibpanelundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibpanelUNDEFS_H_ +#define __wrappedlibpanelUNDEFS_H_ + + +#endif // __wrappedlibpanelUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibpthreaddefs.h b/src/wrapped/generated/wrappedlibpthreaddefs.h new file mode 100644 index 0000000000..c7e0b1bf42 --- /dev/null +++ b/src/wrapped/generated/wrappedlibpthreaddefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibpthreadDEFS_H_ +#define __wrappedlibpthreadDEFS_H_ + + +#endif // __wrappedlibpthreadDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibpthreadtypes.h b/src/wrapped/generated/wrappedlibpthreadtypes.h index ff8fb9082c..144d7a84af 100644 --- a/src/wrapped/generated/wrappedlibpthreadtypes.h +++ b/src/wrapped/generated/wrappedlibpthreadtypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibpthreadTYPES_H_ #define __wrappedlibpthreadTYPES_H_ @@ -11,6 +11,7 @@ #define ADDED_FUNCTIONS() #endif +typedef void (*vFv_t)(void); typedef void (*vFp_t)(void*); typedef int32_t (*iFp_t)(void*); typedef void (*vFpi_t)(void*, int32_t); @@ -25,25 +26,32 @@ typedef int32_t (*iFppp_t)(void*, void*, void*); typedef int32_t (*iFpppp_t)(void*, void*, void*, void*); #define SUPER() ADDED_FUNCTIONS() \ + GO(__pthread_initialize, vFv_t) \ GO(__pthread_register_cancel, vFp_t) \ GO(__pthread_unregister_cancel, vFp_t) \ GO(__pthread_unwind_next, vFp_t) \ + GO(__pthread_mutex_destroy, iFp_t) \ + GO(__pthread_mutex_lock, iFp_t) \ + GO(__pthread_mutex_trylock, iFp_t) \ + GO(__pthread_mutex_unlock, iFp_t) \ GO(pthread_attr_destroy, iFp_t) \ - GO(pthread_cond_broadcast@GLIBC_2.0, iFp_t) \ - GO(pthread_cond_destroy@GLIBC_2.0, iFp_t) \ - GO(pthread_cond_signal@GLIBC_2.0, iFp_t) \ + GO(pthread_mutex_destroy, iFp_t) \ + GO(pthread_mutex_lock, iFp_t) \ + GO(pthread_mutex_trylock, iFp_t) \ + GO(pthread_mutex_unlock, iFp_t) \ GO(_pthread_cleanup_pop, vFpi_t) \ GO(_pthread_cleanup_pop_restore, vFpi_t) \ GO(pthread_attr_setscope, iFpi_t) \ GO(pthread_kill, iFpi_t) \ GO(pthread_mutexattr_setkind_np, iFpi_t) \ GO(__pthread_key_create, iFpp_t) \ + GO(__pthread_mutex_init, iFpp_t) \ GO(__pthread_once, iFpp_t) \ GO(pthread_attr_setschedparam, iFpp_t) \ - GO(pthread_cond_init@GLIBC_2.0, iFpp_t) \ GO(pthread_cond_wait, iFpp_t) \ - GO(pthread_cond_wait@GLIBC_2.0, iFpp_t) \ GO(pthread_key_create, iFpp_t) \ + GO(pthread_mutex_init, iFpp_t) \ + GO(pthread_mutex_timedlock, iFpp_t) \ GO(pthread_once, iFpp_t) \ GO(pthread_setname_np, iFpp_t) \ GO(_pthread_cleanup_push, vFppp_t) \ @@ -57,7 +65,6 @@ typedef int32_t (*iFpppp_t)(void*, void*, void*, void*); GO(pthread_atfork, iFppp_t) \ GO(pthread_attr_getstack, iFppp_t) \ GO(pthread_cond_timedwait, iFppp_t) \ - GO(pthread_cond_timedwait@GLIBC_2.0, iFppp_t) \ GO(pthread_create, iFpppp_t) #endif // __wrappedlibpthreadTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibpthreadundefs.h b/src/wrapped/generated/wrappedlibpthreadundefs.h new file mode 100644 index 0000000000..5dcc60510b --- /dev/null +++ b/src/wrapped/generated/wrappedlibpthreadundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibpthreadUNDEFS_H_ +#define __wrappedlibpthreadUNDEFS_H_ + + +#endif // __wrappedlibpthreadUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibresolvdefs.h b/src/wrapped/generated/wrappedlibresolvdefs.h new file mode 100644 index 0000000000..8fb262c44e --- /dev/null +++ b/src/wrapped/generated/wrappedlibresolvdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibresolvDEFS_H_ +#define __wrappedlibresolvDEFS_H_ + + +#endif // __wrappedlibresolvDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibresolvtypes.h b/src/wrapped/generated/wrappedlibresolvtypes.h new file mode 100644 index 0000000000..e235e9cf88 --- /dev/null +++ b/src/wrapped/generated/wrappedlibresolvtypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibresolvTYPES_H_ +#define __wrappedlibresolvTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibresolvTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibresolvundefs.h b/src/wrapped/generated/wrappedlibresolvundefs.h new file mode 100644 index 0000000000..115437fcc4 --- /dev/null +++ b/src/wrapped/generated/wrappedlibresolvundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibresolvUNDEFS_H_ +#define __wrappedlibresolvUNDEFS_H_ + + +#endif // __wrappedlibresolvUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibrtdefs.h b/src/wrapped/generated/wrappedlibrtdefs.h new file mode 100644 index 0000000000..a6a4c7188c --- /dev/null +++ b/src/wrapped/generated/wrappedlibrtdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibrtDEFS_H_ +#define __wrappedlibrtDEFS_H_ + + +#endif // __wrappedlibrtDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibrttypes.h b/src/wrapped/generated/wrappedlibrttypes.h index 04583f0028..6ca59dc2d6 100644 --- a/src/wrapped/generated/wrappedlibrttypes.h +++ b/src/wrapped/generated/wrappedlibrttypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibrtTYPES_H_ #define __wrappedlibrtTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibrtundefs.h b/src/wrapped/generated/wrappedlibrtundefs.h new file mode 100644 index 0000000000..db73bff944 --- /dev/null +++ b/src/wrapped/generated/wrappedlibrtundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibrtUNDEFS_H_ +#define __wrappedlibrtUNDEFS_H_ + + +#endif // __wrappedlibrtUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibsmdefs.h b/src/wrapped/generated/wrappedlibsmdefs.h new file mode 100644 index 0000000000..d04ef6b796 --- /dev/null +++ b/src/wrapped/generated/wrappedlibsmdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibsmDEFS_H_ +#define __wrappedlibsmDEFS_H_ + + +#endif // __wrappedlibsmDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibsmtypes.h b/src/wrapped/generated/wrappedlibsmtypes.h index 0bef58d4e7..f322502b35 100644 --- a/src/wrapped/generated/wrappedlibsmtypes.h +++ b/src/wrapped/generated/wrappedlibsmtypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibsmTYPES_H_ #define __wrappedlibsmTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibsmundefs.h b/src/wrapped/generated/wrappedlibsmundefs.h new file mode 100644 index 0000000000..be922c3d9e --- /dev/null +++ b/src/wrapped/generated/wrappedlibsmundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibsmUNDEFS_H_ +#define __wrappedlibsmUNDEFS_H_ + + +#endif // __wrappedlibsmUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibsndfiledefs.h b/src/wrapped/generated/wrappedlibsndfiledefs.h new file mode 100644 index 0000000000..83ec3ac384 --- /dev/null +++ b/src/wrapped/generated/wrappedlibsndfiledefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibsndfileDEFS_H_ +#define __wrappedlibsndfileDEFS_H_ + + +#endif // __wrappedlibsndfileDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibsndfiletypes.h b/src/wrapped/generated/wrappedlibsndfiletypes.h index 98fecab0e6..57d0d41111 100644 --- a/src/wrapped/generated/wrappedlibsndfiletypes.h +++ b/src/wrapped/generated/wrappedlibsndfiletypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibsndfileTYPES_H_ #define __wrappedlibsndfileTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibsndfileundefs.h b/src/wrapped/generated/wrappedlibsndfileundefs.h new file mode 100644 index 0000000000..39e87caec8 --- /dev/null +++ b/src/wrapped/generated/wrappedlibsndfileundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibsndfileUNDEFS_H_ +#define __wrappedlibsndfileUNDEFS_H_ + + +#endif // __wrappedlibsndfileUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibssldefs.h b/src/wrapped/generated/wrappedlibssldefs.h new file mode 100644 index 0000000000..cb8ebc5816 --- /dev/null +++ b/src/wrapped/generated/wrappedlibssldefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibsslDEFS_H_ +#define __wrappedlibsslDEFS_H_ + + +#endif // __wrappedlibsslDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibssltypes.h b/src/wrapped/generated/wrappedlibssltypes.h index 8e53889bc5..d97f761223 100644 --- a/src/wrapped/generated/wrappedlibssltypes.h +++ b/src/wrapped/generated/wrappedlibssltypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibsslTYPES_H_ #define __wrappedlibsslTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibsslundefs.h b/src/wrapped/generated/wrappedlibsslundefs.h new file mode 100644 index 0000000000..47327f5933 --- /dev/null +++ b/src/wrapped/generated/wrappedlibsslundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibsslUNDEFS_H_ +#define __wrappedlibsslUNDEFS_H_ + + +#endif // __wrappedlibsslUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibtiffdefs.h b/src/wrapped/generated/wrappedlibtiffdefs.h new file mode 100644 index 0000000000..d486d5df53 --- /dev/null +++ b/src/wrapped/generated/wrappedlibtiffdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibtiffDEFS_H_ +#define __wrappedlibtiffDEFS_H_ + + +#endif // __wrappedlibtiffDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibtifftypes.h b/src/wrapped/generated/wrappedlibtifftypes.h new file mode 100644 index 0000000000..a0739605c3 --- /dev/null +++ b/src/wrapped/generated/wrappedlibtifftypes.h @@ -0,0 +1,19 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibtiffTYPES_H_ +#define __wrappedlibtiffTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + +typedef void* (*pFpppppppppp_t)(void*, void*, void*, void*, void*, void*, void*, void*, void*, void*); + +#define SUPER() ADDED_FUNCTIONS() \ + GO(TIFFClientOpen, pFpppppppppp_t) + +#endif // __wrappedlibtiffTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibtiffundefs.h b/src/wrapped/generated/wrappedlibtiffundefs.h new file mode 100644 index 0000000000..f53bfd3d3a --- /dev/null +++ b/src/wrapped/generated/wrappedlibtiffundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibtiffUNDEFS_H_ +#define __wrappedlibtiffUNDEFS_H_ + + +#endif // __wrappedlibtiffUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibtinfo6defs.h b/src/wrapped/generated/wrappedlibtinfo6defs.h new file mode 100644 index 0000000000..9172f03ddf --- /dev/null +++ b/src/wrapped/generated/wrappedlibtinfo6defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibtinfo6DEFS_H_ +#define __wrappedlibtinfo6DEFS_H_ + + +#endif // __wrappedlibtinfo6DEFS_H_ diff --git a/src/wrapped/generated/wrappedlibtinfo6types.h b/src/wrapped/generated/wrappedlibtinfo6types.h index 85c79d3982..8a61dd0a0e 100644 --- a/src/wrapped/generated/wrappedlibtinfo6types.h +++ b/src/wrapped/generated/wrappedlibtinfo6types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibtinfo6TYPES_H_ #define __wrappedlibtinfo6TYPES_H_ diff --git a/src/wrapped/generated/wrappedlibtinfo6undefs.h b/src/wrapped/generated/wrappedlibtinfo6undefs.h new file mode 100644 index 0000000000..719271f06c --- /dev/null +++ b/src/wrapped/generated/wrappedlibtinfo6undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibtinfo6UNDEFS_H_ +#define __wrappedlibtinfo6UNDEFS_H_ + + +#endif // __wrappedlibtinfo6UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibtinfodefs.h b/src/wrapped/generated/wrappedlibtinfodefs.h new file mode 100644 index 0000000000..918f6ca609 --- /dev/null +++ b/src/wrapped/generated/wrappedlibtinfodefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibtinfoDEFS_H_ +#define __wrappedlibtinfoDEFS_H_ + + +#endif // __wrappedlibtinfoDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibtinfotypes.h b/src/wrapped/generated/wrappedlibtinfotypes.h index 3ab7ecf55d..eec70908c3 100644 --- a/src/wrapped/generated/wrappedlibtinfotypes.h +++ b/src/wrapped/generated/wrappedlibtinfotypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibtinfoTYPES_H_ #define __wrappedlibtinfoTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibtinfoundefs.h b/src/wrapped/generated/wrappedlibtinfoundefs.h new file mode 100644 index 0000000000..9cbd47ebe2 --- /dev/null +++ b/src/wrapped/generated/wrappedlibtinfoundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibtinfoUNDEFS_H_ +#define __wrappedlibtinfoUNDEFS_H_ + + +#endif // __wrappedlibtinfoUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibusb1defs.h b/src/wrapped/generated/wrappedlibusb1defs.h new file mode 100644 index 0000000000..0b0f911eb9 --- /dev/null +++ b/src/wrapped/generated/wrappedlibusb1defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibusb1DEFS_H_ +#define __wrappedlibusb1DEFS_H_ + + +#endif // __wrappedlibusb1DEFS_H_ diff --git a/src/wrapped/generated/wrappedlibusb1types.h b/src/wrapped/generated/wrappedlibusb1types.h index 15761e08ab..aa71c7cbdb 100644 --- a/src/wrapped/generated/wrappedlibusb1types.h +++ b/src/wrapped/generated/wrappedlibusb1types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibusb1TYPES_H_ #define __wrappedlibusb1TYPES_H_ diff --git a/src/wrapped/generated/wrappedlibusb1undefs.h b/src/wrapped/generated/wrappedlibusb1undefs.h new file mode 100644 index 0000000000..6058106b80 --- /dev/null +++ b/src/wrapped/generated/wrappedlibusb1undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibusb1UNDEFS_H_ +#define __wrappedlibusb1UNDEFS_H_ + + +#endif // __wrappedlibusb1UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibuuiddefs.h b/src/wrapped/generated/wrappedlibuuiddefs.h new file mode 100644 index 0000000000..d555a690d1 --- /dev/null +++ b/src/wrapped/generated/wrappedlibuuiddefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibuuidDEFS_H_ +#define __wrappedlibuuidDEFS_H_ + + +#endif // __wrappedlibuuidDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibuuidtypes.h b/src/wrapped/generated/wrappedlibuuidtypes.h new file mode 100644 index 0000000000..a607ef32e4 --- /dev/null +++ b/src/wrapped/generated/wrappedlibuuidtypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibuuidTYPES_H_ +#define __wrappedlibuuidTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibuuidTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibuuidundefs.h b/src/wrapped/generated/wrappedlibuuidundefs.h new file mode 100644 index 0000000000..6c8e3e858e --- /dev/null +++ b/src/wrapped/generated/wrappedlibuuidundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibuuidUNDEFS_H_ +#define __wrappedlibuuidUNDEFS_H_ + + +#endif // __wrappedlibuuidUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibv4l2defs.h b/src/wrapped/generated/wrappedlibv4l2defs.h new file mode 100644 index 0000000000..15411c4931 --- /dev/null +++ b/src/wrapped/generated/wrappedlibv4l2defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibv4l2DEFS_H_ +#define __wrappedlibv4l2DEFS_H_ + + +#endif // __wrappedlibv4l2DEFS_H_ diff --git a/src/wrapped/generated/wrappedlibv4l2types.h b/src/wrapped/generated/wrappedlibv4l2types.h index 8ea1908800..343a093c2a 100644 --- a/src/wrapped/generated/wrappedlibv4l2types.h +++ b/src/wrapped/generated/wrappedlibv4l2types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibv4l2TYPES_H_ #define __wrappedlibv4l2TYPES_H_ diff --git a/src/wrapped/generated/wrappedlibv4l2undefs.h b/src/wrapped/generated/wrappedlibv4l2undefs.h new file mode 100644 index 0000000000..bd09dda21c --- /dev/null +++ b/src/wrapped/generated/wrappedlibv4l2undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibv4l2UNDEFS_H_ +#define __wrappedlibv4l2UNDEFS_H_ + + +#endif // __wrappedlibv4l2UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibvorbisdefs.h b/src/wrapped/generated/wrappedlibvorbisdefs.h new file mode 100644 index 0000000000..20a0b18fb4 --- /dev/null +++ b/src/wrapped/generated/wrappedlibvorbisdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibvorbisDEFS_H_ +#define __wrappedlibvorbisDEFS_H_ + + +#endif // __wrappedlibvorbisDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibvorbistypes.h b/src/wrapped/generated/wrappedlibvorbistypes.h index f45f0fbffe..fe2aae2045 100644 --- a/src/wrapped/generated/wrappedlibvorbistypes.h +++ b/src/wrapped/generated/wrappedlibvorbistypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibvorbisTYPES_H_ #define __wrappedlibvorbisTYPES_H_ @@ -35,6 +35,7 @@ typedef int32_t (*iFppppp_t)(void*, void*, void*, void*, void*); GO(vorbis_synthesis_init, iFpp_t) \ GO(vorbis_synthesis_lapout, iFpp_t) \ GO(vorbis_synthesis_pcmout, iFpp_t) \ + GO(vorbis_synthesis_trackonly, iFpp_t) \ GO(vorbis_analysis_buffer, pFpi_t) \ GO(vorbis_window, pFpi_t) \ GO(vorbis_analysis_headerout, iFppppp_t) diff --git a/src/wrapped/generated/wrappedlibvorbisundefs.h b/src/wrapped/generated/wrappedlibvorbisundefs.h new file mode 100644 index 0000000000..dffbec472b --- /dev/null +++ b/src/wrapped/generated/wrappedlibvorbisundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibvorbisUNDEFS_H_ +#define __wrappedlibvorbisUNDEFS_H_ + + +#endif // __wrappedlibvorbisUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibx11defs.h b/src/wrapped/generated/wrappedlibx11defs.h new file mode 100644 index 0000000000..3af24c74c3 --- /dev/null +++ b/src/wrapped/generated/wrappedlibx11defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibx11DEFS_H_ +#define __wrappedlibx11DEFS_H_ + + +#endif // __wrappedlibx11DEFS_H_ diff --git a/src/wrapped/generated/wrappedlibx11types.h b/src/wrapped/generated/wrappedlibx11types.h index 57cea9b461..60b078ef6f 100644 --- a/src/wrapped/generated/wrappedlibx11types.h +++ b/src/wrapped/generated/wrappedlibx11types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibx11TYPES_H_ #define __wrappedlibx11TYPES_H_ diff --git a/src/wrapped/generated/wrappedlibx11undefs.h b/src/wrapped/generated/wrappedlibx11undefs.h new file mode 100644 index 0000000000..bddbfc75fa --- /dev/null +++ b/src/wrapped/generated/wrappedlibx11undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibx11UNDEFS_H_ +#define __wrappedlibx11UNDEFS_H_ + + +#endif // __wrappedlibx11UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibx11xcbdefs.h b/src/wrapped/generated/wrappedlibx11xcbdefs.h new file mode 100644 index 0000000000..b624ef3a4b --- /dev/null +++ b/src/wrapped/generated/wrappedlibx11xcbdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibx11xcbDEFS_H_ +#define __wrappedlibx11xcbDEFS_H_ + + +#endif // __wrappedlibx11xcbDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibx11xcbtypes.h b/src/wrapped/generated/wrappedlibx11xcbtypes.h new file mode 100644 index 0000000000..494601bc94 --- /dev/null +++ b/src/wrapped/generated/wrappedlibx11xcbtypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibx11xcbTYPES_H_ +#define __wrappedlibx11xcbTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibx11xcbTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibx11xcbundefs.h b/src/wrapped/generated/wrappedlibx11xcbundefs.h new file mode 100644 index 0000000000..0aeaeb0f88 --- /dev/null +++ b/src/wrapped/generated/wrappedlibx11xcbundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibx11xcbUNDEFS_H_ +#define __wrappedlibx11xcbUNDEFS_H_ + + +#endif // __wrappedlibx11xcbUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxaudefs.h b/src/wrapped/generated/wrappedlibxaudefs.h new file mode 100644 index 0000000000..d0cd359c77 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxaudefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxauDEFS_H_ +#define __wrappedlibxauDEFS_H_ + + +#endif // __wrappedlibxauDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxautypes.h b/src/wrapped/generated/wrappedlibxautypes.h new file mode 100644 index 0000000000..8f685d041f --- /dev/null +++ b/src/wrapped/generated/wrappedlibxautypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxauTYPES_H_ +#define __wrappedlibxauTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibxauTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxauundefs.h b/src/wrapped/generated/wrappedlibxauundefs.h new file mode 100644 index 0000000000..7d045524c4 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxauundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxauUNDEFS_H_ +#define __wrappedlibxauUNDEFS_H_ + + +#endif // __wrappedlibxauUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbdefs.h b/src/wrapped/generated/wrappedlibxcbdefs.h new file mode 100644 index 0000000000..366dfc7a71 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbdefs.h @@ -0,0 +1,44 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbDEFS_H_ +#define __wrappedlibxcbDEFS_H_ + +#define XFEp pFEpp +#define xFEp pFEpp +#define xFEpC pFEppC +#define xFEpu pFEppu +#define xFEpp pFEppp +#define xFEpCC pFEppCC +#define xFEpup pFEppup +#define xFEppp pFEpppp +#define xFEpCWp pFEppCWp +#define xFEpCuW pFEppCuW +#define xFEpCuu pFEppCuu +#define xFEpuWp pFEppuWp +#define xFEpuuu pFEppuuu +#define xFEpuup pFEppuup +#define xFEpCuup pFEppCuup +#define xFEpCppp pFEppCppp +#define xFEpuWWW pFEppuWWW +#define xFEpuuWW pFEppuuWW +#define xFEpuuup pFEppuuup +#define xFEpCuuCC pFEppCuuCC +#define xFEpCuuWW pFEppCuuWW +#define xFEpCuuup pFEppCuuup +#define xFEpuuuuu pFEppuuuuu +#define xFEpCuwwWW pFEppCuwwWW +#define xFEpCuWCCC pFEppCuWCCC +#define xFEpCuuwwp pFEppCuuwwp +#define xFEpCuuuuu pFEppCuuuuu +#define xFEpCuwwWWu pFEppCuwwWWu +#define xFEpCuuuCup pFEppCuuuCup +#define xFEpCuWCCuuu pFEppCuWCCuuu +#define xFEpuuwwWWww pFEppuuwwWWww +#define xFEpCuWCCuuCW pFEppCuWCCuuCW +#define xFEpuuuwwwwWW pFEppuuuwwwwWW +#define xFEpCuuWWwwCCup pFEppCuuWWwwCCup +#define xFEpuuuWWWWWWWW pFEppuuuWWWWWWWW +#define xFEpCuuwwWWWWuup pFEppCuuwwWWWWuup + +#endif // __wrappedlibxcbDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbdri2defs.h b/src/wrapped/generated/wrappedlibxcbdri2defs.h new file mode 100644 index 0000000000..ed60243316 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbdri2defs.h @@ -0,0 +1,9 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbdri2DEFS_H_ +#define __wrappedlibxcbdri2DEFS_H_ + +#define xFEpuu pFEppuu + +#endif // __wrappedlibxcbdri2DEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbdri2types.h b/src/wrapped/generated/wrappedlibxcbdri2types.h index 36413651a2..5643238dd1 100644 --- a/src/wrapped/generated/wrappedlibxcbdri2types.h +++ b/src/wrapped/generated/wrappedlibxcbdri2types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibxcbdri2TYPES_H_ #define __wrappedlibxcbdri2TYPES_H_ @@ -11,11 +11,11 @@ #define ADDED_FUNCTIONS() #endif -typedef my_xcb_cookie_t (*XFpuu_t)(void*, uint32_t, uint32_t); +typedef my_xcb_cookie_t (*xFpuu_t)(void*, uint32_t, uint32_t); #define SUPER() ADDED_FUNCTIONS() \ - GO(xcb_dri2_authenticate, XFpuu_t) \ - GO(xcb_dri2_connect, XFpuu_t) \ - GO(xcb_dri2_query_version, XFpuu_t) + GO(xcb_dri2_authenticate, xFpuu_t) \ + GO(xcb_dri2_connect, xFpuu_t) \ + GO(xcb_dri2_query_version, xFpuu_t) #endif // __wrappedlibxcbdri2TYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxcbdri2undefs.h b/src/wrapped/generated/wrappedlibxcbdri2undefs.h new file mode 100644 index 0000000000..c5f5adac0e --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbdri2undefs.h @@ -0,0 +1,9 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbdri2UNDEFS_H_ +#define __wrappedlibxcbdri2UNDEFS_H_ + +#undef xFEpuu + +#endif // __wrappedlibxcbdri2UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbdri3defs.h b/src/wrapped/generated/wrappedlibxcbdri3defs.h new file mode 100644 index 0000000000..013fad8f7c --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbdri3defs.h @@ -0,0 +1,10 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbdri3DEFS_H_ +#define __wrappedlibxcbdri3DEFS_H_ + +#define xFEpuu pFEppuu +#define xFEpuuuWWWCCi pFEppuuuWWWCCi + +#endif // __wrappedlibxcbdri3DEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbdri3types.h b/src/wrapped/generated/wrappedlibxcbdri3types.h index 2bdf6e985b..5584831154 100644 --- a/src/wrapped/generated/wrappedlibxcbdri3types.h +++ b/src/wrapped/generated/wrappedlibxcbdri3types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibxcbdri3TYPES_H_ #define __wrappedlibxcbdri3TYPES_H_ @@ -11,12 +11,12 @@ #define ADDED_FUNCTIONS() #endif -typedef my_xcb_cookie_t (*XFpuu_t)(void*, uint32_t, uint32_t); -typedef my_xcb_cookie_t (*XFpuuuWWWCCi_t)(void*, uint32_t, uint32_t, uint32_t, uint16_t, uint16_t, uint16_t, uint8_t, uint8_t, int32_t); +typedef my_xcb_cookie_t (*xFpuu_t)(void*, uint32_t, uint32_t); +typedef my_xcb_cookie_t (*xFpuuuWWWCCi_t)(void*, uint32_t, uint32_t, uint32_t, uint16_t, uint16_t, uint16_t, uint8_t, uint8_t, int32_t); #define SUPER() ADDED_FUNCTIONS() \ - GO(xcb_dri3_open, XFpuu_t) \ - GO(xcb_dri3_query_version, XFpuu_t) \ - GO(xcb_dri3_pixmap_from_buffer_checked, XFpuuuWWWCCi_t) + GO(xcb_dri3_open, xFpuu_t) \ + GO(xcb_dri3_query_version, xFpuu_t) \ + GO(xcb_dri3_pixmap_from_buffer_checked, xFpuuuWWWCCi_t) #endif // __wrappedlibxcbdri3TYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxcbdri3undefs.h b/src/wrapped/generated/wrappedlibxcbdri3undefs.h new file mode 100644 index 0000000000..934cb8d8e3 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbdri3undefs.h @@ -0,0 +1,10 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbdri3UNDEFS_H_ +#define __wrappedlibxcbdri3UNDEFS_H_ + +#undef xFEpuu +#undef xFEpuuuWWWCCi + +#endif // __wrappedlibxcbdri3UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbimagedefs.h b/src/wrapped/generated/wrappedlibxcbimagedefs.h new file mode 100644 index 0000000000..b31ca86e74 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbimagedefs.h @@ -0,0 +1,9 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbimageDEFS_H_ +#define __wrappedlibxcbimageDEFS_H_ + +#define xFEpuupwwC pFEppuupwwC + +#endif // __wrappedlibxcbimageDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbimagetypes.h b/src/wrapped/generated/wrappedlibxcbimagetypes.h index dfbbff0c84..b4167f44b5 100644 --- a/src/wrapped/generated/wrappedlibxcbimagetypes.h +++ b/src/wrapped/generated/wrappedlibxcbimagetypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibxcbimageTYPES_H_ #define __wrappedlibxcbimageTYPES_H_ @@ -11,9 +11,9 @@ #define ADDED_FUNCTIONS() #endif -typedef my_xcb_cookie_t (*XFpuupwwC_t)(void*, uint32_t, uint32_t, void*, int16_t, int16_t, uint8_t); +typedef my_xcb_cookie_t (*xFpuupwwC_t)(void*, uint32_t, uint32_t, void*, int16_t, int16_t, uint8_t); #define SUPER() ADDED_FUNCTIONS() \ - GO(xcb_image_put, XFpuupwwC_t) + GO(xcb_image_put, xFpuupwwC_t) #endif // __wrappedlibxcbimageTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxcbimageundefs.h b/src/wrapped/generated/wrappedlibxcbimageundefs.h new file mode 100644 index 0000000000..54fadcc43e --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbimageundefs.h @@ -0,0 +1,9 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbimageUNDEFS_H_ +#define __wrappedlibxcbimageUNDEFS_H_ + +#undef xFEpuupwwC + +#endif // __wrappedlibxcbimageUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbkeysymsdefs.h b/src/wrapped/generated/wrappedlibxcbkeysymsdefs.h new file mode 100644 index 0000000000..42c425f518 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbkeysymsdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbkeysymsDEFS_H_ +#define __wrappedlibxcbkeysymsDEFS_H_ + + +#endif // __wrappedlibxcbkeysymsDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbkeysymstypes.h b/src/wrapped/generated/wrappedlibxcbkeysymstypes.h new file mode 100644 index 0000000000..09377e57a7 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbkeysymstypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbkeysymsTYPES_H_ +#define __wrappedlibxcbkeysymsTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibxcbkeysymsTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxcbkeysymsundefs.h b/src/wrapped/generated/wrappedlibxcbkeysymsundefs.h new file mode 100644 index 0000000000..d27532f232 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbkeysymsundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbkeysymsUNDEFS_H_ +#define __wrappedlibxcbkeysymsUNDEFS_H_ + + +#endif // __wrappedlibxcbkeysymsUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbpresentdefs.h b/src/wrapped/generated/wrappedlibxcbpresentdefs.h new file mode 100644 index 0000000000..a425febf6b --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbpresentdefs.h @@ -0,0 +1,12 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbpresentDEFS_H_ +#define __wrappedlibxcbpresentDEFS_H_ + +#define xFEpuu pFEppuu +#define xFEpuuu pFEppuuu +#define xFEpuuUUU pFEppuuUUU +#define xFEpuuuuuwwuuuuUUUup pFEppuuuuuwwuuuuUUUup + +#endif // __wrappedlibxcbpresentDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbpresenttypes.h b/src/wrapped/generated/wrappedlibxcbpresenttypes.h index 75f9f2c631..9b62a468bc 100644 --- a/src/wrapped/generated/wrappedlibxcbpresenttypes.h +++ b/src/wrapped/generated/wrappedlibxcbpresenttypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibxcbpresentTYPES_H_ #define __wrappedlibxcbpresentTYPES_H_ @@ -11,16 +11,16 @@ #define ADDED_FUNCTIONS() #endif -typedef my_xcb_cookie_t (*XFpuu_t)(void*, uint32_t, uint32_t); -typedef my_xcb_cookie_t (*XFpuuu_t)(void*, uint32_t, uint32_t, uint32_t); -typedef my_xcb_cookie_t (*XFpuuUUU_t)(void*, uint32_t, uint32_t, uint64_t, uint64_t, uint64_t); -typedef my_xcb_cookie_t (*XFpuuuuuwwuuuuUUUup_t)(void*, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, int16_t, int16_t, uint32_t, uint32_t, uint32_t, uint32_t, uint64_t, uint64_t, uint64_t, uint32_t, void*); +typedef my_xcb_cookie_t (*xFpuu_t)(void*, uint32_t, uint32_t); +typedef my_xcb_cookie_t (*xFpuuu_t)(void*, uint32_t, uint32_t, uint32_t); +typedef my_xcb_cookie_t (*xFpuuUUU_t)(void*, uint32_t, uint32_t, uint64_t, uint64_t, uint64_t); +typedef my_xcb_cookie_t (*xFpuuuuuwwuuuuUUUup_t)(void*, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, int16_t, int16_t, uint32_t, uint32_t, uint32_t, uint32_t, uint64_t, uint64_t, uint64_t, uint32_t, void*); #define SUPER() ADDED_FUNCTIONS() \ - GO(xcb_present_query_version, XFpuu_t) \ - GO(xcb_present_select_input_checked, XFpuuu_t) \ - GO(xcb_present_notify_msc, XFpuuUUU_t) \ - GO(xcb_present_pixmap, XFpuuuuuwwuuuuUUUup_t) \ - GO(xcb_present_pixmap_checked, XFpuuuuuwwuuuuUUUup_t) + GO(xcb_present_query_version, xFpuu_t) \ + GO(xcb_present_select_input_checked, xFpuuu_t) \ + GO(xcb_present_notify_msc, xFpuuUUU_t) \ + GO(xcb_present_pixmap, xFpuuuuuwwuuuuUUUup_t) \ + GO(xcb_present_pixmap_checked, xFpuuuuuwwuuuuUUUup_t) #endif // __wrappedlibxcbpresentTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxcbpresentundefs.h b/src/wrapped/generated/wrappedlibxcbpresentundefs.h new file mode 100644 index 0000000000..15a1af8452 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbpresentundefs.h @@ -0,0 +1,12 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbpresentUNDEFS_H_ +#define __wrappedlibxcbpresentUNDEFS_H_ + +#undef xFEpuu +#undef xFEpuuu +#undef xFEpuuUUU +#undef xFEpuuuuuwwuuuuUUUup + +#endif // __wrappedlibxcbpresentUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbrandrdefs.h b/src/wrapped/generated/wrappedlibxcbrandrdefs.h new file mode 100644 index 0000000000..aa4adc81fc --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbrandrdefs.h @@ -0,0 +1,13 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbrandrDEFS_H_ +#define __wrappedlibxcbrandrDEFS_H_ + +#define XFEp pFEpp +#define xFEpu pFEppu +#define xFEpuu pFEppuu +#define xFEpuW pFEppuW +#define xFEppu pFEpppu + +#endif // __wrappedlibxcbrandrDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbrandrtypes.h b/src/wrapped/generated/wrappedlibxcbrandrtypes.h index 0e6e2ec2d0..bad7a13a75 100644 --- a/src/wrapped/generated/wrappedlibxcbrandrtypes.h +++ b/src/wrapped/generated/wrappedlibxcbrandrtypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibxcbrandrTYPES_H_ #define __wrappedlibxcbrandrTYPES_H_ @@ -11,27 +11,27 @@ #define ADDED_FUNCTIONS() #endif -typedef my_xcb_iterator_t (*TFp_t)(void*); -typedef my_xcb_cookie_t (*XFpu_t)(void*, uint32_t); -typedef my_xcb_cookie_t (*XFpuW_t)(void*, uint32_t, uint16_t); -typedef my_xcb_cookie_t (*XFpuu_t)(void*, uint32_t, uint32_t); -typedef my_xcb_cookie_t (*XFppu_t)(void*, void*, uint32_t); +typedef my_xcb_XXX_iterator_t (*XFp_t)(void*); +typedef my_xcb_cookie_t (*xFpu_t)(void*, uint32_t); +typedef my_xcb_cookie_t (*xFpuW_t)(void*, uint32_t, uint16_t); +typedef my_xcb_cookie_t (*xFpuu_t)(void*, uint32_t, uint32_t); +typedef my_xcb_cookie_t (*xFppu_t)(void*, void*, uint32_t); #define SUPER() ADDED_FUNCTIONS() \ - GO(xcb_randr_get_screen_resources_current_outputs_end, TFp_t) \ - GO(xcb_randr_get_output_primary, XFpu_t) \ - GO(xcb_randr_get_output_primary_unchecked, XFpu_t) \ - GO(xcb_randr_get_screen_resources, XFpu_t) \ - GO(xcb_randr_get_screen_resources_current, XFpu_t) \ - GO(xcb_randr_get_screen_resources_outputs, XFpu_t) \ - GO(xcb_randr_get_screen_resources_unchecked, XFpu_t) \ - GO(xcb_randr_select_input, XFpuW_t) \ - GO(xcb_randr_select_input_checked, XFpuW_t) \ - GO(xcb_randr_query_version, XFpuu_t) \ - GO(xcb_randr_query_version_unchecked, XFpuu_t) \ - GO(xcb_randr_get_crtc_info, XFppu_t) \ - GO(xcb_randr_get_crtc_info_unchecked, XFppu_t) \ - GO(xcb_randr_get_output_info, XFppu_t) \ - GO(xcb_randr_get_output_info_unchecked, XFppu_t) + GO(xcb_randr_get_screen_resources_current_outputs_end, XFp_t) \ + GO(xcb_randr_get_output_primary, xFpu_t) \ + GO(xcb_randr_get_output_primary_unchecked, xFpu_t) \ + GO(xcb_randr_get_screen_resources, xFpu_t) \ + GO(xcb_randr_get_screen_resources_current, xFpu_t) \ + GO(xcb_randr_get_screen_resources_outputs, xFpu_t) \ + GO(xcb_randr_get_screen_resources_unchecked, xFpu_t) \ + GO(xcb_randr_select_input, xFpuW_t) \ + GO(xcb_randr_select_input_checked, xFpuW_t) \ + GO(xcb_randr_query_version, xFpuu_t) \ + GO(xcb_randr_query_version_unchecked, xFpuu_t) \ + GO(xcb_randr_get_crtc_info, xFppu_t) \ + GO(xcb_randr_get_crtc_info_unchecked, xFppu_t) \ + GO(xcb_randr_get_output_info, xFppu_t) \ + GO(xcb_randr_get_output_info_unchecked, xFppu_t) #endif // __wrappedlibxcbrandrTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxcbrandrundefs.h b/src/wrapped/generated/wrappedlibxcbrandrundefs.h new file mode 100644 index 0000000000..98c3a80bc4 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbrandrundefs.h @@ -0,0 +1,13 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbrandrUNDEFS_H_ +#define __wrappedlibxcbrandrUNDEFS_H_ + +#undef XFEp +#undef xFEpu +#undef xFEpuu +#undef xFEpuW +#undef xFEppu + +#endif // __wrappedlibxcbrandrUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbshapedefs.h b/src/wrapped/generated/wrappedlibxcbshapedefs.h new file mode 100644 index 0000000000..034705e75d --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbshapedefs.h @@ -0,0 +1,9 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbshapeDEFS_H_ +#define __wrappedlibxcbshapeDEFS_H_ + +#define xFEpuuuwwu pFEppuuuwwu + +#endif // __wrappedlibxcbshapeDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbshapetypes.h b/src/wrapped/generated/wrappedlibxcbshapetypes.h index 9e2d55e623..c2399c5a42 100644 --- a/src/wrapped/generated/wrappedlibxcbshapetypes.h +++ b/src/wrapped/generated/wrappedlibxcbshapetypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibxcbshapeTYPES_H_ #define __wrappedlibxcbshapeTYPES_H_ @@ -11,10 +11,10 @@ #define ADDED_FUNCTIONS() #endif -typedef my_xcb_cookie_t (*XFpuuuwwu_t)(void*, uint32_t, uint32_t, uint32_t, int16_t, int16_t, uint32_t); +typedef my_xcb_cookie_t (*xFpuuuwwu_t)(void*, uint32_t, uint32_t, uint32_t, int16_t, int16_t, uint32_t); #define SUPER() ADDED_FUNCTIONS() \ - GO(xcb_shape_mask, XFpuuuwwu_t) \ - GO(xcb_shape_mask_checked, XFpuuuwwu_t) + GO(xcb_shape_mask, xFpuuuwwu_t) \ + GO(xcb_shape_mask_checked, xFpuuuwwu_t) #endif // __wrappedlibxcbshapeTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxcbshapeundefs.h b/src/wrapped/generated/wrappedlibxcbshapeundefs.h new file mode 100644 index 0000000000..013b9c82f3 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbshapeundefs.h @@ -0,0 +1,9 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbshapeUNDEFS_H_ +#define __wrappedlibxcbshapeUNDEFS_H_ + +#undef xFEpuuuwwu + +#endif // __wrappedlibxcbshapeUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbshmdefs.h b/src/wrapped/generated/wrappedlibxcbshmdefs.h new file mode 100644 index 0000000000..0780c4927b --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbshmdefs.h @@ -0,0 +1,15 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbshmDEFS_H_ +#define __wrappedlibxcbshmDEFS_H_ + +#define XFEX pFEppii +#define xFEp pFEpp +#define xFEpu pFEppu +#define xFEpuuC pFEppuuC +#define xFEpuuWWCuu pFEppuuWWCuu +#define xFEpuwwWWuCuu pFEppuwwWWuCuu +#define xFEpuuWWWWWWwwCCCuu pFEppuuWWWWWWwwCCCuu + +#endif // __wrappedlibxcbshmDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbshmtypes.h b/src/wrapped/generated/wrappedlibxcbshmtypes.h index 1bd1c095a3..99da881797 100644 --- a/src/wrapped/generated/wrappedlibxcbshmtypes.h +++ b/src/wrapped/generated/wrappedlibxcbshmtypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibxcbshmTYPES_H_ #define __wrappedlibxcbshmTYPES_H_ @@ -11,31 +11,31 @@ #define ADDED_FUNCTIONS() #endif -typedef my_xcb_cookie_t (*XFp_t)(void*); -typedef my_xcb_iterator_t (*TFT_t)(my_xcb_iterator_t); -typedef my_xcb_cookie_t (*XFpu_t)(void*, uint32_t); -typedef my_xcb_cookie_t (*XFpuuC_t)(void*, uint32_t, uint32_t, uint8_t); -typedef my_xcb_cookie_t (*XFpuuWWCuu_t)(void*, uint32_t, uint32_t, uint16_t, uint16_t, uint8_t, uint32_t, uint32_t); -typedef my_xcb_cookie_t (*XFpuwwWWuCuu_t)(void*, uint32_t, int16_t, int16_t, uint16_t, uint16_t, uint32_t, uint8_t, uint32_t, uint32_t); -typedef my_xcb_cookie_t (*XFpuuWWWWWWwwCCCuu_t)(void*, uint32_t, uint32_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, int16_t, int16_t, uint8_t, uint8_t, uint8_t, uint32_t, uint32_t); +typedef my_xcb_cookie_t (*xFp_t)(void*); +typedef my_xcb_iterator_t (*XFX_t)(my_xcb_iterator_t); +typedef my_xcb_cookie_t (*xFpu_t)(void*, uint32_t); +typedef my_xcb_cookie_t (*xFpuuC_t)(void*, uint32_t, uint32_t, uint8_t); +typedef my_xcb_cookie_t (*xFpuuWWCuu_t)(void*, uint32_t, uint32_t, uint16_t, uint16_t, uint8_t, uint32_t, uint32_t); +typedef my_xcb_cookie_t (*xFpuwwWWuCuu_t)(void*, uint32_t, int16_t, int16_t, uint16_t, uint16_t, uint32_t, uint8_t, uint32_t, uint32_t); +typedef my_xcb_cookie_t (*xFpuuWWWWWWwwCCCuu_t)(void*, uint32_t, uint32_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, int16_t, int16_t, uint8_t, uint8_t, uint8_t, uint32_t, uint32_t); #define SUPER() ADDED_FUNCTIONS() \ - GO(xcb_shm_query_version, XFp_t) \ - GO(xcb_shm_query_version_unchecked, XFp_t) \ - GO(xcb_shm_seg_end, TFT_t) \ - GO(xcb_shm_detach, XFpu_t) \ - GO(xcb_shm_detach_checked, XFpu_t) \ - GO(xcb_shm_attach, XFpuuC_t) \ - GO(xcb_shm_attach_checked, XFpuuC_t) \ - GO(xcb_shm_attach_fd, XFpuuC_t) \ - GO(xcb_shm_attach_fd_checked, XFpuuC_t) \ - GO(xcb_shm_create_segment, XFpuuC_t) \ - GO(xcb_shm_create_segment_unchecked, XFpuuC_t) \ - GO(xcb_shm_create_pixmap, XFpuuWWCuu_t) \ - GO(xcb_shm_create_pixmap_checked, XFpuuWWCuu_t) \ - GO(xcb_shm_get_image, XFpuwwWWuCuu_t) \ - GO(xcb_shm_get_image_unchecked, XFpuwwWWuCuu_t) \ - GO(xcb_shm_put_image, XFpuuWWWWWWwwCCCuu_t) \ - GO(xcb_shm_put_image_checked, XFpuuWWWWWWwwCCCuu_t) + GO(xcb_shm_query_version, xFp_t) \ + GO(xcb_shm_query_version_unchecked, xFp_t) \ + GO(xcb_shm_seg_end, XFX_t) \ + GO(xcb_shm_detach, xFpu_t) \ + GO(xcb_shm_detach_checked, xFpu_t) \ + GO(xcb_shm_attach, xFpuuC_t) \ + GO(xcb_shm_attach_checked, xFpuuC_t) \ + GO(xcb_shm_attach_fd, xFpuuC_t) \ + GO(xcb_shm_attach_fd_checked, xFpuuC_t) \ + GO(xcb_shm_create_segment, xFpuuC_t) \ + GO(xcb_shm_create_segment_unchecked, xFpuuC_t) \ + GO(xcb_shm_create_pixmap, xFpuuWWCuu_t) \ + GO(xcb_shm_create_pixmap_checked, xFpuuWWCuu_t) \ + GO(xcb_shm_get_image, xFpuwwWWuCuu_t) \ + GO(xcb_shm_get_image_unchecked, xFpuwwWWuCuu_t) \ + GO(xcb_shm_put_image, xFpuuWWWWWWwwCCCuu_t) \ + GO(xcb_shm_put_image_checked, xFpuuWWWWWWwwCCCuu_t) #endif // __wrappedlibxcbshmTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxcbshmundefs.h b/src/wrapped/generated/wrappedlibxcbshmundefs.h new file mode 100644 index 0000000000..9d7d2530b5 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbshmundefs.h @@ -0,0 +1,15 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbshmUNDEFS_H_ +#define __wrappedlibxcbshmUNDEFS_H_ + +#undef XFEX +#undef xFEp +#undef xFEpu +#undef xFEpuuC +#undef xFEpuuWWCuu +#undef xFEpuwwWWuCuu +#undef xFEpuuWWWWWWwwCCCuu + +#endif // __wrappedlibxcbshmUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbtypes.h b/src/wrapped/generated/wrappedlibxcbtypes.h index 1c6eedb2fb..cdb780eb50 100644 --- a/src/wrapped/generated/wrappedlibxcbtypes.h +++ b/src/wrapped/generated/wrappedlibxcbtypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibxcbTYPES_H_ #define __wrappedlibxcbTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxcbundefs.h b/src/wrapped/generated/wrappedlibxcbundefs.h new file mode 100644 index 0000000000..4c8f2694f0 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbundefs.h @@ -0,0 +1,44 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbUNDEFS_H_ +#define __wrappedlibxcbUNDEFS_H_ + +#undef XFEp +#undef xFEp +#undef xFEpC +#undef xFEpu +#undef xFEpp +#undef xFEpCC +#undef xFEpup +#undef xFEppp +#undef xFEpCWp +#undef xFEpCuW +#undef xFEpCuu +#undef xFEpuWp +#undef xFEpuuu +#undef xFEpuup +#undef xFEpCuup +#undef xFEpCppp +#undef xFEpuWWW +#undef xFEpuuWW +#undef xFEpuuup +#undef xFEpCuuCC +#undef xFEpCuuWW +#undef xFEpCuuup +#undef xFEpuuuuu +#undef xFEpCuwwWW +#undef xFEpCuWCCC +#undef xFEpCuuwwp +#undef xFEpCuuuuu +#undef xFEpCuwwWWu +#undef xFEpCuuuCup +#undef xFEpCuWCCuuu +#undef xFEpuuwwWWww +#undef xFEpCuWCCuuCW +#undef xFEpuuuwwwwWW +#undef xFEpCuuWWwwCCup +#undef xFEpuuuWWWWWWWW +#undef xFEpCuuwwWWWWuup + +#endif // __wrappedlibxcbUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbxfixesdefs.h b/src/wrapped/generated/wrappedlibxcbxfixesdefs.h new file mode 100644 index 0000000000..1326da9d0b --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbxfixesdefs.h @@ -0,0 +1,12 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbxfixesDEFS_H_ +#define __wrappedlibxcbxfixesDEFS_H_ + +#define xFEpu pFEppu +#define xFEpuu pFEppuu +#define xFEpuup pFEppuup +#define xFEpuuwwu pFEppuuwwu + +#endif // __wrappedlibxcbxfixesDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbxfixestypes.h b/src/wrapped/generated/wrappedlibxcbxfixestypes.h index 3da700c31d..3c05aacaa1 100644 --- a/src/wrapped/generated/wrappedlibxcbxfixestypes.h +++ b/src/wrapped/generated/wrappedlibxcbxfixestypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibxcbxfixesTYPES_H_ #define __wrappedlibxcbxfixesTYPES_H_ @@ -11,16 +11,16 @@ #define ADDED_FUNCTIONS() #endif -typedef my_xcb_cookie_t (*XFpu_t)(void*, uint32_t); -typedef my_xcb_cookie_t (*XFpuu_t)(void*, uint32_t, uint32_t); -typedef my_xcb_cookie_t (*XFpuup_t)(void*, uint32_t, uint32_t, void*); -typedef my_xcb_cookie_t (*XFpuuwwu_t)(void*, uint32_t, uint32_t, int16_t, int16_t, uint32_t); +typedef my_xcb_cookie_t (*xFpu_t)(void*, uint32_t); +typedef my_xcb_cookie_t (*xFpuu_t)(void*, uint32_t, uint32_t); +typedef my_xcb_cookie_t (*xFpuup_t)(void*, uint32_t, uint32_t, void*); +typedef my_xcb_cookie_t (*xFpuuwwu_t)(void*, uint32_t, uint32_t, int16_t, int16_t, uint32_t); #define SUPER() ADDED_FUNCTIONS() \ - GO(xcb_xfixes_destroy_region, XFpu_t) \ - GO(xcb_xfixes_query_version_unchecked, XFpuu_t) \ - GO(xcb_xfixes_create_region, XFpuup_t) \ - GO(xcb_xfixes_set_window_shape_region, XFpuuwwu_t) \ - GO(xcb_xfixes_set_window_shape_region_checked, XFpuuwwu_t) + GO(xcb_xfixes_destroy_region, xFpu_t) \ + GO(xcb_xfixes_query_version_unchecked, xFpuu_t) \ + GO(xcb_xfixes_create_region, xFpuup_t) \ + GO(xcb_xfixes_set_window_shape_region, xFpuuwwu_t) \ + GO(xcb_xfixes_set_window_shape_region_checked, xFpuuwwu_t) #endif // __wrappedlibxcbxfixesTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxcbxfixesundefs.h b/src/wrapped/generated/wrappedlibxcbxfixesundefs.h new file mode 100644 index 0000000000..24343d07d3 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbxfixesundefs.h @@ -0,0 +1,12 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbxfixesUNDEFS_H_ +#define __wrappedlibxcbxfixesUNDEFS_H_ + +#undef xFEpu +#undef xFEpuu +#undef xFEpuup +#undef xFEpuuwwu + +#endif // __wrappedlibxcbxfixesUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbxtestdefs.h b/src/wrapped/generated/wrappedlibxcbxtestdefs.h new file mode 100644 index 0000000000..71cafa7edc --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbxtestdefs.h @@ -0,0 +1,9 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbxtestDEFS_H_ +#define __wrappedlibxcbxtestDEFS_H_ + +#define xFEpCCuuwwC pFEppCCuuwwC + +#endif // __wrappedlibxcbxtestDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcbxtesttypes.h b/src/wrapped/generated/wrappedlibxcbxtesttypes.h index 1b55860d6e..28d48cef29 100644 --- a/src/wrapped/generated/wrappedlibxcbxtesttypes.h +++ b/src/wrapped/generated/wrappedlibxcbxtesttypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibxcbxtestTYPES_H_ #define __wrappedlibxcbxtestTYPES_H_ @@ -11,10 +11,10 @@ #define ADDED_FUNCTIONS() #endif -typedef my_xcb_cookie_t (*XFpCCuuwwC_t)(void*, uint8_t, uint8_t, uint32_t, uint32_t, int16_t, int16_t, uint8_t); +typedef my_xcb_cookie_t (*xFpCCuuwwC_t)(void*, uint8_t, uint8_t, uint32_t, uint32_t, int16_t, int16_t, uint8_t); #define SUPER() ADDED_FUNCTIONS() \ - GO(xcb_test_fake_input, XFpCCuuwwC_t) \ - GO(xcb_test_fake_input_checked, XFpCCuuwwC_t) + GO(xcb_test_fake_input, xFpCCuuwwC_t) \ + GO(xcb_test_fake_input_checked, xFpCCuuwwC_t) #endif // __wrappedlibxcbxtestTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxcbxtestundefs.h b/src/wrapped/generated/wrappedlibxcbxtestundefs.h new file mode 100644 index 0000000000..52cdbb3f5c --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcbxtestundefs.h @@ -0,0 +1,9 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcbxtestUNDEFS_H_ +#define __wrappedlibxcbxtestUNDEFS_H_ + +#undef xFEpCCuuwwC + +#endif // __wrappedlibxcbxtestUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcompositedefs.h b/src/wrapped/generated/wrappedlibxcompositedefs.h new file mode 100644 index 0000000000..eb7c1db4a0 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcompositedefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcompositeDEFS_H_ +#define __wrappedlibxcompositeDEFS_H_ + + +#endif // __wrappedlibxcompositeDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcompositetypes.h b/src/wrapped/generated/wrappedlibxcompositetypes.h new file mode 100644 index 0000000000..362100aa8d --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcompositetypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcompositeTYPES_H_ +#define __wrappedlibxcompositeTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibxcompositeTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxcompositeundefs.h b/src/wrapped/generated/wrappedlibxcompositeundefs.h new file mode 100644 index 0000000000..165ee5291d --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcompositeundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcompositeUNDEFS_H_ +#define __wrappedlibxcompositeUNDEFS_H_ + + +#endif // __wrappedlibxcompositeUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcursordefs.h b/src/wrapped/generated/wrappedlibxcursordefs.h new file mode 100644 index 0000000000..6b3b5e1417 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcursordefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcursorDEFS_H_ +#define __wrappedlibxcursorDEFS_H_ + + +#endif // __wrappedlibxcursorDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxcursortypes.h b/src/wrapped/generated/wrappedlibxcursortypes.h new file mode 100644 index 0000000000..b453ac0a44 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcursortypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcursorTYPES_H_ +#define __wrappedlibxcursorTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibxcursorTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxcursorundefs.h b/src/wrapped/generated/wrappedlibxcursorundefs.h new file mode 100644 index 0000000000..bcf740a529 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxcursorundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxcursorUNDEFS_H_ +#define __wrappedlibxcursorUNDEFS_H_ + + +#endif // __wrappedlibxcursorUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxdamagedefs.h b/src/wrapped/generated/wrappedlibxdamagedefs.h new file mode 100644 index 0000000000..cd0a20ba4c --- /dev/null +++ b/src/wrapped/generated/wrappedlibxdamagedefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxdamageDEFS_H_ +#define __wrappedlibxdamageDEFS_H_ + + +#endif // __wrappedlibxdamageDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxdamagetypes.h b/src/wrapped/generated/wrappedlibxdamagetypes.h new file mode 100644 index 0000000000..8c4af62442 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxdamagetypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxdamageTYPES_H_ +#define __wrappedlibxdamageTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibxdamageTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxdamageundefs.h b/src/wrapped/generated/wrappedlibxdamageundefs.h new file mode 100644 index 0000000000..eed98c5cab --- /dev/null +++ b/src/wrapped/generated/wrappedlibxdamageundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxdamageUNDEFS_H_ +#define __wrappedlibxdamageUNDEFS_H_ + + +#endif // __wrappedlibxdamageUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxdmcpdefs.h b/src/wrapped/generated/wrappedlibxdmcpdefs.h new file mode 100644 index 0000000000..88a4f65fbe --- /dev/null +++ b/src/wrapped/generated/wrappedlibxdmcpdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxdmcpDEFS_H_ +#define __wrappedlibxdmcpDEFS_H_ + + +#endif // __wrappedlibxdmcpDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxdmcptypes.h b/src/wrapped/generated/wrappedlibxdmcptypes.h new file mode 100644 index 0000000000..2e8b12fdfb --- /dev/null +++ b/src/wrapped/generated/wrappedlibxdmcptypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxdmcpTYPES_H_ +#define __wrappedlibxdmcpTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibxdmcpTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxdmcpundefs.h b/src/wrapped/generated/wrappedlibxdmcpundefs.h new file mode 100644 index 0000000000..21e36ab0f7 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxdmcpundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxdmcpUNDEFS_H_ +#define __wrappedlibxdmcpUNDEFS_H_ + + +#endif // __wrappedlibxdmcpUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxextdefs.h b/src/wrapped/generated/wrappedlibxextdefs.h new file mode 100644 index 0000000000..032ddd4f34 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxextdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxextDEFS_H_ +#define __wrappedlibxextDEFS_H_ + + +#endif // __wrappedlibxextDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxexttypes.h b/src/wrapped/generated/wrappedlibxexttypes.h index ae02b2ac2c..680f384085 100644 --- a/src/wrapped/generated/wrappedlibxexttypes.h +++ b/src/wrapped/generated/wrappedlibxexttypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibxextTYPES_H_ #define __wrappedlibxextTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxextundefs.h b/src/wrapped/generated/wrappedlibxextundefs.h new file mode 100644 index 0000000000..c6d1b05ecc --- /dev/null +++ b/src/wrapped/generated/wrappedlibxextundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxextUNDEFS_H_ +#define __wrappedlibxextUNDEFS_H_ + + +#endif // __wrappedlibxextUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxfixesdefs.h b/src/wrapped/generated/wrappedlibxfixesdefs.h new file mode 100644 index 0000000000..96509f12a1 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxfixesdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxfixesDEFS_H_ +#define __wrappedlibxfixesDEFS_H_ + + +#endif // __wrappedlibxfixesDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxfixestypes.h b/src/wrapped/generated/wrappedlibxfixestypes.h new file mode 100644 index 0000000000..24a682a60e --- /dev/null +++ b/src/wrapped/generated/wrappedlibxfixestypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxfixesTYPES_H_ +#define __wrappedlibxfixesTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibxfixesTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxfixesundefs.h b/src/wrapped/generated/wrappedlibxfixesundefs.h new file mode 100644 index 0000000000..e58022b21c --- /dev/null +++ b/src/wrapped/generated/wrappedlibxfixesundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxfixesUNDEFS_H_ +#define __wrappedlibxfixesUNDEFS_H_ + + +#endif // __wrappedlibxfixesUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxftdefs.h b/src/wrapped/generated/wrappedlibxftdefs.h new file mode 100644 index 0000000000..d35344e1de --- /dev/null +++ b/src/wrapped/generated/wrappedlibxftdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxftDEFS_H_ +#define __wrappedlibxftDEFS_H_ + + +#endif // __wrappedlibxftDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxfttypes.h b/src/wrapped/generated/wrappedlibxfttypes.h new file mode 100644 index 0000000000..117cc02836 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxfttypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxftTYPES_H_ +#define __wrappedlibxftTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibxftTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxftundefs.h b/src/wrapped/generated/wrappedlibxftundefs.h new file mode 100644 index 0000000000..49b3c53fca --- /dev/null +++ b/src/wrapped/generated/wrappedlibxftundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxftUNDEFS_H_ +#define __wrappedlibxftUNDEFS_H_ + + +#endif // __wrappedlibxftUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxidefs.h b/src/wrapped/generated/wrappedlibxidefs.h new file mode 100644 index 0000000000..c940afe9ab --- /dev/null +++ b/src/wrapped/generated/wrappedlibxidefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxiDEFS_H_ +#define __wrappedlibxiDEFS_H_ + + +#endif // __wrappedlibxiDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxitypes.h b/src/wrapped/generated/wrappedlibxitypes.h new file mode 100644 index 0000000000..709898be54 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxitypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxiTYPES_H_ +#define __wrappedlibxiTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibxiTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxiundefs.h b/src/wrapped/generated/wrappedlibxiundefs.h new file mode 100644 index 0000000000..0661ebccfb --- /dev/null +++ b/src/wrapped/generated/wrappedlibxiundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxiUNDEFS_H_ +#define __wrappedlibxiUNDEFS_H_ + + +#endif // __wrappedlibxiUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxmudefs.h b/src/wrapped/generated/wrappedlibxmudefs.h new file mode 100644 index 0000000000..e0b12b8a5e --- /dev/null +++ b/src/wrapped/generated/wrappedlibxmudefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxmuDEFS_H_ +#define __wrappedlibxmuDEFS_H_ + + +#endif // __wrappedlibxmuDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxmutypes.h b/src/wrapped/generated/wrappedlibxmutypes.h new file mode 100644 index 0000000000..55ced16425 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxmutypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxmuTYPES_H_ +#define __wrappedlibxmuTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibxmuTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxmuundefs.h b/src/wrapped/generated/wrappedlibxmuundefs.h new file mode 100644 index 0000000000..186bb5ad34 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxmuundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxmuUNDEFS_H_ +#define __wrappedlibxmuUNDEFS_H_ + + +#endif // __wrappedlibxmuUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxpmdefs.h b/src/wrapped/generated/wrappedlibxpmdefs.h new file mode 100644 index 0000000000..fe147cae07 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxpmdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxpmDEFS_H_ +#define __wrappedlibxpmDEFS_H_ + + +#endif // __wrappedlibxpmDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxpmtypes.h b/src/wrapped/generated/wrappedlibxpmtypes.h new file mode 100644 index 0000000000..af7d837066 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxpmtypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxpmTYPES_H_ +#define __wrappedlibxpmTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibxpmTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxpmundefs.h b/src/wrapped/generated/wrappedlibxpmundefs.h new file mode 100644 index 0000000000..d40f7aebb8 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxpmundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxpmUNDEFS_H_ +#define __wrappedlibxpmUNDEFS_H_ + + +#endif // __wrappedlibxpmUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxrandrdefs.h b/src/wrapped/generated/wrappedlibxrandrdefs.h new file mode 100644 index 0000000000..ab1da5a381 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxrandrdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxrandrDEFS_H_ +#define __wrappedlibxrandrDEFS_H_ + + +#endif // __wrappedlibxrandrDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxrandrtypes.h b/src/wrapped/generated/wrappedlibxrandrtypes.h new file mode 100644 index 0000000000..51c4361d13 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxrandrtypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxrandrTYPES_H_ +#define __wrappedlibxrandrTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibxrandrTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxrandrundefs.h b/src/wrapped/generated/wrappedlibxrandrundefs.h new file mode 100644 index 0000000000..672133851f --- /dev/null +++ b/src/wrapped/generated/wrappedlibxrandrundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxrandrUNDEFS_H_ +#define __wrappedlibxrandrUNDEFS_H_ + + +#endif // __wrappedlibxrandrUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxrenderdefs.h b/src/wrapped/generated/wrappedlibxrenderdefs.h new file mode 100644 index 0000000000..8cbf942c11 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxrenderdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxrenderDEFS_H_ +#define __wrappedlibxrenderDEFS_H_ + + +#endif // __wrappedlibxrenderDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxrendertypes.h b/src/wrapped/generated/wrappedlibxrendertypes.h new file mode 100644 index 0000000000..8c9bfc2d8a --- /dev/null +++ b/src/wrapped/generated/wrappedlibxrendertypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxrenderTYPES_H_ +#define __wrappedlibxrenderTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibxrenderTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxrenderundefs.h b/src/wrapped/generated/wrappedlibxrenderundefs.h new file mode 100644 index 0000000000..603827bb73 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxrenderundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxrenderUNDEFS_H_ +#define __wrappedlibxrenderUNDEFS_H_ + + +#endif // __wrappedlibxrenderUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxssdefs.h b/src/wrapped/generated/wrappedlibxssdefs.h new file mode 100644 index 0000000000..5dfa77b286 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxssdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxssDEFS_H_ +#define __wrappedlibxssDEFS_H_ + + +#endif // __wrappedlibxssDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxsstypes.h b/src/wrapped/generated/wrappedlibxsstypes.h new file mode 100644 index 0000000000..a1c6557eaa --- /dev/null +++ b/src/wrapped/generated/wrappedlibxsstypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxssTYPES_H_ +#define __wrappedlibxssTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedlibxssTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxssundefs.h b/src/wrapped/generated/wrappedlibxssundefs.h new file mode 100644 index 0000000000..04fd935331 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxssundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxssUNDEFS_H_ +#define __wrappedlibxssUNDEFS_H_ + + +#endif // __wrappedlibxssUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxtdefs.h b/src/wrapped/generated/wrappedlibxtdefs.h new file mode 100644 index 0000000000..30165a0ca1 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxtdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxtDEFS_H_ +#define __wrappedlibxtDEFS_H_ + + +#endif // __wrappedlibxtDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxtstdefs.h b/src/wrapped/generated/wrappedlibxtstdefs.h new file mode 100644 index 0000000000..26694d3cc0 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxtstdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxtstDEFS_H_ +#define __wrappedlibxtstDEFS_H_ + + +#endif // __wrappedlibxtstDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxtsttypes.h b/src/wrapped/generated/wrappedlibxtsttypes.h index 11f7d1dc17..49e1caa247 100644 --- a/src/wrapped/generated/wrappedlibxtsttypes.h +++ b/src/wrapped/generated/wrappedlibxtsttypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibxtstTYPES_H_ #define __wrappedlibxtstTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxtstundefs.h b/src/wrapped/generated/wrappedlibxtstundefs.h new file mode 100644 index 0000000000..2d393c88b1 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxtstundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxtstUNDEFS_H_ +#define __wrappedlibxtstUNDEFS_H_ + + +#endif // __wrappedlibxtstUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxttypes.h b/src/wrapped/generated/wrappedlibxttypes.h index ae115647bf..82f59be284 100644 --- a/src/wrapped/generated/wrappedlibxttypes.h +++ b/src/wrapped/generated/wrappedlibxttypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibxtTYPES_H_ #define __wrappedlibxtTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxtundefs.h b/src/wrapped/generated/wrappedlibxtundefs.h new file mode 100644 index 0000000000..6b22fe0d39 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxtundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxtUNDEFS_H_ +#define __wrappedlibxtUNDEFS_H_ + + +#endif // __wrappedlibxtUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxxf86vmdefs.h b/src/wrapped/generated/wrappedlibxxf86vmdefs.h new file mode 100644 index 0000000000..4af5570f8c --- /dev/null +++ b/src/wrapped/generated/wrappedlibxxf86vmdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxxf86vmDEFS_H_ +#define __wrappedlibxxf86vmDEFS_H_ + + +#endif // __wrappedlibxxf86vmDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibxxf86vmtypes.h b/src/wrapped/generated/wrappedlibxxf86vmtypes.h new file mode 100644 index 0000000000..3d598b6c6f --- /dev/null +++ b/src/wrapped/generated/wrappedlibxxf86vmtypes.h @@ -0,0 +1,20 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxxf86vmTYPES_H_ +#define __wrappedlibxxf86vmTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + +typedef int32_t (*iFpip_t)(void*, int32_t, void*); + +#define SUPER() ADDED_FUNCTIONS() \ + GO(XF86VidModeGetGamma, iFpip_t) \ + GO(XF86VidModeSetGamma, iFpip_t) + +#endif // __wrappedlibxxf86vmTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibxxf86vmundefs.h b/src/wrapped/generated/wrappedlibxxf86vmundefs.h new file mode 100644 index 0000000000..7ac95a5be2 --- /dev/null +++ b/src/wrapped/generated/wrappedlibxxf86vmundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibxxf86vmUNDEFS_H_ +#define __wrappedlibxxf86vmUNDEFS_H_ + + +#endif // __wrappedlibxxf86vmUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibzdefs.h b/src/wrapped/generated/wrappedlibzdefs.h new file mode 100644 index 0000000000..0ba5ba3203 --- /dev/null +++ b/src/wrapped/generated/wrappedlibzdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibzDEFS_H_ +#define __wrappedlibzDEFS_H_ + + +#endif // __wrappedlibzDEFS_H_ diff --git a/src/wrapped/generated/wrappedlibztypes.h b/src/wrapped/generated/wrappedlibztypes.h index e66cbea40c..c2ba734f32 100644 --- a/src/wrapped/generated/wrappedlibztypes.h +++ b/src/wrapped/generated/wrappedlibztypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedlibzTYPES_H_ #define __wrappedlibzTYPES_H_ @@ -11,18 +11,16 @@ #define ADDED_FUNCTIONS() #endif -typedef int32_t (*iFp_t)(void*); typedef int32_t (*iFppi_t)(void*, void*, int32_t); typedef int32_t (*iFpipi_t)(void*, int32_t, void*, int32_t); +typedef int32_t (*iFpippi_t)(void*, int32_t, void*, void*, int32_t); typedef int32_t (*iFpiiiiipi_t)(void*, int32_t, int32_t, int32_t, int32_t, int32_t, void*, int32_t); #define SUPER() ADDED_FUNCTIONS() \ - GO(deflateEnd, iFp_t) \ - GO(inflateEnd, iFp_t) \ - GO(inflateInit, iFp_t) \ GO(inflateInit_, iFppi_t) \ GO(deflateInit_, iFpipi_t) \ GO(inflateInit2_, iFpipi_t) \ + GO(inflateBackInit_, iFpippi_t) \ GO(deflateInit2_, iFpiiiiipi_t) #endif // __wrappedlibzTYPES_H_ diff --git a/src/wrapped/generated/wrappedlibzundefs.h b/src/wrapped/generated/wrappedlibzundefs.h new file mode 100644 index 0000000000..d9555dbcab --- /dev/null +++ b/src/wrapped/generated/wrappedlibzundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedlibzUNDEFS_H_ +#define __wrappedlibzUNDEFS_H_ + + +#endif // __wrappedlibzUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedmpg123defs.h b/src/wrapped/generated/wrappedmpg123defs.h new file mode 100644 index 0000000000..d6c7ae4e64 --- /dev/null +++ b/src/wrapped/generated/wrappedmpg123defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedmpg123DEFS_H_ +#define __wrappedmpg123DEFS_H_ + + +#endif // __wrappedmpg123DEFS_H_ diff --git a/src/wrapped/generated/wrappedmpg123types.h b/src/wrapped/generated/wrappedmpg123types.h index 08b08dcfc8..bf692c71bc 100644 --- a/src/wrapped/generated/wrappedmpg123types.h +++ b/src/wrapped/generated/wrappedmpg123types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedmpg123TYPES_H_ #define __wrappedmpg123TYPES_H_ diff --git a/src/wrapped/generated/wrappedmpg123undefs.h b/src/wrapped/generated/wrappedmpg123undefs.h new file mode 100644 index 0000000000..76b1eb4db8 --- /dev/null +++ b/src/wrapped/generated/wrappedmpg123undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedmpg123UNDEFS_H_ +#define __wrappedmpg123UNDEFS_H_ + + +#endif // __wrappedmpg123UNDEFS_H_ diff --git a/src/wrapped/generated/wrappednsldefs.h b/src/wrapped/generated/wrappednsldefs.h new file mode 100644 index 0000000000..4c803163d1 --- /dev/null +++ b/src/wrapped/generated/wrappednsldefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappednslDEFS_H_ +#define __wrappednslDEFS_H_ + + +#endif // __wrappednslDEFS_H_ diff --git a/src/wrapped/generated/wrappednsltypes.h b/src/wrapped/generated/wrappednsltypes.h new file mode 100644 index 0000000000..a50002dba9 --- /dev/null +++ b/src/wrapped/generated/wrappednsltypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappednslTYPES_H_ +#define __wrappednslTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappednslTYPES_H_ diff --git a/src/wrapped/generated/wrappednslundefs.h b/src/wrapped/generated/wrappednslundefs.h new file mode 100644 index 0000000000..614c3f61ba --- /dev/null +++ b/src/wrapped/generated/wrappednslundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappednslUNDEFS_H_ +#define __wrappednslUNDEFS_H_ + + +#endif // __wrappednslUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedopenaldefs.h b/src/wrapped/generated/wrappedopenaldefs.h new file mode 100644 index 0000000000..7363ef4162 --- /dev/null +++ b/src/wrapped/generated/wrappedopenaldefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedopenalDEFS_H_ +#define __wrappedopenalDEFS_H_ + + +#endif // __wrappedopenalDEFS_H_ diff --git a/src/wrapped/generated/wrappedopenaltypes.h b/src/wrapped/generated/wrappedopenaltypes.h index fc7b7ba117..e56105df1d 100644 --- a/src/wrapped/generated/wrappedopenaltypes.h +++ b/src/wrapped/generated/wrappedopenaltypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedopenalTYPES_H_ #define __wrappedopenalTYPES_H_ diff --git a/src/wrapped/generated/wrappedopenalundefs.h b/src/wrapped/generated/wrappedopenalundefs.h new file mode 100644 index 0000000000..3a072e2b72 --- /dev/null +++ b/src/wrapped/generated/wrappedopenalundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedopenalUNDEFS_H_ +#define __wrappedopenalUNDEFS_H_ + + +#endif // __wrappedopenalUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedpangocairodefs.h b/src/wrapped/generated/wrappedpangocairodefs.h new file mode 100644 index 0000000000..10c3991c98 --- /dev/null +++ b/src/wrapped/generated/wrappedpangocairodefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedpangocairoDEFS_H_ +#define __wrappedpangocairoDEFS_H_ + + +#endif // __wrappedpangocairoDEFS_H_ diff --git a/src/wrapped/generated/wrappedpangocairotypes.h b/src/wrapped/generated/wrappedpangocairotypes.h new file mode 100644 index 0000000000..3834c8c337 --- /dev/null +++ b/src/wrapped/generated/wrappedpangocairotypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedpangocairoTYPES_H_ +#define __wrappedpangocairoTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedpangocairoTYPES_H_ diff --git a/src/wrapped/generated/wrappedpangocairoundefs.h b/src/wrapped/generated/wrappedpangocairoundefs.h new file mode 100644 index 0000000000..901cf2aaa0 --- /dev/null +++ b/src/wrapped/generated/wrappedpangocairoundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedpangocairoUNDEFS_H_ +#define __wrappedpangocairoUNDEFS_H_ + + +#endif // __wrappedpangocairoUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedpangodefs.h b/src/wrapped/generated/wrappedpangodefs.h new file mode 100644 index 0000000000..346af6eb1f --- /dev/null +++ b/src/wrapped/generated/wrappedpangodefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedpangoDEFS_H_ +#define __wrappedpangoDEFS_H_ + + +#endif // __wrappedpangoDEFS_H_ diff --git a/src/wrapped/generated/wrappedpangoft2defs.h b/src/wrapped/generated/wrappedpangoft2defs.h new file mode 100644 index 0000000000..cb62301409 --- /dev/null +++ b/src/wrapped/generated/wrappedpangoft2defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedpangoft2DEFS_H_ +#define __wrappedpangoft2DEFS_H_ + + +#endif // __wrappedpangoft2DEFS_H_ diff --git a/src/wrapped/generated/wrappedpangoft2types.h b/src/wrapped/generated/wrappedpangoft2types.h new file mode 100644 index 0000000000..99b44db6d7 --- /dev/null +++ b/src/wrapped/generated/wrappedpangoft2types.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedpangoft2TYPES_H_ +#define __wrappedpangoft2TYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedpangoft2TYPES_H_ diff --git a/src/wrapped/generated/wrappedpangoft2undefs.h b/src/wrapped/generated/wrappedpangoft2undefs.h new file mode 100644 index 0000000000..d4c1f188e0 --- /dev/null +++ b/src/wrapped/generated/wrappedpangoft2undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedpangoft2UNDEFS_H_ +#define __wrappedpangoft2UNDEFS_H_ + + +#endif // __wrappedpangoft2UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedpangotypes.h b/src/wrapped/generated/wrappedpangotypes.h index f07652779a..7441bff36f 100644 --- a/src/wrapped/generated/wrappedpangotypes.h +++ b/src/wrapped/generated/wrappedpangotypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedpangoTYPES_H_ #define __wrappedpangoTYPES_H_ diff --git a/src/wrapped/generated/wrappedpangoundefs.h b/src/wrapped/generated/wrappedpangoundefs.h new file mode 100644 index 0000000000..4b59d4e201 --- /dev/null +++ b/src/wrapped/generated/wrappedpangoundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedpangoUNDEFS_H_ +#define __wrappedpangoUNDEFS_H_ + + +#endif // __wrappedpangoUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedpng12defs.h b/src/wrapped/generated/wrappedpng12defs.h new file mode 100644 index 0000000000..22d4792397 --- /dev/null +++ b/src/wrapped/generated/wrappedpng12defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedpng12DEFS_H_ +#define __wrappedpng12DEFS_H_ + + +#endif // __wrappedpng12DEFS_H_ diff --git a/src/wrapped/generated/wrappedpng12types.h b/src/wrapped/generated/wrappedpng12types.h index a0edea2aef..56e380b968 100644 --- a/src/wrapped/generated/wrappedpng12types.h +++ b/src/wrapped/generated/wrappedpng12types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedpng12TYPES_H_ #define __wrappedpng12TYPES_H_ diff --git a/src/wrapped/generated/wrappedpng12undefs.h b/src/wrapped/generated/wrappedpng12undefs.h new file mode 100644 index 0000000000..0b4d781497 --- /dev/null +++ b/src/wrapped/generated/wrappedpng12undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedpng12UNDEFS_H_ +#define __wrappedpng12UNDEFS_H_ + + +#endif // __wrappedpng12UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedpng16defs.h b/src/wrapped/generated/wrappedpng16defs.h new file mode 100644 index 0000000000..9486793f8e --- /dev/null +++ b/src/wrapped/generated/wrappedpng16defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedpng16DEFS_H_ +#define __wrappedpng16DEFS_H_ + + +#endif // __wrappedpng16DEFS_H_ diff --git a/src/wrapped/generated/wrappedpng16types.h b/src/wrapped/generated/wrappedpng16types.h index ddd82dfe21..38158790dc 100644 --- a/src/wrapped/generated/wrappedpng16types.h +++ b/src/wrapped/generated/wrappedpng16types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedpng16TYPES_H_ #define __wrappedpng16TYPES_H_ diff --git a/src/wrapped/generated/wrappedpng16undefs.h b/src/wrapped/generated/wrappedpng16undefs.h new file mode 100644 index 0000000000..4818f86711 --- /dev/null +++ b/src/wrapped/generated/wrappedpng16undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedpng16UNDEFS_H_ +#define __wrappedpng16UNDEFS_H_ + + +#endif // __wrappedpng16UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedpulsedefs.h b/src/wrapped/generated/wrappedpulsedefs.h new file mode 100644 index 0000000000..d032eb1b5d --- /dev/null +++ b/src/wrapped/generated/wrappedpulsedefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedpulseDEFS_H_ +#define __wrappedpulseDEFS_H_ + + +#endif // __wrappedpulseDEFS_H_ diff --git a/src/wrapped/generated/wrappedpulsesimpledefs.h b/src/wrapped/generated/wrappedpulsesimpledefs.h new file mode 100644 index 0000000000..b688297615 --- /dev/null +++ b/src/wrapped/generated/wrappedpulsesimpledefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedpulsesimpleDEFS_H_ +#define __wrappedpulsesimpleDEFS_H_ + + +#endif // __wrappedpulsesimpleDEFS_H_ diff --git a/src/wrapped/generated/wrappedpulsesimpletypes.h b/src/wrapped/generated/wrappedpulsesimpletypes.h new file mode 100644 index 0000000000..88a9cc8ea0 --- /dev/null +++ b/src/wrapped/generated/wrappedpulsesimpletypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedpulsesimpleTYPES_H_ +#define __wrappedpulsesimpleTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedpulsesimpleTYPES_H_ diff --git a/src/wrapped/generated/wrappedpulsesimpleundefs.h b/src/wrapped/generated/wrappedpulsesimpleundefs.h new file mode 100644 index 0000000000..1a1841d92a --- /dev/null +++ b/src/wrapped/generated/wrappedpulsesimpleundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedpulsesimpleUNDEFS_H_ +#define __wrappedpulsesimpleUNDEFS_H_ + + +#endif // __wrappedpulsesimpleUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedpulsetypes.h b/src/wrapped/generated/wrappedpulsetypes.h index 1f80f71b5f..15ae75401e 100644 --- a/src/wrapped/generated/wrappedpulsetypes.h +++ b/src/wrapped/generated/wrappedpulsetypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedpulseTYPES_H_ #define __wrappedpulseTYPES_H_ @@ -20,7 +20,7 @@ typedef void (*vFppp_t)(void*, void*, void*); typedef void* (*pFipp_t)(int32_t, void*, void*); typedef void* (*pFppp_t)(void*, void*, void*); typedef int32_t (*iFppip_t)(void*, void*, int32_t, void*); -typedef int32_t (*iFpppV_t)(void*, void*, void*, void*); +typedef int32_t (*iFpppV_t)(void*, void*, void*, ...); typedef void* (*pFpipp_t)(void*, int32_t, void*, void*); typedef void* (*pFpupp_t)(void*, uint32_t, void*, void*); typedef void* (*pFpppp_t)(void*, void*, void*, void*); diff --git a/src/wrapped/generated/wrappedpulseundefs.h b/src/wrapped/generated/wrappedpulseundefs.h new file mode 100644 index 0000000000..e0b03d5d16 --- /dev/null +++ b/src/wrapped/generated/wrappedpulseundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedpulseUNDEFS_H_ +#define __wrappedpulseUNDEFS_H_ + + +#endif // __wrappedpulseUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl1defs.h b/src/wrapped/generated/wrappedsdl1defs.h new file mode 100644 index 0000000000..956cb0b194 --- /dev/null +++ b/src/wrapped/generated/wrappedsdl1defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl1DEFS_H_ +#define __wrappedsdl1DEFS_H_ + + +#endif // __wrappedsdl1DEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl1imagedefs.h b/src/wrapped/generated/wrappedsdl1imagedefs.h new file mode 100644 index 0000000000..457dc2ea9c --- /dev/null +++ b/src/wrapped/generated/wrappedsdl1imagedefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl1imageDEFS_H_ +#define __wrappedsdl1imageDEFS_H_ + + +#endif // __wrappedsdl1imageDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl1imagetypes.h b/src/wrapped/generated/wrappedsdl1imagetypes.h index 5a8bdc2795..d3f6d07697 100644 --- a/src/wrapped/generated/wrappedsdl1imagetypes.h +++ b/src/wrapped/generated/wrappedsdl1imagetypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedsdl1imageTYPES_H_ #define __wrappedsdl1imageTYPES_H_ diff --git a/src/wrapped/generated/wrappedsdl1imageundefs.h b/src/wrapped/generated/wrappedsdl1imageundefs.h new file mode 100644 index 0000000000..1116912af5 --- /dev/null +++ b/src/wrapped/generated/wrappedsdl1imageundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl1imageUNDEFS_H_ +#define __wrappedsdl1imageUNDEFS_H_ + + +#endif // __wrappedsdl1imageUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl1mixerdefs.h b/src/wrapped/generated/wrappedsdl1mixerdefs.h new file mode 100644 index 0000000000..3cc1fc0484 --- /dev/null +++ b/src/wrapped/generated/wrappedsdl1mixerdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl1mixerDEFS_H_ +#define __wrappedsdl1mixerDEFS_H_ + + +#endif // __wrappedsdl1mixerDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl1mixertypes.h b/src/wrapped/generated/wrappedsdl1mixertypes.h index ffcbf2216f..69488d9048 100644 --- a/src/wrapped/generated/wrappedsdl1mixertypes.h +++ b/src/wrapped/generated/wrappedsdl1mixertypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedsdl1mixerTYPES_H_ #define __wrappedsdl1mixerTYPES_H_ diff --git a/src/wrapped/generated/wrappedsdl1mixerundefs.h b/src/wrapped/generated/wrappedsdl1mixerundefs.h new file mode 100644 index 0000000000..58df8cd884 --- /dev/null +++ b/src/wrapped/generated/wrappedsdl1mixerundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl1mixerUNDEFS_H_ +#define __wrappedsdl1mixerUNDEFS_H_ + + +#endif // __wrappedsdl1mixerUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl1netdefs.h b/src/wrapped/generated/wrappedsdl1netdefs.h new file mode 100644 index 0000000000..d54522fd08 --- /dev/null +++ b/src/wrapped/generated/wrappedsdl1netdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl1netDEFS_H_ +#define __wrappedsdl1netDEFS_H_ + + +#endif // __wrappedsdl1netDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl1nettypes.h b/src/wrapped/generated/wrappedsdl1nettypes.h new file mode 100644 index 0000000000..fb78787a26 --- /dev/null +++ b/src/wrapped/generated/wrappedsdl1nettypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl1netTYPES_H_ +#define __wrappedsdl1netTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedsdl1netTYPES_H_ diff --git a/src/wrapped/generated/wrappedsdl1netundefs.h b/src/wrapped/generated/wrappedsdl1netundefs.h new file mode 100644 index 0000000000..16efff9e04 --- /dev/null +++ b/src/wrapped/generated/wrappedsdl1netundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl1netUNDEFS_H_ +#define __wrappedsdl1netUNDEFS_H_ + + +#endif // __wrappedsdl1netUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl1sounddefs.h b/src/wrapped/generated/wrappedsdl1sounddefs.h new file mode 100644 index 0000000000..03b0cd5d6a --- /dev/null +++ b/src/wrapped/generated/wrappedsdl1sounddefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl1soundDEFS_H_ +#define __wrappedsdl1soundDEFS_H_ + + +#endif // __wrappedsdl1soundDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl1soundtypes.h b/src/wrapped/generated/wrappedsdl1soundtypes.h index f2ae9897f6..c911ab3fbb 100644 --- a/src/wrapped/generated/wrappedsdl1soundtypes.h +++ b/src/wrapped/generated/wrappedsdl1soundtypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedsdl1soundTYPES_H_ #define __wrappedsdl1soundTYPES_H_ diff --git a/src/wrapped/generated/wrappedsdl1soundundefs.h b/src/wrapped/generated/wrappedsdl1soundundefs.h new file mode 100644 index 0000000000..cc8c5753a9 --- /dev/null +++ b/src/wrapped/generated/wrappedsdl1soundundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl1soundUNDEFS_H_ +#define __wrappedsdl1soundUNDEFS_H_ + + +#endif // __wrappedsdl1soundUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl1ttfdefs.h b/src/wrapped/generated/wrappedsdl1ttfdefs.h new file mode 100644 index 0000000000..e3289eed85 --- /dev/null +++ b/src/wrapped/generated/wrappedsdl1ttfdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl1ttfDEFS_H_ +#define __wrappedsdl1ttfDEFS_H_ + + +#endif // __wrappedsdl1ttfDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl1ttftypes.h b/src/wrapped/generated/wrappedsdl1ttftypes.h index 21c2a9b7c8..e00b426a9d 100644 --- a/src/wrapped/generated/wrappedsdl1ttftypes.h +++ b/src/wrapped/generated/wrappedsdl1ttftypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedsdl1ttfTYPES_H_ #define __wrappedsdl1ttfTYPES_H_ diff --git a/src/wrapped/generated/wrappedsdl1ttfundefs.h b/src/wrapped/generated/wrappedsdl1ttfundefs.h new file mode 100644 index 0000000000..093e9fe77b --- /dev/null +++ b/src/wrapped/generated/wrappedsdl1ttfundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl1ttfUNDEFS_H_ +#define __wrappedsdl1ttfUNDEFS_H_ + + +#endif // __wrappedsdl1ttfUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl1types.h b/src/wrapped/generated/wrappedsdl1types.h index 848e6cf611..8eb2f100c4 100644 --- a/src/wrapped/generated/wrappedsdl1types.h +++ b/src/wrapped/generated/wrappedsdl1types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedsdl1TYPES_H_ #define __wrappedsdl1TYPES_H_ @@ -12,6 +12,7 @@ #endif typedef void (*vFp_t)(void*); +typedef int32_t (*iFv_t)(void); typedef int32_t (*iFp_t)(void*); typedef uint32_t (*uFp_t)(void*); typedef uint64_t (*UFp_t)(void*); @@ -32,6 +33,14 @@ typedef void* (*pFpippp_t)(void*, int32_t, void*, void*, void*); GO(SDL_KillThread, vFp_t) \ GO(SDL_SetEventFilter, vFp_t) \ GO(SDL_UnloadObject, vFp_t) \ + GO(SDL_Has3DNow, iFv_t) \ + GO(SDL_Has3DNowExt, iFv_t) \ + GO(SDL_HasAltiVec, iFv_t) \ + GO(SDL_HasMMX, iFv_t) \ + GO(SDL_HasMMXExt, iFv_t) \ + GO(SDL_HasRDTSC, iFv_t) \ + GO(SDL_HasSSE, iFv_t) \ + GO(SDL_HasSSE2, iFv_t) \ GO(SDL_GetWMInfo, iFp_t) \ GO(SDL_RemoveTimer, iFp_t) \ GO(SDL_ReadBE16, uFp_t) \ diff --git a/src/wrapped/generated/wrappedsdl1undefs.h b/src/wrapped/generated/wrappedsdl1undefs.h new file mode 100644 index 0000000000..3b89ebb836 --- /dev/null +++ b/src/wrapped/generated/wrappedsdl1undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl1UNDEFS_H_ +#define __wrappedsdl1UNDEFS_H_ + + +#endif // __wrappedsdl1UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl2defs.h b/src/wrapped/generated/wrappedsdl2defs.h new file mode 100644 index 0000000000..21946706b0 --- /dev/null +++ b/src/wrapped/generated/wrappedsdl2defs.h @@ -0,0 +1,14 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl2DEFS_H_ +#define __wrappedsdl2DEFS_H_ + +#define pFJ pFuuuu +#define iFEJ iFEuuuu +#define JFEi pFEpi +#define JFEp pFEpp +#define gFEpi pFEppi +#define vFEJppp vFEuuuuppp + +#endif // __wrappedsdl2DEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl2imagedefs.h b/src/wrapped/generated/wrappedsdl2imagedefs.h new file mode 100644 index 0000000000..9c94f01944 --- /dev/null +++ b/src/wrapped/generated/wrappedsdl2imagedefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl2imageDEFS_H_ +#define __wrappedsdl2imageDEFS_H_ + + +#endif // __wrappedsdl2imageDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl2imagetypes.h b/src/wrapped/generated/wrappedsdl2imagetypes.h index 9a28760612..41c099642a 100644 --- a/src/wrapped/generated/wrappedsdl2imagetypes.h +++ b/src/wrapped/generated/wrappedsdl2imagetypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedsdl2imageTYPES_H_ #define __wrappedsdl2imageTYPES_H_ diff --git a/src/wrapped/generated/wrappedsdl2imageundefs.h b/src/wrapped/generated/wrappedsdl2imageundefs.h new file mode 100644 index 0000000000..defdd19bfb --- /dev/null +++ b/src/wrapped/generated/wrappedsdl2imageundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl2imageUNDEFS_H_ +#define __wrappedsdl2imageUNDEFS_H_ + + +#endif // __wrappedsdl2imageUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl2mixerdefs.h b/src/wrapped/generated/wrappedsdl2mixerdefs.h new file mode 100644 index 0000000000..83fd12356d --- /dev/null +++ b/src/wrapped/generated/wrappedsdl2mixerdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl2mixerDEFS_H_ +#define __wrappedsdl2mixerDEFS_H_ + + +#endif // __wrappedsdl2mixerDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl2mixertypes.h b/src/wrapped/generated/wrappedsdl2mixertypes.h index 361c05ea90..e00ae8dbea 100644 --- a/src/wrapped/generated/wrappedsdl2mixertypes.h +++ b/src/wrapped/generated/wrappedsdl2mixertypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedsdl2mixerTYPES_H_ #define __wrappedsdl2mixerTYPES_H_ diff --git a/src/wrapped/generated/wrappedsdl2mixerundefs.h b/src/wrapped/generated/wrappedsdl2mixerundefs.h new file mode 100644 index 0000000000..b26a4e974f --- /dev/null +++ b/src/wrapped/generated/wrappedsdl2mixerundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl2mixerUNDEFS_H_ +#define __wrappedsdl2mixerUNDEFS_H_ + + +#endif // __wrappedsdl2mixerUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl2netdefs.h b/src/wrapped/generated/wrappedsdl2netdefs.h new file mode 100644 index 0000000000..4f7179e709 --- /dev/null +++ b/src/wrapped/generated/wrappedsdl2netdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl2netDEFS_H_ +#define __wrappedsdl2netDEFS_H_ + + +#endif // __wrappedsdl2netDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl2nettypes.h b/src/wrapped/generated/wrappedsdl2nettypes.h new file mode 100644 index 0000000000..ca49037472 --- /dev/null +++ b/src/wrapped/generated/wrappedsdl2nettypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl2netTYPES_H_ +#define __wrappedsdl2netTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedsdl2netTYPES_H_ diff --git a/src/wrapped/generated/wrappedsdl2netundefs.h b/src/wrapped/generated/wrappedsdl2netundefs.h new file mode 100644 index 0000000000..7f6c74d87b --- /dev/null +++ b/src/wrapped/generated/wrappedsdl2netundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl2netUNDEFS_H_ +#define __wrappedsdl2netUNDEFS_H_ + + +#endif // __wrappedsdl2netUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl2ttfdefs.h b/src/wrapped/generated/wrappedsdl2ttfdefs.h new file mode 100644 index 0000000000..264da3ae88 --- /dev/null +++ b/src/wrapped/generated/wrappedsdl2ttfdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl2ttfDEFS_H_ +#define __wrappedsdl2ttfDEFS_H_ + + +#endif // __wrappedsdl2ttfDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl2ttftypes.h b/src/wrapped/generated/wrappedsdl2ttftypes.h index 4828b7fbb6..7e62c00742 100644 --- a/src/wrapped/generated/wrappedsdl2ttftypes.h +++ b/src/wrapped/generated/wrappedsdl2ttftypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedsdl2ttfTYPES_H_ #define __wrappedsdl2ttfTYPES_H_ diff --git a/src/wrapped/generated/wrappedsdl2ttfundefs.h b/src/wrapped/generated/wrappedsdl2ttfundefs.h new file mode 100644 index 0000000000..c2195086d9 --- /dev/null +++ b/src/wrapped/generated/wrappedsdl2ttfundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl2ttfUNDEFS_H_ +#define __wrappedsdl2ttfUNDEFS_H_ + + +#endif // __wrappedsdl2ttfUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedsdl2types.h b/src/wrapped/generated/wrappedsdl2types.h index d669d9cda7..b5791940cc 100644 --- a/src/wrapped/generated/wrappedsdl2types.h +++ b/src/wrapped/generated/wrappedsdl2types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedsdl2TYPES_H_ #define __wrappedsdl2TYPES_H_ @@ -12,6 +12,7 @@ #endif typedef void (*vFp_t)(void*); +typedef int32_t (*iFv_t)(void); typedef int32_t (*iFp_t)(void*); typedef int32_t (*iFJ_t)(SDL_JoystickGUID); typedef int64_t (*IFp_t)(void*); @@ -19,11 +20,10 @@ typedef uint32_t (*uFp_t)(void*); typedef uint64_t (*UFp_t)(void*); typedef void* (*pFv_t)(void); typedef void* (*pFp_t)(void*); -typedef void* (*pFJ_t)(SDL_JoystickGUID); typedef SDL_JoystickGUID (*JFi_t)(int32_t); typedef SDL_JoystickGUID (*JFp_t)(void*); typedef void (*vFpp_t)(void*, void*); -typedef void (*vFpV_t)(void*, void*); +typedef void (*vFpV_t)(void*, ...); typedef int32_t (*iFip_t)(int32_t, void*); typedef int32_t (*iFWW_t)(uint16_t, uint16_t); typedef int32_t (*iFpi_t)(void*, int32_t); @@ -34,18 +34,17 @@ typedef uint32_t (*uFpU_t)(void*, uint64_t); typedef void* (*pFpi_t)(void*, int32_t); typedef void* (*pFpp_t)(void*, void*); typedef SDL_GameControllerButtonBind (*gFpi_t)(void*, int32_t); -typedef void (*vFipV_t)(int32_t, void*, void*); +typedef void (*vFipV_t)(int32_t, void*, ...); typedef int32_t (*iFupp_t)(uint32_t, void*, void*); typedef int32_t (*iFppi_t)(void*, void*, int32_t); typedef int64_t (*IFpIi_t)(void*, int64_t, int32_t); typedef void* (*pFupp_t)(uint32_t, void*, void*); typedef void* (*pFppi_t)(void*, void*, int32_t); typedef void* (*pFppp_t)(void*, void*, void*); -typedef void (*vFpuup_t)(void*, uint32_t, uint32_t, void*); typedef void (*vFJppp_t)(SDL_JoystickGUID, void*, void*, void*); +typedef int32_t (*iFpupV_t)(void*, uint32_t, void*, ...); typedef uint32_t (*uFppuu_t)(void*, void*, uint32_t, uint32_t); typedef int32_t (*iFpippi_t)(void*, int32_t, void*, void*, int32_t); -typedef int32_t (*iFpupVV_t)(void*, uint32_t, void*, void*, void*); typedef void* (*pFpippp_t)(void*, int32_t, void*, void*, void*); #define SUPER() ADDED_FUNCTIONS() \ @@ -67,7 +66,6 @@ typedef void* (*pFpippp_t)(void*, int32_t, void*, void*, void*); GO(SDL_Vulkan_GetVkGetInstanceProcAddr, pFv_t) \ GO(SDL_GL_GetProcAddress, pFp_t) \ GO(SDL_LoadObject, pFp_t) \ - GO(SDL_GameControllerMappingForGUID, pFJ_t) \ GO(SDL_JoystickGetDeviceGUID, JFi_t) \ GO(SDL_JoystickGetGUID, JFp_t) \ GO(SDL_JoystickGetGUIDFromString, JFp_t) \ @@ -113,13 +111,12 @@ typedef void* (*pFpippp_t)(void*, int32_t, void*, void*, void*); GO(SDL_AddTimer, pFupp_t) \ GO(SDL_LoadFile_RW, pFppi_t) \ GO(SDL_CreateThread, pFppp_t) \ - GO(SDL_qsort, vFpuup_t) \ GO(SDL_GetJoystickGUIDInfo, vFJppp_t) \ + GO(SDL_snprintf, iFpupV_t) \ + GO(SDL_vsnprintf, iFpupV_t) \ GO(SDL_RWread, uFppuu_t) \ GO(SDL_RWwrite, uFppuu_t) \ GO(SDL_OpenAudioDevice, iFpippi_t) \ - GO(SDL_snprintf, iFpupVV_t) \ - GO(SDL_vsnprintf, iFpupVV_t) \ GO(SDL_LoadWAV_RW, pFpippp_t) #endif // __wrappedsdl2TYPES_H_ diff --git a/src/wrapped/generated/wrappedsdl2undefs.h b/src/wrapped/generated/wrappedsdl2undefs.h new file mode 100644 index 0000000000..93a8b5a5a2 --- /dev/null +++ b/src/wrapped/generated/wrappedsdl2undefs.h @@ -0,0 +1,14 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsdl2UNDEFS_H_ +#define __wrappedsdl2UNDEFS_H_ + +#undef pFJ +#undef iFEJ +#undef JFEi +#undef JFEp +#undef gFEpi +#undef vFEJppp + +#endif // __wrappedsdl2UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedsmpeg2defs.h b/src/wrapped/generated/wrappedsmpeg2defs.h new file mode 100644 index 0000000000..5f902e3bc7 --- /dev/null +++ b/src/wrapped/generated/wrappedsmpeg2defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsmpeg2DEFS_H_ +#define __wrappedsmpeg2DEFS_H_ + + +#endif // __wrappedsmpeg2DEFS_H_ diff --git a/src/wrapped/generated/wrappedsmpeg2types.h b/src/wrapped/generated/wrappedsmpeg2types.h index 5c9576a746..b682039b05 100644 --- a/src/wrapped/generated/wrappedsmpeg2types.h +++ b/src/wrapped/generated/wrappedsmpeg2types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedsmpeg2TYPES_H_ #define __wrappedsmpeg2TYPES_H_ diff --git a/src/wrapped/generated/wrappedsmpeg2undefs.h b/src/wrapped/generated/wrappedsmpeg2undefs.h new file mode 100644 index 0000000000..f8cd3303b5 --- /dev/null +++ b/src/wrapped/generated/wrappedsmpeg2undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsmpeg2UNDEFS_H_ +#define __wrappedsmpeg2UNDEFS_H_ + + +#endif // __wrappedsmpeg2UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedsmpegdefs.h b/src/wrapped/generated/wrappedsmpegdefs.h new file mode 100644 index 0000000000..7bca78b312 --- /dev/null +++ b/src/wrapped/generated/wrappedsmpegdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsmpegDEFS_H_ +#define __wrappedsmpegDEFS_H_ + + +#endif // __wrappedsmpegDEFS_H_ diff --git a/src/wrapped/generated/wrappedsmpegtypes.h b/src/wrapped/generated/wrappedsmpegtypes.h index 1241546836..4876ed9710 100644 --- a/src/wrapped/generated/wrappedsmpegtypes.h +++ b/src/wrapped/generated/wrappedsmpegtypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedsmpegTYPES_H_ #define __wrappedsmpegTYPES_H_ diff --git a/src/wrapped/generated/wrappedsmpegundefs.h b/src/wrapped/generated/wrappedsmpegundefs.h new file mode 100644 index 0000000000..3ef542689b --- /dev/null +++ b/src/wrapped/generated/wrappedsmpegundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedsmpegUNDEFS_H_ +#define __wrappedsmpegUNDEFS_H_ + + +#endif // __wrappedsmpegUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedtcmallocminimaldefs.h b/src/wrapped/generated/wrappedtcmallocminimaldefs.h new file mode 100644 index 0000000000..cf8a449dd3 --- /dev/null +++ b/src/wrapped/generated/wrappedtcmallocminimaldefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedtcmallocminimalDEFS_H_ +#define __wrappedtcmallocminimalDEFS_H_ + + +#endif // __wrappedtcmallocminimalDEFS_H_ diff --git a/src/wrapped/generated/wrappedtcmallocminimaltypes.h b/src/wrapped/generated/wrappedtcmallocminimaltypes.h index bf1d09b104..b93e09b9d0 100644 --- a/src/wrapped/generated/wrappedtcmallocminimaltypes.h +++ b/src/wrapped/generated/wrappedtcmallocminimaltypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedtcmallocminimalTYPES_H_ #define __wrappedtcmallocminimalTYPES_H_ diff --git a/src/wrapped/generated/wrappedtcmallocminimalundefs.h b/src/wrapped/generated/wrappedtcmallocminimalundefs.h new file mode 100644 index 0000000000..e3b2798cc1 --- /dev/null +++ b/src/wrapped/generated/wrappedtcmallocminimalundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedtcmallocminimalUNDEFS_H_ +#define __wrappedtcmallocminimalUNDEFS_H_ + + +#endif // __wrappedtcmallocminimalUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedturbojpegdefs.h b/src/wrapped/generated/wrappedturbojpegdefs.h new file mode 100644 index 0000000000..afa2f6084b --- /dev/null +++ b/src/wrapped/generated/wrappedturbojpegdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedturbojpegDEFS_H_ +#define __wrappedturbojpegDEFS_H_ + + +#endif // __wrappedturbojpegDEFS_H_ diff --git a/src/wrapped/generated/wrappedturbojpegtypes.h b/src/wrapped/generated/wrappedturbojpegtypes.h new file mode 100644 index 0000000000..9bc8a12210 --- /dev/null +++ b/src/wrapped/generated/wrappedturbojpegtypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedturbojpegTYPES_H_ +#define __wrappedturbojpegTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedturbojpegTYPES_H_ diff --git a/src/wrapped/generated/wrappedturbojpegundefs.h b/src/wrapped/generated/wrappedturbojpegundefs.h new file mode 100644 index 0000000000..c654c58055 --- /dev/null +++ b/src/wrapped/generated/wrappedturbojpegundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedturbojpegUNDEFS_H_ +#define __wrappedturbojpegUNDEFS_H_ + + +#endif // __wrappedturbojpegUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedudev0defs.h b/src/wrapped/generated/wrappedudev0defs.h new file mode 100644 index 0000000000..0d64bba4bf --- /dev/null +++ b/src/wrapped/generated/wrappedudev0defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedudev0DEFS_H_ +#define __wrappedudev0DEFS_H_ + + +#endif // __wrappedudev0DEFS_H_ diff --git a/src/wrapped/generated/wrappedudev0types.h b/src/wrapped/generated/wrappedudev0types.h new file mode 100644 index 0000000000..0bb8f747a7 --- /dev/null +++ b/src/wrapped/generated/wrappedudev0types.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedudev0TYPES_H_ +#define __wrappedudev0TYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedudev0TYPES_H_ diff --git a/src/wrapped/generated/wrappedudev0undefs.h b/src/wrapped/generated/wrappedudev0undefs.h new file mode 100644 index 0000000000..e0d1631401 --- /dev/null +++ b/src/wrapped/generated/wrappedudev0undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedudev0UNDEFS_H_ +#define __wrappedudev0UNDEFS_H_ + + +#endif // __wrappedudev0UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedudev1defs.h b/src/wrapped/generated/wrappedudev1defs.h new file mode 100644 index 0000000000..201ae76123 --- /dev/null +++ b/src/wrapped/generated/wrappedudev1defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedudev1DEFS_H_ +#define __wrappedudev1DEFS_H_ + + +#endif // __wrappedudev1DEFS_H_ diff --git a/src/wrapped/generated/wrappedudev1types.h b/src/wrapped/generated/wrappedudev1types.h new file mode 100644 index 0000000000..71a3c6b75d --- /dev/null +++ b/src/wrapped/generated/wrappedudev1types.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedudev1TYPES_H_ +#define __wrappedudev1TYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedudev1TYPES_H_ diff --git a/src/wrapped/generated/wrappedudev1undefs.h b/src/wrapped/generated/wrappedudev1undefs.h new file mode 100644 index 0000000000..d075dd1263 --- /dev/null +++ b/src/wrapped/generated/wrappedudev1undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedudev1UNDEFS_H_ +#define __wrappedudev1UNDEFS_H_ + + +#endif // __wrappedudev1UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedutildefs.h b/src/wrapped/generated/wrappedutildefs.h new file mode 100644 index 0000000000..a1d3e60e65 --- /dev/null +++ b/src/wrapped/generated/wrappedutildefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedutilDEFS_H_ +#define __wrappedutilDEFS_H_ + + +#endif // __wrappedutilDEFS_H_ diff --git a/src/wrapped/generated/wrappedutiltypes.h b/src/wrapped/generated/wrappedutiltypes.h index 77d7df2511..83803c94e2 100644 --- a/src/wrapped/generated/wrappedutiltypes.h +++ b/src/wrapped/generated/wrappedutiltypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedutilTYPES_H_ #define __wrappedutilTYPES_H_ diff --git a/src/wrapped/generated/wrappedutilundefs.h b/src/wrapped/generated/wrappedutilundefs.h new file mode 100644 index 0000000000..170d2566eb --- /dev/null +++ b/src/wrapped/generated/wrappedutilundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedutilUNDEFS_H_ +#define __wrappedutilUNDEFS_H_ + + +#endif // __wrappedutilUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedvorbisfiledefs.h b/src/wrapped/generated/wrappedvorbisfiledefs.h new file mode 100644 index 0000000000..b4e5ff265e --- /dev/null +++ b/src/wrapped/generated/wrappedvorbisfiledefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedvorbisfileDEFS_H_ +#define __wrappedvorbisfileDEFS_H_ + + +#endif // __wrappedvorbisfileDEFS_H_ diff --git a/src/wrapped/generated/wrappedvorbisfiletypes.h b/src/wrapped/generated/wrappedvorbisfiletypes.h index 30524d7462..3647815c73 100644 --- a/src/wrapped/generated/wrappedvorbisfiletypes.h +++ b/src/wrapped/generated/wrappedvorbisfiletypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedvorbisfileTYPES_H_ #define __wrappedvorbisfileTYPES_H_ diff --git a/src/wrapped/generated/wrappedvorbisfileundefs.h b/src/wrapped/generated/wrappedvorbisfileundefs.h new file mode 100644 index 0000000000..faf943e841 --- /dev/null +++ b/src/wrapped/generated/wrappedvorbisfileundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedvorbisfileUNDEFS_H_ +#define __wrappedvorbisfileUNDEFS_H_ + + +#endif // __wrappedvorbisfileUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedvulkandefs.h b/src/wrapped/generated/wrappedvulkandefs.h new file mode 100644 index 0000000000..c55377ce1b --- /dev/null +++ b/src/wrapped/generated/wrappedvulkandefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedvulkanDEFS_H_ +#define __wrappedvulkanDEFS_H_ + + +#endif // __wrappedvulkanDEFS_H_ diff --git a/src/wrapped/generated/wrappedvulkantypes.h b/src/wrapped/generated/wrappedvulkantypes.h index 17d59ad80d..a15917b7ea 100644 --- a/src/wrapped/generated/wrappedvulkantypes.h +++ b/src/wrapped/generated/wrappedvulkantypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedvulkanTYPES_H_ #define __wrappedvulkanTYPES_H_ diff --git a/src/wrapped/generated/wrappedvulkanundefs.h b/src/wrapped/generated/wrappedvulkanundefs.h new file mode 100644 index 0000000000..c9e3830654 --- /dev/null +++ b/src/wrapped/generated/wrappedvulkanundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedvulkanUNDEFS_H_ +#define __wrappedvulkanUNDEFS_H_ + + +#endif // __wrappedvulkanUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedwaylandclientdefs.h b/src/wrapped/generated/wrappedwaylandclientdefs.h new file mode 100644 index 0000000000..1305954d60 --- /dev/null +++ b/src/wrapped/generated/wrappedwaylandclientdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedwaylandclientDEFS_H_ +#define __wrappedwaylandclientDEFS_H_ + + +#endif // __wrappedwaylandclientDEFS_H_ diff --git a/src/wrapped/generated/wrappedwaylandclienttypes.h b/src/wrapped/generated/wrappedwaylandclienttypes.h new file mode 100644 index 0000000000..2872c956d5 --- /dev/null +++ b/src/wrapped/generated/wrappedwaylandclienttypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedwaylandclientTYPES_H_ +#define __wrappedwaylandclientTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedwaylandclientTYPES_H_ diff --git a/src/wrapped/generated/wrappedwaylandclientundefs.h b/src/wrapped/generated/wrappedwaylandclientundefs.h new file mode 100644 index 0000000000..5f934539e1 --- /dev/null +++ b/src/wrapped/generated/wrappedwaylandclientundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedwaylandclientUNDEFS_H_ +#define __wrappedwaylandclientUNDEFS_H_ + + +#endif // __wrappedwaylandclientUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedxineramadefs.h b/src/wrapped/generated/wrappedxineramadefs.h new file mode 100644 index 0000000000..e01e10c9a6 --- /dev/null +++ b/src/wrapped/generated/wrappedxineramadefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedxineramaDEFS_H_ +#define __wrappedxineramaDEFS_H_ + + +#endif // __wrappedxineramaDEFS_H_ diff --git a/src/wrapped/generated/wrappedxineramatypes.h b/src/wrapped/generated/wrappedxineramatypes.h new file mode 100644 index 0000000000..4bc07ce0f1 --- /dev/null +++ b/src/wrapped/generated/wrappedxineramatypes.h @@ -0,0 +1,17 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedxineramaTYPES_H_ +#define __wrappedxineramaTYPES_H_ + +#ifndef LIBNAME +#error You should only #include this file inside a wrapped*.c file +#endif +#ifndef ADDED_FUNCTIONS +#define ADDED_FUNCTIONS() +#endif + + +#define SUPER() ADDED_FUNCTIONS() + +#endif // __wrappedxineramaTYPES_H_ diff --git a/src/wrapped/generated/wrappedxineramaundefs.h b/src/wrapped/generated/wrappedxineramaundefs.h new file mode 100644 index 0000000000..dc5107250f --- /dev/null +++ b/src/wrapped/generated/wrappedxineramaundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedxineramaUNDEFS_H_ +#define __wrappedxineramaUNDEFS_H_ + + +#endif // __wrappedxineramaUNDEFS_H_ diff --git a/src/wrapped/generated/wrappedxml2defs.h b/src/wrapped/generated/wrappedxml2defs.h new file mode 100644 index 0000000000..c5d40edd17 --- /dev/null +++ b/src/wrapped/generated/wrappedxml2defs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedxml2DEFS_H_ +#define __wrappedxml2DEFS_H_ + + +#endif // __wrappedxml2DEFS_H_ diff --git a/src/wrapped/generated/wrappedxml2types.h b/src/wrapped/generated/wrappedxml2types.h index d1bf12469d..e5f5c155d9 100644 --- a/src/wrapped/generated/wrappedxml2types.h +++ b/src/wrapped/generated/wrappedxml2types.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedxml2TYPES_H_ #define __wrappedxml2TYPES_H_ diff --git a/src/wrapped/generated/wrappedxml2undefs.h b/src/wrapped/generated/wrappedxml2undefs.h new file mode 100644 index 0000000000..194fd8abae --- /dev/null +++ b/src/wrapped/generated/wrappedxml2undefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedxml2UNDEFS_H_ +#define __wrappedxml2UNDEFS_H_ + + +#endif // __wrappedxml2UNDEFS_H_ diff --git a/src/wrapped/generated/wrappedxsltdefs.h b/src/wrapped/generated/wrappedxsltdefs.h new file mode 100644 index 0000000000..7b907af045 --- /dev/null +++ b/src/wrapped/generated/wrappedxsltdefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedxsltDEFS_H_ +#define __wrappedxsltDEFS_H_ + + +#endif // __wrappedxsltDEFS_H_ diff --git a/src/wrapped/generated/wrappedxslttypes.h b/src/wrapped/generated/wrappedxslttypes.h index b3707c3e23..cb5b6d36ec 100644 --- a/src/wrapped/generated/wrappedxslttypes.h +++ b/src/wrapped/generated/wrappedxslttypes.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __wrappedxsltTYPES_H_ #define __wrappedxsltTYPES_H_ diff --git a/src/wrapped/generated/wrappedxsltundefs.h b/src/wrapped/generated/wrappedxsltundefs.h new file mode 100644 index 0000000000..1724f619f2 --- /dev/null +++ b/src/wrapped/generated/wrappedxsltundefs.h @@ -0,0 +1,8 @@ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ +#ifndef __wrappedxsltUNDEFS_H_ +#define __wrappedxsltUNDEFS_H_ + + +#endif // __wrappedxsltUNDEFS_H_ diff --git a/src/wrapped/generated/wrapper.c b/src/wrapped/generated/wrapper.c index 8ce2d3c8fa..e10fa1924c 100644 --- a/src/wrapped/generated/wrapper.c +++ b/src/wrapped/generated/wrapper.c @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #include #include #include @@ -70,7 +70,6 @@ void VulkanTox86(void* src, void* save); int of_convert(int); -typedef void (*vFE_t)(x86emu_t*); typedef void (*vFv_t)(void); typedef void (*vFi_t)(int32_t); typedef void (*vFu_t)(uint32_t); @@ -89,7 +88,6 @@ typedef int8_t (*cFf_t)(float); typedef int8_t (*cFp_t)(void*); typedef int8_t (*cFG_t)(void*); typedef int16_t (*wFp_t)(void*); -typedef int32_t (*iFE_t)(x86emu_t*); typedef int32_t (*iFv_t)(void); typedef int32_t (*iFw_t)(int16_t); typedef int32_t (*iFi_t)(int32_t); @@ -115,7 +113,6 @@ typedef uint8_t (*CFp_t)(void*); typedef uint8_t (*CFG_t)(void*); typedef uint16_t (*WFi_t)(int32_t); typedef uint16_t (*WFp_t)(void*); -typedef uint32_t (*uFE_t)(x86emu_t*); typedef uint32_t (*uFv_t)(void); typedef uint32_t (*uFi_t)(int32_t); typedef uint32_t (*uFu_t)(uint32_t); @@ -127,8 +124,8 @@ typedef uint32_t (*uFG_t)(void*); typedef uint64_t (*UFv_t)(void); typedef uint64_t (*UFu_t)(uint32_t); typedef uint64_t (*UFp_t)(void*); -typedef uint64_t (*UFV_t)(void*); typedef uint64_t (*UFG_t)(void*); +typedef uint64_t (*UFs_t)(void*); typedef float (*fFi_t)(int32_t); typedef float (*fFf_t)(float); typedef float (*fFp_t)(void*); @@ -146,9 +143,9 @@ typedef intptr_t (*lFp_t)(void*); typedef intptr_t (*lFG_t)(void*); typedef uintptr_t (*LFv_t)(void); typedef uintptr_t (*LFu_t)(uint32_t); +typedef uintptr_t (*LFL_t)(uintptr_t); typedef uintptr_t (*LFp_t)(void*); typedef uintptr_t (*LFG_t)(void*); -typedef void* (*pFE_t)(x86emu_t*); typedef void* (*pFv_t)(void); typedef void* (*pFw_t)(int16_t); typedef void* (*pFi_t)(int32_t); @@ -163,6 +160,7 @@ typedef void* (*pFL_t)(uintptr_t); typedef void* (*pFp_t)(void*); typedef void* (*pFV_t)(void*); typedef void* (*pFG_t)(void*); +typedef void (*vFEv_t)(x86emu_t*); typedef void (*vFEp_t)(x86emu_t*, void*); typedef void (*vFii_t)(int32_t, int32_t); typedef void (*vFiI_t)(int32_t, int64_t); @@ -215,9 +213,9 @@ typedef void (*vFGL_t)(void*, uintptr_t); typedef void (*vFGp_t)(void*, void*); typedef void (*vFGG_t)(void*, void*); typedef int8_t (*cFpp_t)(void*, void*); +typedef int32_t (*iFEv_t)(x86emu_t*); typedef int32_t (*iFEL_t)(x86emu_t*, uintptr_t); typedef int32_t (*iFEp_t)(x86emu_t*, void*); -typedef int32_t (*iFEV_t)(x86emu_t*, void*); typedef int32_t (*iFwp_t)(int16_t, void*); typedef int32_t (*iFii_t)(int32_t, int32_t); typedef int32_t (*iFiI_t)(int32_t, int64_t); @@ -229,8 +227,6 @@ typedef int32_t (*iFui_t)(uint32_t, int32_t); typedef int32_t (*iFuu_t)(uint32_t, uint32_t); typedef int32_t (*iFup_t)(uint32_t, void*); typedef int32_t (*iFli_t)(intptr_t, int32_t); -typedef int32_t (*iFLi_t)(uintptr_t, int32_t); -typedef int32_t (*iFLp_t)(uintptr_t, void*); typedef int32_t (*iFpw_t)(void*, int16_t); typedef int32_t (*iFpi_t)(void*, int32_t); typedef int32_t (*iFpI_t)(void*, int64_t); @@ -243,6 +239,7 @@ typedef int32_t (*iFpd_t)(void*, double); typedef int32_t (*iFpl_t)(void*, intptr_t); typedef int32_t (*iFpL_t)(void*, uintptr_t); typedef int32_t (*iFpp_t)(void*, void*); +typedef int32_t (*iFpV_t)(void*, void*); typedef int32_t (*iFpO_t)(void*, int32_t); typedef int32_t (*iFpP_t)(void*, void*); typedef int32_t (*iFpG_t)(void*, void*); @@ -257,8 +254,10 @@ typedef uint8_t (*CFui_t)(uint32_t, int32_t); typedef uint8_t (*CFpi_t)(void*, int32_t); typedef uint8_t (*CFpu_t)(void*, uint32_t); typedef uint8_t (*CFpp_t)(void*, void*); +typedef uint32_t (*uFEv_t)(x86emu_t*); typedef uint32_t (*uFEu_t)(x86emu_t*, uint32_t); typedef uint32_t (*uFEp_t)(x86emu_t*, void*); +typedef uint32_t (*uFii_t)(int32_t, int32_t); typedef uint32_t (*uFiu_t)(int32_t, uint32_t); typedef uint32_t (*uFui_t)(uint32_t, int32_t); typedef uint32_t (*uFuu_t)(uint32_t, uint32_t); @@ -275,7 +274,7 @@ typedef uint64_t (*UFuu_t)(uint32_t, uint32_t); typedef uint64_t (*UFUU_t)(uint64_t, uint64_t); typedef uint64_t (*UFUp_t)(uint64_t, void*); typedef uint64_t (*UFpp_t)(void*, void*); -typedef uint64_t (*UFVV_t)(void*, void*); +typedef uint64_t (*UFss_t)(void*, void*); typedef float (*fFEp_t)(x86emu_t*, void*); typedef float (*fFif_t)(int32_t, float); typedef float (*fFfi_t)(float, int32_t); @@ -298,15 +297,13 @@ typedef intptr_t (*lFpi_t)(void*, int32_t); typedef intptr_t (*lFpp_t)(void*, void*); typedef uintptr_t (*LFii_t)(int32_t, int32_t); typedef uintptr_t (*LFLi_t)(uintptr_t, int32_t); -typedef uintptr_t (*LFLp_t)(uintptr_t, void*); typedef uintptr_t (*LFpL_t)(void*, uintptr_t); typedef uintptr_t (*LFpp_t)(void*, void*); +typedef void* (*pFEv_t)(x86emu_t*); typedef void* (*pFEi_t)(x86emu_t*, int32_t); typedef void* (*pFEp_t)(x86emu_t*, void*); -typedef void* (*pFEV_t)(x86emu_t*, void*); typedef void* (*pFii_t)(int32_t, int32_t); typedef void* (*pFiu_t)(int32_t, uint32_t); -typedef void* (*pFiL_t)(int32_t, uintptr_t); typedef void* (*pFip_t)(int32_t, void*); typedef void* (*pFiV_t)(int32_t, void*); typedef void* (*pFui_t)(uint32_t, int32_t); @@ -329,6 +326,7 @@ typedef void* (*pFpL_t)(void*, uintptr_t); typedef void* (*pFpp_t)(void*, void*); typedef void* (*pFpV_t)(void*, void*); typedef void* (*pFpG_t)(void*, void*); +typedef void* (*pFps_t)(void*, void*); typedef void* (*pFSi_t)(void*, int32_t); typedef void (*vFEip_t)(x86emu_t*, int32_t, void*); typedef void (*vFEpi_t)(x86emu_t*, void*, int32_t); @@ -419,7 +417,6 @@ typedef int32_t (*iFiwC_t)(int32_t, int16_t, uint8_t); typedef int32_t (*iFiii_t)(int32_t, int32_t, int32_t); typedef int32_t (*iFiiI_t)(int32_t, int32_t, int64_t); typedef int32_t (*iFiiu_t)(int32_t, int32_t, uint32_t); -typedef int32_t (*iFiiL_t)(int32_t, int32_t, uintptr_t); typedef int32_t (*iFiip_t)(int32_t, int32_t, void*); typedef int32_t (*iFiiO_t)(int32_t, int32_t, int32_t); typedef int32_t (*iFiII_t)(int32_t, int64_t, int64_t); @@ -431,6 +428,7 @@ typedef int32_t (*iFipu_t)(int32_t, void*, uint32_t); typedef int32_t (*iFipL_t)(int32_t, void*, uintptr_t); typedef int32_t (*iFipp_t)(int32_t, void*, void*); typedef int32_t (*iFCiW_t)(uint8_t, int32_t, uint16_t); +typedef int32_t (*iFuwp_t)(uint32_t, int16_t, void*); typedef int32_t (*iFuii_t)(uint32_t, int32_t, int32_t); typedef int32_t (*iFuip_t)(uint32_t, int32_t, void*); typedef int32_t (*iFuui_t)(uint32_t, uint32_t, int32_t); @@ -440,7 +438,6 @@ typedef int32_t (*iFuff_t)(uint32_t, float, float); typedef int32_t (*iFuLp_t)(uint32_t, uintptr_t, void*); typedef int32_t (*iFupp_t)(uint32_t, void*, void*); typedef int32_t (*iFfff_t)(float, float, float); -typedef int32_t (*iFLwp_t)(uintptr_t, int16_t, void*); typedef int32_t (*iFpwp_t)(void*, int16_t, void*); typedef int32_t (*iFpii_t)(void*, int32_t, int32_t); typedef int32_t (*iFpiu_t)(void*, int32_t, uint32_t); @@ -468,7 +465,6 @@ typedef int32_t (*iFpli_t)(void*, intptr_t, int32_t); typedef int32_t (*iFpll_t)(void*, intptr_t, intptr_t); typedef int32_t (*iFplp_t)(void*, intptr_t, void*); typedef int32_t (*iFpLi_t)(void*, uintptr_t, int32_t); -typedef int32_t (*iFpLL_t)(void*, uintptr_t, uintptr_t); typedef int32_t (*iFpLp_t)(void*, uintptr_t, void*); typedef int32_t (*iFppi_t)(void*, void*, int32_t); typedef int32_t (*iFppI_t)(void*, void*, int64_t); @@ -498,8 +494,6 @@ typedef uint32_t (*uFEpU_t)(x86emu_t*, void*, uint64_t); typedef uint32_t (*uFEpp_t)(x86emu_t*, void*, void*); typedef uint32_t (*uFipu_t)(int32_t, void*, uint32_t); typedef uint32_t (*uFuip_t)(uint32_t, int32_t, void*); -typedef uint32_t (*uFuui_t)(uint32_t, uint32_t, int32_t); -typedef uint32_t (*uFuuI_t)(uint32_t, uint32_t, int64_t); typedef uint32_t (*uFuuu_t)(uint32_t, uint32_t, uint32_t); typedef uint32_t (*uFuup_t)(uint32_t, uint32_t, void*); typedef uint32_t (*uFupi_t)(uint32_t, void*, int32_t); @@ -517,7 +511,6 @@ typedef uint32_t (*uFppu_t)(void*, void*, uint32_t); typedef uint32_t (*uFppp_t)(void*, void*, void*); typedef uint64_t (*UFppi_t)(void*, void*, int32_t); typedef uint64_t (*UFppu_t)(void*, void*, uint32_t); -typedef float (*fFuii_t)(uint32_t, int32_t, int32_t); typedef float (*fFull_t)(uint32_t, intptr_t, intptr_t); typedef float (*fFfff_t)(float, float, float); typedef float (*fFffp_t)(float, float, void*); @@ -533,12 +526,15 @@ typedef intptr_t (*lFipi_t)(int32_t, void*, int32_t); typedef intptr_t (*lFipL_t)(int32_t, void*, uintptr_t); typedef intptr_t (*lFlll_t)(intptr_t, intptr_t, intptr_t); typedef intptr_t (*lFlpi_t)(intptr_t, void*, int32_t); +typedef intptr_t (*lFpli_t)(void*, intptr_t, int32_t); typedef intptr_t (*lFpLp_t)(void*, uintptr_t, void*); typedef intptr_t (*lFppi_t)(void*, void*, int32_t); typedef intptr_t (*lFppL_t)(void*, void*, uintptr_t); typedef intptr_t (*lFSpl_t)(void*, void*, intptr_t); typedef uintptr_t (*LFiii_t)(int32_t, int32_t, int32_t); -typedef uintptr_t (*LFpii_t)(void*, int32_t, int32_t); +typedef uintptr_t (*LFLLl_t)(uintptr_t, uintptr_t, intptr_t); +typedef uintptr_t (*LFLpu_t)(uintptr_t, void*, uint32_t); +typedef uintptr_t (*LFLpL_t)(uintptr_t, void*, uintptr_t); typedef uintptr_t (*LFpip_t)(void*, int32_t, void*); typedef uintptr_t (*LFpLi_t)(void*, uintptr_t, int32_t); typedef uintptr_t (*LFpLp_t)(void*, uintptr_t, void*); @@ -599,8 +595,8 @@ typedef void* (*pFppf_t)(void*, void*, float); typedef void* (*pFppl_t)(void*, void*, intptr_t); typedef void* (*pFppL_t)(void*, void*, uintptr_t); typedef void* (*pFppp_t)(void*, void*, void*); -typedef void* (*pFpVV_t)(void*, void*, void*); typedef void* (*pFpOM_t)(void*, int32_t, ...); +typedef void* (*pFpss_t)(void*, void*, void*); typedef void* (*pFSpl_t)(void*, void*, intptr_t); typedef void* (*pFSpp_t)(void*, void*, void*); typedef void (*vFEiip_t)(x86emu_t*, int32_t, int32_t, void*); @@ -750,7 +746,6 @@ typedef int32_t (*iFEppu_t)(x86emu_t*, void*, void*, uint32_t); typedef int32_t (*iFEppL_t)(x86emu_t*, void*, void*, uintptr_t); typedef int32_t (*iFEppp_t)(x86emu_t*, void*, void*, void*); typedef int32_t (*iFEppV_t)(x86emu_t*, void*, void*, void*); -typedef int32_t (*iFEpVV_t)(x86emu_t*, void*, void*, void*); typedef int32_t (*iFEpOu_t)(x86emu_t*, void*, int32_t, uint32_t); typedef int32_t (*iFEpOV_t)(x86emu_t*, void*, int32_t, void*); typedef int32_t (*iFEPpp_t)(x86emu_t*, void*, void*, void*); @@ -760,13 +755,13 @@ typedef int32_t (*iFiiii_t)(int32_t, int32_t, int32_t, int32_t); typedef int32_t (*iFiiiu_t)(int32_t, int32_t, int32_t, uint32_t); typedef int32_t (*iFiiip_t)(int32_t, int32_t, int32_t, void*); typedef int32_t (*iFiiII_t)(int32_t, int32_t, int64_t, int64_t); -typedef int32_t (*iFiiLi_t)(int32_t, int32_t, uintptr_t, int32_t); +typedef int32_t (*iFiiui_t)(int32_t, int32_t, uint32_t, int32_t); typedef int32_t (*iFiipi_t)(int32_t, int32_t, void*, int32_t); typedef int32_t (*iFiipp_t)(int32_t, int32_t, void*, void*); +typedef int32_t (*iFiuwp_t)(int32_t, uint32_t, int16_t, void*); typedef int32_t (*iFiuii_t)(int32_t, uint32_t, int32_t, int32_t); typedef int32_t (*iFiuui_t)(int32_t, uint32_t, uint32_t, int32_t); typedef int32_t (*iFiupp_t)(int32_t, uint32_t, void*, void*); -typedef int32_t (*iFiLwp_t)(int32_t, uintptr_t, int16_t, void*); typedef int32_t (*iFipii_t)(int32_t, void*, int32_t, int32_t); typedef int32_t (*iFipip_t)(int32_t, void*, int32_t, void*); typedef int32_t (*iFipui_t)(int32_t, void*, uint32_t, int32_t); @@ -783,10 +778,11 @@ typedef int32_t (*iFuuff_t)(uint32_t, uint32_t, float, float); typedef int32_t (*iFupup_t)(uint32_t, void*, uint32_t, void*); typedef int32_t (*iFuppi_t)(uint32_t, void*, void*, int32_t); typedef int32_t (*iFuppp_t)(uint32_t, void*, void*, void*); +typedef int32_t (*iFpwww_t)(void*, int16_t, int16_t, int16_t); +typedef int32_t (*iFpwpp_t)(void*, int16_t, void*, void*); typedef int32_t (*iFpiii_t)(void*, int32_t, int32_t, int32_t); typedef int32_t (*iFpiiu_t)(void*, int32_t, int32_t, uint32_t); typedef int32_t (*iFpiid_t)(void*, int32_t, int32_t, double); -typedef int32_t (*iFpiiL_t)(void*, int32_t, int32_t, uintptr_t); typedef int32_t (*iFpiip_t)(void*, int32_t, int32_t, void*); typedef int32_t (*iFpiuu_t)(void*, int32_t, uint32_t, uint32_t); typedef int32_t (*iFpiuL_t)(void*, int32_t, uint32_t, uintptr_t); @@ -800,6 +796,7 @@ typedef int32_t (*iFpIip_t)(void*, int64_t, int32_t, void*); typedef int32_t (*iFpCCC_t)(void*, uint8_t, uint8_t, uint8_t); typedef int32_t (*iFpCpi_t)(void*, uint8_t, void*, int32_t); typedef int32_t (*iFpWWu_t)(void*, uint16_t, uint16_t, uint32_t); +typedef int32_t (*iFpuwp_t)(void*, uint32_t, int16_t, void*); typedef int32_t (*iFpuii_t)(void*, uint32_t, int32_t, int32_t); typedef int32_t (*iFpuiu_t)(void*, uint32_t, int32_t, uint32_t); typedef int32_t (*iFpuiL_t)(void*, uint32_t, int32_t, uintptr_t); @@ -820,7 +817,6 @@ typedef int32_t (*iFpUUU_t)(void*, uint64_t, uint64_t, uint64_t); typedef int32_t (*iFpUpp_t)(void*, uint64_t, void*, void*); typedef int32_t (*iFplii_t)(void*, intptr_t, int32_t, int32_t); typedef int32_t (*iFplip_t)(void*, intptr_t, int32_t, void*); -typedef int32_t (*iFpLwp_t)(void*, uintptr_t, int16_t, void*); typedef int32_t (*iFpLpi_t)(void*, uintptr_t, void*, int32_t); typedef int32_t (*iFpLpL_t)(void*, uintptr_t, void*, uintptr_t); typedef int32_t (*iFppii_t)(void*, void*, int32_t, int32_t); @@ -917,6 +913,7 @@ typedef void* (*pFipip_t)(int32_t, void*, int32_t, void*); typedef void* (*pFippi_t)(int32_t, void*, void*, int32_t); typedef void* (*pFippu_t)(int32_t, void*, void*, uint32_t); typedef void* (*pFuiii_t)(uint32_t, int32_t, int32_t, int32_t); +typedef void* (*pFuuuu_t)(uint32_t, uint32_t, uint32_t, uint32_t); typedef void* (*pFulli_t)(uint32_t, intptr_t, intptr_t, int32_t); typedef void* (*pFullu_t)(uint32_t, intptr_t, intptr_t, uint32_t); typedef void* (*pFffff_t)(float, float, float, float); @@ -984,7 +981,6 @@ typedef void (*vFiplll_t)(int32_t, void*, intptr_t, intptr_t, intptr_t); typedef void (*vFuiiii_t)(uint32_t, int32_t, int32_t, int32_t, int32_t); typedef void (*vFuiiiu_t)(uint32_t, int32_t, int32_t, int32_t, uint32_t); typedef void (*vFuiiip_t)(uint32_t, int32_t, int32_t, int32_t, void*); -typedef void (*vFuiiup_t)(uint32_t, int32_t, int32_t, uint32_t, void*); typedef void (*vFuiifi_t)(uint32_t, int32_t, int32_t, float, int32_t); typedef void (*vFuiIII_t)(uint32_t, int32_t, int64_t, int64_t, int64_t); typedef void (*vFuiuii_t)(uint32_t, int32_t, uint32_t, int32_t, int32_t); @@ -1076,11 +1072,12 @@ typedef int32_t (*iFEiipV_t)(x86emu_t*, int32_t, int32_t, void*, void*); typedef int32_t (*iFEipuu_t)(x86emu_t*, int32_t, void*, uint32_t, uint32_t); typedef int32_t (*iFEippi_t)(x86emu_t*, int32_t, void*, void*, int32_t); typedef int32_t (*iFEippp_t)(x86emu_t*, int32_t, void*, void*, void*); -typedef int32_t (*iFEipVV_t)(x86emu_t*, int32_t, void*, void*, void*); +typedef int32_t (*iFEuuuu_t)(x86emu_t*, uint32_t, uint32_t, uint32_t, uint32_t); typedef int32_t (*iFEpiii_t)(x86emu_t*, void*, int32_t, int32_t, int32_t); typedef int32_t (*iFEpiup_t)(x86emu_t*, void*, int32_t, uint32_t, void*); typedef int32_t (*iFEpipi_t)(x86emu_t*, void*, int32_t, void*, int32_t); typedef int32_t (*iFEpipp_t)(x86emu_t*, void*, int32_t, void*, void*); +typedef int32_t (*iFEpipV_t)(x86emu_t*, void*, int32_t, void*, void*); typedef int32_t (*iFEpupV_t)(x86emu_t*, void*, uint32_t, void*, void*); typedef int32_t (*iFEpUup_t)(x86emu_t*, void*, uint64_t, uint32_t, void*); typedef int32_t (*iFEpLpp_t)(x86emu_t*, void*, uintptr_t, void*, void*); @@ -1091,7 +1088,6 @@ typedef int32_t (*iFEppiV_t)(x86emu_t*, void*, void*, int32_t, void*); typedef int32_t (*iFEpplp_t)(x86emu_t*, void*, void*, intptr_t, void*); typedef int32_t (*iFEpppp_t)(x86emu_t*, void*, void*, void*, void*); typedef int32_t (*iFEpppV_t)(x86emu_t*, void*, void*, void*, void*); -typedef int32_t (*iFEppVV_t)(x86emu_t*, void*, void*, void*, void*); typedef int32_t (*iFEpPpp_t)(x86emu_t*, void*, void*, void*, void*); typedef int32_t (*iFiiipu_t)(int32_t, int32_t, int32_t, void*, uint32_t); typedef int32_t (*iFiiipp_t)(int32_t, int32_t, int32_t, void*, void*); @@ -1108,16 +1104,18 @@ typedef int32_t (*iFippup_t)(int32_t, void*, void*, uint32_t, void*); typedef int32_t (*iFipppi_t)(int32_t, void*, void*, void*, int32_t); typedef int32_t (*iFipppp_t)(int32_t, void*, void*, void*, void*); typedef int32_t (*iFuppup_t)(uint32_t, void*, void*, uint32_t, void*); +typedef int32_t (*iFpwwww_t)(void*, int16_t, int16_t, int16_t, int16_t); +typedef int32_t (*iFpwppp_t)(void*, int16_t, void*, void*, void*); typedef int32_t (*iFpiiii_t)(void*, int32_t, int32_t, int32_t, int32_t); typedef int32_t (*iFpiiiu_t)(void*, int32_t, int32_t, int32_t, uint32_t); typedef int32_t (*iFpiiiL_t)(void*, int32_t, int32_t, int32_t, uintptr_t); typedef int32_t (*iFpiiip_t)(void*, int32_t, int32_t, int32_t, void*); +typedef int32_t (*iFpiiui_t)(void*, int32_t, int32_t, uint32_t, int32_t); typedef int32_t (*iFpiiuu_t)(void*, int32_t, int32_t, uint32_t, uint32_t); -typedef int32_t (*iFpiiLi_t)(void*, int32_t, int32_t, uintptr_t, int32_t); typedef int32_t (*iFpiipi_t)(void*, int32_t, int32_t, void*, int32_t); typedef int32_t (*iFpiipp_t)(void*, int32_t, int32_t, void*, void*); +typedef int32_t (*iFpiuwp_t)(void*, int32_t, uint32_t, int16_t, void*); typedef int32_t (*iFpiupu_t)(void*, int32_t, uint32_t, void*, uint32_t); -typedef int32_t (*iFpiLwp_t)(void*, int32_t, uintptr_t, int16_t, void*); typedef int32_t (*iFpipii_t)(void*, int32_t, void*, int32_t, int32_t); typedef int32_t (*iFpipiL_t)(void*, int32_t, void*, int32_t, uintptr_t); typedef int32_t (*iFpipip_t)(void*, int32_t, void*, int32_t, void*); @@ -1146,12 +1144,12 @@ typedef int32_t (*iFppiip_t)(void*, void*, int32_t, int32_t, void*); typedef int32_t (*iFppiup_t)(void*, void*, int32_t, uint32_t, void*); typedef int32_t (*iFppipi_t)(void*, void*, int32_t, void*, int32_t); typedef int32_t (*iFppipp_t)(void*, void*, int32_t, void*, void*); +typedef int32_t (*iFppuwp_t)(void*, void*, uint32_t, int16_t, void*); typedef int32_t (*iFppuip_t)(void*, void*, uint32_t, int32_t, void*); typedef int32_t (*iFppupi_t)(void*, void*, uint32_t, void*, int32_t); typedef int32_t (*iFppupp_t)(void*, void*, uint32_t, void*, void*); typedef int32_t (*iFppllp_t)(void*, void*, intptr_t, intptr_t, void*); typedef int32_t (*iFpplpp_t)(void*, void*, intptr_t, void*, void*); -typedef int32_t (*iFppLwp_t)(void*, void*, uintptr_t, int16_t, void*); typedef int32_t (*iFppLip_t)(void*, void*, uintptr_t, int32_t, void*); typedef int32_t (*iFppLpi_t)(void*, void*, uintptr_t, void*, int32_t); typedef int32_t (*iFppLpL_t)(void*, void*, uintptr_t, void*, uintptr_t); @@ -1162,6 +1160,7 @@ typedef int32_t (*iFpppip_t)(void*, void*, void*, int32_t, void*); typedef int32_t (*iFpppui_t)(void*, void*, void*, uint32_t, int32_t); typedef int32_t (*iFpppuu_t)(void*, void*, void*, uint32_t, uint32_t); typedef int32_t (*iFpppup_t)(void*, void*, void*, uint32_t, void*); +typedef int32_t (*iFpppLi_t)(void*, void*, void*, uintptr_t, int32_t); typedef int32_t (*iFppppi_t)(void*, void*, void*, void*, int32_t); typedef int32_t (*iFppppu_t)(void*, void*, void*, void*, uint32_t); typedef int32_t (*iFppppL_t)(void*, void*, void*, void*, uintptr_t); @@ -1284,7 +1283,6 @@ typedef void (*vFuiupiu_t)(uint32_t, int32_t, uint32_t, void*, int32_t, uint32_t typedef void (*vFuiUUUU_t)(uint32_t, int32_t, uint64_t, uint64_t, uint64_t, uint64_t); typedef void (*vFuiffff_t)(uint32_t, int32_t, float, float, float, float); typedef void (*vFuidddd_t)(uint32_t, int32_t, double, double, double, double); -typedef void (*vFuipiup_t)(uint32_t, int32_t, void*, int32_t, uint32_t, void*); typedef void (*vFuuiiii_t)(uint32_t, uint32_t, int32_t, int32_t, int32_t, int32_t); typedef void (*vFuuiiiu_t)(uint32_t, uint32_t, int32_t, int32_t, int32_t, uint32_t); typedef void (*vFuuiuii_t)(uint32_t, uint32_t, int32_t, uint32_t, int32_t, int32_t); @@ -1369,17 +1367,14 @@ typedef int32_t (*iFEpiipV_t)(x86emu_t*, void*, int32_t, int32_t, void*, void*); typedef int32_t (*iFEpiLpp_t)(x86emu_t*, void*, int32_t, uintptr_t, void*, void*); typedef int32_t (*iFEpippi_t)(x86emu_t*, void*, int32_t, void*, void*, int32_t); typedef int32_t (*iFEpippp_t)(x86emu_t*, void*, int32_t, void*, void*, void*); -typedef int32_t (*iFEpipVV_t)(x86emu_t*, void*, int32_t, void*, void*, void*); typedef int32_t (*iFEpuuip_t)(x86emu_t*, void*, uint32_t, uint32_t, int32_t, void*); typedef int32_t (*iFEpuppp_t)(x86emu_t*, void*, uint32_t, void*, void*, void*); -typedef int32_t (*iFEpupVV_t)(x86emu_t*, void*, uint32_t, void*, void*, void*); typedef int32_t (*iFEpUPpp_t)(x86emu_t*, void*, uint64_t, void*, void*, void*); typedef int32_t (*iFEpLppp_t)(x86emu_t*, void*, uintptr_t, void*, void*, void*); -typedef int32_t (*iFEpLpVV_t)(x86emu_t*, void*, uintptr_t, void*, void*, void*); typedef int32_t (*iFEppppp_t)(x86emu_t*, void*, void*, void*, void*, void*); typedef int32_t (*iFiiiiii_t)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); typedef int32_t (*iFiiiiip_t)(int32_t, int32_t, int32_t, int32_t, int32_t, void*); -typedef int32_t (*iFiiiLwp_t)(int32_t, int32_t, int32_t, uintptr_t, int16_t, void*); +typedef int32_t (*iFiiiuwp_t)(int32_t, int32_t, int32_t, uint32_t, int16_t, void*); typedef int32_t (*iFiuiipi_t)(int32_t, uint32_t, int32_t, int32_t, void*, int32_t); typedef int32_t (*iFipipuu_t)(int32_t, void*, int32_t, void*, uint32_t, uint32_t); typedef int32_t (*iFipuufp_t)(int32_t, void*, uint32_t, uint32_t, float, void*); @@ -1497,10 +1492,8 @@ typedef void (*vFEpuipuV_t)(x86emu_t*, void*, uint32_t, int32_t, void*, uint32_t typedef void (*vFEpppppp_t)(x86emu_t*, void*, void*, void*, void*, void*, void*); typedef void (*vFiiiiiip_t)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, void*); typedef void (*vFiiiiuup_t)(int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, void*); -typedef void (*vFiiupuip_t)(int32_t, int32_t, uint32_t, void*, uint32_t, int32_t, void*); typedef void (*vFiiffffp_t)(int32_t, int32_t, float, float, float, float, void*); typedef void (*vFiipllli_t)(int32_t, int32_t, void*, intptr_t, intptr_t, intptr_t, int32_t); -typedef void (*vFiupuuup_t)(int32_t, uint32_t, void*, uint32_t, uint32_t, uint32_t, void*); typedef void (*vFuiiiiii_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); typedef void (*vFuiiiuip_t)(uint32_t, int32_t, int32_t, int32_t, uint32_t, int32_t, void*); typedef void (*vFuiiiuup_t)(uint32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, void*); @@ -1576,6 +1569,7 @@ typedef void (*vFppppppp_t)(void*, void*, void*, void*, void*, void*, void*); typedef int32_t (*iFEpuiupV_t)(x86emu_t*, void*, uint32_t, int32_t, uint32_t, void*, void*); typedef int32_t (*iFEpupppp_t)(x86emu_t*, void*, uint32_t, void*, void*, void*, void*); typedef int32_t (*iFEpUuppp_t)(x86emu_t*, void*, uint64_t, uint32_t, void*, void*, void*); +typedef int32_t (*iFEpLiipV_t)(x86emu_t*, void*, uintptr_t, int32_t, int32_t, void*, void*); typedef int32_t (*iFEppiuui_t)(x86emu_t*, void*, void*, int32_t, uint32_t, uint32_t, int32_t); typedef int32_t (*iFEppupIi_t)(x86emu_t*, void*, void*, uint32_t, void*, int64_t, int32_t); typedef int32_t (*iFEppuppp_t)(x86emu_t*, void*, void*, uint32_t, void*, void*, void*); @@ -1585,7 +1579,7 @@ typedef int32_t (*iFEpppppp_t)(x86emu_t*, void*, void*, void*, void*, void*, voi typedef int32_t (*iFiiiiiip_t)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, void*); typedef int32_t (*iFpiiiiii_t)(void*, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); typedef int32_t (*iFpiiiiip_t)(void*, int32_t, int32_t, int32_t, int32_t, int32_t, void*); -typedef int32_t (*iFpiiiLwp_t)(void*, int32_t, int32_t, int32_t, uintptr_t, int16_t, void*); +typedef int32_t (*iFpiiiuwp_t)(void*, int32_t, int32_t, int32_t, uint32_t, int16_t, void*); typedef int32_t (*iFpiiuuiu_t)(void*, int32_t, int32_t, uint32_t, uint32_t, int32_t, uint32_t); typedef int32_t (*iFpiiuuuu_t)(void*, int32_t, int32_t, uint32_t, uint32_t, uint32_t, uint32_t); typedef int32_t (*iFpiipppp_t)(void*, int32_t, int32_t, void*, void*, void*, void*); @@ -1683,13 +1677,10 @@ typedef void (*vFEppipppp_t)(x86emu_t*, void*, void*, int32_t, void*, void*, voi typedef void (*vFEpppuipV_t)(x86emu_t*, void*, void*, void*, uint32_t, int32_t, void*, void*); typedef void (*vFEpppppuu_t)(x86emu_t*, void*, void*, void*, void*, void*, uint32_t, uint32_t); typedef void (*vFiiiiuuip_t)(int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, int32_t, void*); -typedef void (*vFiupuiuup_t)(int32_t, uint32_t, void*, uint32_t, int32_t, uint32_t, uint32_t, void*); -typedef void (*vFiupuuuup_t)(int32_t, uint32_t, void*, uint32_t, uint32_t, uint32_t, uint32_t, void*); typedef void (*vFilipufip_t)(int32_t, intptr_t, int32_t, void*, uint32_t, float, int32_t, void*); typedef void (*vFuiiiiiii_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); typedef void (*vFuiiiiill_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, intptr_t, intptr_t); typedef void (*vFuiiiiuup_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, void*); -typedef void (*vFuiiipiup_t)(uint32_t, int32_t, int32_t, int32_t, void*, int32_t, uint32_t, void*); typedef void (*vFuiuiiiii_t)(uint32_t, int32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t); typedef void (*vFuiuiiiip_t)(uint32_t, int32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, void*); typedef void (*vFuiulplpp_t)(uint32_t, int32_t, uint32_t, intptr_t, void*, intptr_t, void*, void*); @@ -1730,15 +1721,12 @@ typedef int32_t (*iFEpippppp_t)(x86emu_t*, void*, int32_t, void*, void*, void*, typedef int32_t (*iFEpuuiipp_t)(x86emu_t*, void*, uint32_t, uint32_t, int32_t, int32_t, void*, void*); typedef int32_t (*iFEpuuuipp_t)(x86emu_t*, void*, uint32_t, uint32_t, uint32_t, int32_t, void*, void*); typedef int32_t (*iFEpuuLppp_t)(x86emu_t*, void*, uint32_t, uint32_t, uintptr_t, void*, void*, void*); -typedef int32_t (*iFEpLiipVV_t)(x86emu_t*, void*, uintptr_t, int32_t, int32_t, void*, void*, void*); typedef int32_t (*iFEppppipp_t)(x86emu_t*, void*, void*, void*, void*, int32_t, void*, void*); typedef int32_t (*iFiiiiiiip_t)(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, void*); typedef int32_t (*iFiiupiupi_t)(int32_t, int32_t, uint32_t, void*, int32_t, uint32_t, void*, int32_t); -typedef int32_t (*iFuiifpppp_t)(uint32_t, int32_t, int32_t, float, void*, void*, void*, void*); typedef int32_t (*iFuipuuluf_t)(uint32_t, int32_t, void*, uint32_t, uint32_t, intptr_t, uint32_t, float); +typedef int32_t (*iFuuuuuuuu_t)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t); typedef int32_t (*iFullfpppp_t)(uint32_t, intptr_t, intptr_t, float, void*, void*, void*, void*); -typedef int32_t (*iFLLLLLLLL_t)(uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t); -typedef int32_t (*iFpiiiiipi_t)(void*, int32_t, int32_t, int32_t, int32_t, int32_t, void*, int32_t); typedef int32_t (*iFpCCWWpWu_t)(void*, uint8_t, uint8_t, uint16_t, uint16_t, void*, uint16_t, uint32_t); typedef int32_t (*iFpWCuWCuu_t)(void*, uint16_t, uint8_t, uint32_t, uint16_t, uint8_t, uint32_t, uint32_t); typedef int32_t (*iFpuiipppp_t)(void*, uint32_t, int32_t, int32_t, void*, void*, void*, void*); @@ -1800,14 +1788,12 @@ typedef void (*vFuiiiillli_t)(uint32_t, int32_t, int32_t, int32_t, int32_t, intp typedef void (*vFuiiilliip_t)(uint32_t, int32_t, int32_t, int32_t, intptr_t, intptr_t, int32_t, int32_t, void*); typedef void (*vFuiiillilp_t)(uint32_t, int32_t, int32_t, int32_t, intptr_t, intptr_t, int32_t, intptr_t, void*); typedef void (*vFuiuiiiiip_t)(uint32_t, int32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, void*); -typedef void (*vFuiupuffup_t)(uint32_t, int32_t, uint32_t, void*, uint32_t, float, float, uint32_t, void*); typedef void (*vFuuiiiiiii_t)(uint32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); typedef void (*vFuuiuiiiii_t)(uint32_t, uint32_t, int32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t); typedef void (*vFuuiuiiiip_t)(uint32_t, uint32_t, int32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, void*); typedef void (*vFuuiuiiuup_t)(uint32_t, uint32_t, int32_t, uint32_t, int32_t, int32_t, uint32_t, uint32_t, void*); typedef void (*vFuuuiiiiip_t)(uint32_t, uint32_t, uint32_t, int32_t, int32_t, int32_t, int32_t, int32_t, void*); typedef void (*vFuuuuuuuuu_t)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t); -typedef void (*vFuupiuiuuf_t)(uint32_t, uint32_t, void*, int32_t, uint32_t, int32_t, uint32_t, uint32_t, float); typedef void (*vFuffffffff_t)(uint32_t, float, float, float, float, float, float, float, float); typedef void (*vFffuuuufff_t)(float, float, uint32_t, uint32_t, uint32_t, uint32_t, float, float, float); typedef void (*vFddddddddd_t)(double, double, double, double, double, double, double, double, double); @@ -1839,8 +1825,8 @@ typedef int32_t (*iFdddpppppp_t)(double, double, double, void*, void*, void*, vo typedef int32_t (*iFpiuuupipu_t)(void*, int32_t, uint32_t, uint32_t, uint32_t, void*, int32_t, void*, uint32_t); typedef int32_t (*iFpipLpiiip_t)(void*, int32_t, void*, uintptr_t, void*, int32_t, int32_t, int32_t, void*); typedef int32_t (*iFpuiuuipip_t)(void*, uint32_t, int32_t, uint32_t, uint32_t, int32_t, void*, int32_t, void*); +typedef int32_t (*iFpuuuuuuuu_t)(void*, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t); typedef int32_t (*iFpupuupWWu_t)(void*, uint32_t, void*, uint32_t, uint32_t, void*, uint16_t, uint16_t, uint32_t); -typedef int32_t (*iFpLLLLLLLL_t)(void*, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uintptr_t); typedef int32_t (*iFppiiiiiii_t)(void*, void*, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t); typedef int32_t (*iFppiuiippu_t)(void*, void*, int32_t, uint32_t, int32_t, int32_t, void*, void*, uint32_t); typedef int32_t (*iFppipiiipi_t)(void*, void*, int32_t, void*, int32_t, int32_t, int32_t, void*, int32_t); @@ -1889,7 +1875,6 @@ typedef void (*vFuuiuiiiiip_t)(uint32_t, uint32_t, int32_t, uint32_t, int32_t, i typedef void (*vFuuiuiiiuup_t)(uint32_t, uint32_t, int32_t, uint32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, void*); typedef void (*vFuuuuuuuiii_t)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, int32_t, int32_t, int32_t); typedef void (*vFuuuuuuuuuu_t)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t); -typedef void (*vFuupiiupuuf_t)(uint32_t, uint32_t, void*, int32_t, int32_t, uint32_t, void*, uint32_t, uint32_t, float); typedef void (*vFuffiiffiip_t)(uint32_t, float, float, int32_t, int32_t, float, float, int32_t, int32_t, void*); typedef void (*vFuddiiddiip_t)(uint32_t, double, double, int32_t, int32_t, double, double, int32_t, int32_t, void*); typedef void (*vFffffffffff_t)(float, float, float, float, float, float, float, float, float, float); @@ -2059,6 +2044,7 @@ typedef int32_t (*iFpppppppppppppppppppppppppppppppppp_t)(void*, void*, void*, v #if defined(NOALIGN) typedef int64_t (*IFpi_t)(void*, int32_t); +typedef int32_t (*iFipV_t)(int32_t, void*, void*); typedef int32_t (*iFppiiiip_t)(void*, void*, int32_t, int32_t, int32_t, int32_t, void*); #endif @@ -2070,6 +2056,7 @@ typedef int32_t (*iFEpI_t)(x86emu_t*, void*, int64_t); typedef int32_t (*iFEpd_t)(x86emu_t*, void*, double); typedef int64_t (*IFEpi_t)(x86emu_t*, void*, int32_t); typedef double (*dFEpi_t)(x86emu_t*, void*, int32_t); +typedef int32_t (*iFEipV_t)(x86emu_t*, int32_t, void*, void*); typedef int32_t (*iFEiiip_t)(x86emu_t*, int32_t, int32_t, int32_t, void*); typedef int32_t (*iFEipii_t)(x86emu_t*, int32_t, void*, int32_t, int32_t); typedef int32_t (*iFEpppi_t)(x86emu_t*, void*, void*, void*, int32_t); @@ -2108,8 +2095,7 @@ typedef int32_t (*iFKipppL_t)(double, int32_t, void*, void*, void*, uintptr_t); typedef void (*vFppippKKC_t)(void*, void*, int32_t, void*, void*, double, double, uint8_t); #endif -void vFE(x86emu_t *emu, uintptr_t fcn) { vFE_t fn = (vFE_t)fcn; fn(emu); } -void vFv(x86emu_t *emu, uintptr_t fcn) { vFv_t fn = (vFv_t)fcn; fn(); } +void vFv(x86emu_t *emu, uintptr_t fcn) { vFv_t fn = (vFv_t)fcn; (void)fcn; fn(); } void vFi(x86emu_t *emu, uintptr_t fcn) { vFi_t fn = (vFi_t)fcn; fn(*(int32_t*)(R_ESP + 4)); } void vFu(x86emu_t *emu, uintptr_t fcn) { vFu_t fn = (vFu_t)fcn; fn(*(uint32_t*)(R_ESP + 4)); } void vFU(x86emu_t *emu, uintptr_t fcn) { vFU_t fn = (vFU_t)fcn; fn(*(uint64_t*)(R_ESP + 4)); } @@ -2127,7 +2113,6 @@ void cFf(x86emu_t *emu, uintptr_t fcn) { cFf_t fn = (cFf_t)fcn; R_EAX=fn(*(float void cFp(x86emu_t *emu, uintptr_t fcn) { cFp_t fn = (cFp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4)); } void cFG(x86emu_t *emu, uintptr_t fcn) { cFG_t fn = (cFG_t)fcn; my_GValue_t arg4; alignGValue(&arg4, *(void**)(R_ESP + 4)); R_EAX=fn(&arg4); unalignGValue(*(void**)(R_ESP + 4), &arg4); } void wFp(x86emu_t *emu, uintptr_t fcn) { wFp_t fn = (wFp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4)); } -void iFE(x86emu_t *emu, uintptr_t fcn) { iFE_t fn = (iFE_t)fcn; R_EAX=fn(emu); } void iFv(x86emu_t *emu, uintptr_t fcn) { iFv_t fn = (iFv_t)fcn; R_EAX=fn(); } void iFw(x86emu_t *emu, uintptr_t fcn) { iFw_t fn = (iFw_t)fcn; R_EAX=fn(*(int16_t*)(R_ESP + 4)); } void iFi(x86emu_t *emu, uintptr_t fcn) { iFi_t fn = (iFi_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4)); } @@ -2153,7 +2138,6 @@ void CFp(x86emu_t *emu, uintptr_t fcn) { CFp_t fn = (CFp_t)fcn; R_EAX=(unsigned void CFG(x86emu_t *emu, uintptr_t fcn) { CFG_t fn = (CFG_t)fcn; my_GValue_t arg4; alignGValue(&arg4, *(void**)(R_ESP + 4)); R_EAX=(unsigned char)fn(&arg4); unalignGValue(*(void**)(R_ESP + 4), &arg4); } void WFi(x86emu_t *emu, uintptr_t fcn) { WFi_t fn = (WFi_t)fcn; R_EAX=(unsigned short)fn(*(int32_t*)(R_ESP + 4)); } void WFp(x86emu_t *emu, uintptr_t fcn) { WFp_t fn = (WFp_t)fcn; R_EAX=(unsigned short)fn(*(void**)(R_ESP + 4)); } -void uFE(x86emu_t *emu, uintptr_t fcn) { uFE_t fn = (uFE_t)fcn; R_EAX=(uint32_t)fn(emu); } void uFv(x86emu_t *emu, uintptr_t fcn) { uFv_t fn = (uFv_t)fcn; R_EAX=(uint32_t)fn(); } void uFi(x86emu_t *emu, uintptr_t fcn) { uFi_t fn = (uFi_t)fcn; R_EAX=(uint32_t)fn(*(int32_t*)(R_ESP + 4)); } void uFu(x86emu_t *emu, uintptr_t fcn) { uFu_t fn = (uFu_t)fcn; R_EAX=(uint32_t)fn(*(uint32_t*)(R_ESP + 4)); } @@ -2165,8 +2149,8 @@ void uFG(x86emu_t *emu, uintptr_t fcn) { uFG_t fn = (uFG_t)fcn; my_GValue_t arg4 void UFv(x86emu_t *emu, uintptr_t fcn) { UFv_t fn = (UFv_t)fcn; ui64_t r; r.u=(uint64_t)fn(); R_EAX=r.d[0]; R_EDX=r.d[1]; } void UFu(x86emu_t *emu, uintptr_t fcn) { UFu_t fn = (UFu_t)fcn; ui64_t r; r.u=(uint64_t)fn(*(uint32_t*)(R_ESP + 4)); R_EAX=r.d[0]; R_EDX=r.d[1]; } void UFp(x86emu_t *emu, uintptr_t fcn) { UFp_t fn = (UFp_t)fcn; ui64_t r; r.u=(uint64_t)fn(*(void**)(R_ESP + 4)); R_EAX=r.d[0]; R_EDX=r.d[1]; } -void UFV(x86emu_t *emu, uintptr_t fcn) { UFV_t fn = (UFV_t)fcn; ui64_t r; r.u=(uint64_t)fn((void*)(R_ESP + 4)); R_EAX=r.d[0]; R_EDX=r.d[1]; } void UFG(x86emu_t *emu, uintptr_t fcn) { UFG_t fn = (UFG_t)fcn; my_GValue_t arg4; alignGValue(&arg4, *(void**)(R_ESP + 4)); ui64_t r; r.u=(uint64_t)fn(&arg4); R_EAX=r.d[0]; R_EDX=r.d[1]; unalignGValue(*(void**)(R_ESP + 4), &arg4); } +void UFs(x86emu_t *emu, uintptr_t fcn) { UFs_t fn = (UFs_t)fcn; ui64_t r; r.u=(uint64_t)fn((void*)(R_ESP + 4)); R_EAX=r.d[0]; R_EDX=r.d[1]; } void fFi(x86emu_t *emu, uintptr_t fcn) { fFi_t fn = (fFi_t)fcn; float fl=fn(*(int32_t*)(R_ESP + 4)); fpu_do_push(emu); ST0val = fl; } void fFf(x86emu_t *emu, uintptr_t fcn) { fFf_t fn = (fFf_t)fcn; float fl=fn(*(float*)(R_ESP + 4)); fpu_do_push(emu); ST0val = fl; } void fFp(x86emu_t *emu, uintptr_t fcn) { fFp_t fn = (fFp_t)fcn; float fl=fn(*(void**)(R_ESP + 4)); fpu_do_push(emu); ST0val = fl; } @@ -2184,9 +2168,9 @@ void lFp(x86emu_t *emu, uintptr_t fcn) { lFp_t fn = (lFp_t)fcn; R_EAX=(intptr_t) void lFG(x86emu_t *emu, uintptr_t fcn) { lFG_t fn = (lFG_t)fcn; my_GValue_t arg4; alignGValue(&arg4, *(void**)(R_ESP + 4)); R_EAX=(intptr_t)fn(&arg4); unalignGValue(*(void**)(R_ESP + 4), &arg4); } void LFv(x86emu_t *emu, uintptr_t fcn) { LFv_t fn = (LFv_t)fcn; R_EAX=(uintptr_t)fn(); } void LFu(x86emu_t *emu, uintptr_t fcn) { LFu_t fn = (LFu_t)fcn; R_EAX=(uintptr_t)fn(*(uint32_t*)(R_ESP + 4)); } +void LFL(x86emu_t *emu, uintptr_t fcn) { LFL_t fn = (LFL_t)fcn; R_EAX=(uintptr_t)fn(*(uintptr_t*)(R_ESP + 4)); } void LFp(x86emu_t *emu, uintptr_t fcn) { LFp_t fn = (LFp_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4)); } void LFG(x86emu_t *emu, uintptr_t fcn) { LFG_t fn = (LFG_t)fcn; my_GValue_t arg4; alignGValue(&arg4, *(void**)(R_ESP + 4)); R_EAX=(uintptr_t)fn(&arg4); unalignGValue(*(void**)(R_ESP + 4), &arg4); } -void pFE(x86emu_t *emu, uintptr_t fcn) { pFE_t fn = (pFE_t)fcn; R_EAX=(uintptr_t)fn(emu); } void pFv(x86emu_t *emu, uintptr_t fcn) { pFv_t fn = (pFv_t)fcn; R_EAX=(uintptr_t)fn(); } void pFw(x86emu_t *emu, uintptr_t fcn) { pFw_t fn = (pFw_t)fcn; R_EAX=(uintptr_t)fn(*(int16_t*)(R_ESP + 4)); } void pFi(x86emu_t *emu, uintptr_t fcn) { pFi_t fn = (pFi_t)fcn; R_EAX=(uintptr_t)fn(*(int32_t*)(R_ESP + 4)); } @@ -2201,6 +2185,7 @@ void pFL(x86emu_t *emu, uintptr_t fcn) { pFL_t fn = (pFL_t)fcn; R_EAX=(uintptr_t void pFp(x86emu_t *emu, uintptr_t fcn) { pFp_t fn = (pFp_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4)); } void pFV(x86emu_t *emu, uintptr_t fcn) { pFV_t fn = (pFV_t)fcn; R_EAX=(uintptr_t)fn((void*)(R_ESP + 4)); } void pFG(x86emu_t *emu, uintptr_t fcn) { pFG_t fn = (pFG_t)fcn; my_GValue_t arg4; alignGValue(&arg4, *(void**)(R_ESP + 4)); R_EAX=(uintptr_t)fn(&arg4); unalignGValue(*(void**)(R_ESP + 4), &arg4); } +void vFEv(x86emu_t *emu, uintptr_t fcn) { vFEv_t fn = (vFEv_t)fcn; fn(emu); } void vFEp(x86emu_t *emu, uintptr_t fcn) { vFEp_t fn = (vFEp_t)fcn; fn(emu, *(void**)(R_ESP + 4)); } void vFii(x86emu_t *emu, uintptr_t fcn) { vFii_t fn = (vFii_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); } void vFiI(x86emu_t *emu, uintptr_t fcn) { vFiI_t fn = (vFiI_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int64_t*)(R_ESP + 8)); } @@ -2237,7 +2222,7 @@ void vFpl(x86emu_t *emu, uintptr_t fcn) { vFpl_t fn = (vFpl_t)fcn; fn(*(void**)( void vFpL(x86emu_t *emu, uintptr_t fcn) { vFpL_t fn = (vFpL_t)fcn; fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8)); } void vFpp(x86emu_t *emu, uintptr_t fcn) { vFpp_t fn = (vFpp_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8)); } void vFpS(x86emu_t *emu, uintptr_t fcn) { vFpS_t fn = (vFpS_t)fcn; fn(*(void**)(R_ESP + 4), io_convert(*(void**)(R_ESP + 8))); } -void vFpP(x86emu_t *emu, uintptr_t fcn) { vFpP_t fn = (vFpP_t)fcn; void* save8=NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); fn(*(void**)(R_ESP + 4), arg8); VulkanTox86(arg8, save8); } +void vFpP(x86emu_t *emu, uintptr_t fcn) { vFpP_t fn = (vFpP_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); fn(*(void**)(R_ESP + 4), arg8); VulkanTox86(arg8, save8); } void vFpG(x86emu_t *emu, uintptr_t fcn) { vFpG_t fn = (vFpG_t)fcn; my_GValue_t arg8; alignGValue(&arg8, *(void**)(R_ESP + 8)); fn(*(void**)(R_ESP + 4), &arg8); unalignGValue(*(void**)(R_ESP + 8), &arg8); } void vFSi(x86emu_t *emu, uintptr_t fcn) { vFSi_t fn = (vFSi_t)fcn; fn(io_convert(*(void**)(R_ESP + 4)), *(int32_t*)(R_ESP + 8)); } void vFGc(x86emu_t *emu, uintptr_t fcn) { vFGc_t fn = (vFGc_t)fcn; my_GValue_t arg4; alignGValue(&arg4, *(void**)(R_ESP + 4)); fn(&arg4, *(int8_t*)(R_ESP + 8)); unalignGValue(*(void**)(R_ESP + 4), &arg4); } @@ -2253,9 +2238,9 @@ void vFGL(x86emu_t *emu, uintptr_t fcn) { vFGL_t fn = (vFGL_t)fcn; my_GValue_t a void vFGp(x86emu_t *emu, uintptr_t fcn) { vFGp_t fn = (vFGp_t)fcn; my_GValue_t arg4; alignGValue(&arg4, *(void**)(R_ESP + 4)); fn(&arg4, *(void**)(R_ESP + 8)); unalignGValue(*(void**)(R_ESP + 4), &arg4); } void vFGG(x86emu_t *emu, uintptr_t fcn) { vFGG_t fn = (vFGG_t)fcn; my_GValue_t arg4; alignGValue(&arg4, *(void**)(R_ESP + 4)); my_GValue_t arg8; alignGValue(&arg8, *(void**)(R_ESP + 8)); fn(&arg4, &arg8); unalignGValue(*(void**)(R_ESP + 4), &arg4); unalignGValue(*(void**)(R_ESP + 8), &arg8); } void cFpp(x86emu_t *emu, uintptr_t fcn) { cFpp_t fn = (cFpp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8)); } +void iFEv(x86emu_t *emu, uintptr_t fcn) { iFEv_t fn = (iFEv_t)fcn; R_EAX=fn(emu); } void iFEL(x86emu_t *emu, uintptr_t fcn) { iFEL_t fn = (iFEL_t)fcn; R_EAX=fn(emu, *(uintptr_t*)(R_ESP + 4)); } void iFEp(x86emu_t *emu, uintptr_t fcn) { iFEp_t fn = (iFEp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4)); } -void iFEV(x86emu_t *emu, uintptr_t fcn) { iFEV_t fn = (iFEV_t)fcn; R_EAX=fn(emu, (void*)(R_ESP + 4)); } void iFwp(x86emu_t *emu, uintptr_t fcn) { iFwp_t fn = (iFwp_t)fcn; R_EAX=fn(*(int16_t*)(R_ESP + 4), *(void**)(R_ESP + 8)); } void iFii(x86emu_t *emu, uintptr_t fcn) { iFii_t fn = (iFii_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); } void iFiI(x86emu_t *emu, uintptr_t fcn) { iFiI_t fn = (iFiI_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int64_t*)(R_ESP + 8)); } @@ -2267,8 +2252,6 @@ void iFui(x86emu_t *emu, uintptr_t fcn) { iFui_t fn = (iFui_t)fcn; R_EAX=fn(*(ui void iFuu(x86emu_t *emu, uintptr_t fcn) { iFuu_t fn = (iFuu_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8)); } void iFup(x86emu_t *emu, uintptr_t fcn) { iFup_t fn = (iFup_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(void**)(R_ESP + 8)); } void iFli(x86emu_t *emu, uintptr_t fcn) { iFli_t fn = (iFli_t)fcn; R_EAX=fn(*(intptr_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); } -void iFLi(x86emu_t *emu, uintptr_t fcn) { iFLi_t fn = (iFLi_t)fcn; R_EAX=fn(*(uintptr_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); } -void iFLp(x86emu_t *emu, uintptr_t fcn) { iFLp_t fn = (iFLp_t)fcn; R_EAX=fn(*(uintptr_t*)(R_ESP + 4), *(void**)(R_ESP + 8)); } void iFpw(x86emu_t *emu, uintptr_t fcn) { iFpw_t fn = (iFpw_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int16_t*)(R_ESP + 8)); } void iFpi(x86emu_t *emu, uintptr_t fcn) { iFpi_t fn = (iFpi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); } void iFpI(x86emu_t *emu, uintptr_t fcn) { iFpI_t fn = (iFpI_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int64_t*)(R_ESP + 8)); } @@ -2281,8 +2264,9 @@ void iFpd(x86emu_t *emu, uintptr_t fcn) { iFpd_t fn = (iFpd_t)fcn; R_EAX=fn(*(vo void iFpl(x86emu_t *emu, uintptr_t fcn) { iFpl_t fn = (iFpl_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(intptr_t*)(R_ESP + 8)); } void iFpL(x86emu_t *emu, uintptr_t fcn) { iFpL_t fn = (iFpL_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8)); } void iFpp(x86emu_t *emu, uintptr_t fcn) { iFpp_t fn = (iFpp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8)); } +void iFpV(x86emu_t *emu, uintptr_t fcn) { iFpV_t fn = (iFpV_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), (void*)(R_ESP + 8)); } void iFpO(x86emu_t *emu, uintptr_t fcn) { iFpO_t fn = (iFpO_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), of_convert(*(int32_t*)(R_ESP + 8))); } -void iFpP(x86emu_t *emu, uintptr_t fcn) { iFpP_t fn = (iFpP_t)fcn; void* save8=NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); R_EAX=fn(*(void**)(R_ESP + 4), arg8); VulkanTox86(arg8, save8); } +void iFpP(x86emu_t *emu, uintptr_t fcn) { iFpP_t fn = (iFpP_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); R_EAX=fn(*(void**)(R_ESP + 4), arg8); VulkanTox86(arg8, save8); } void iFpG(x86emu_t *emu, uintptr_t fcn) { iFpG_t fn = (iFpG_t)fcn; my_GValue_t arg8; alignGValue(&arg8, *(void**)(R_ESP + 8)); R_EAX=fn(*(void**)(R_ESP + 4), &arg8); unalignGValue(*(void**)(R_ESP + 8), &arg8); } void iFSi(x86emu_t *emu, uintptr_t fcn) { iFSi_t fn = (iFSi_t)fcn; R_EAX=fn(io_convert(*(void**)(R_ESP + 4)), *(int32_t*)(R_ESP + 8)); } void iFGG(x86emu_t *emu, uintptr_t fcn) { iFGG_t fn = (iFGG_t)fcn; my_GValue_t arg4; alignGValue(&arg4, *(void**)(R_ESP + 4)); my_GValue_t arg8; alignGValue(&arg8, *(void**)(R_ESP + 8)); R_EAX=fn(&arg4, &arg8); unalignGValue(*(void**)(R_ESP + 4), &arg4); unalignGValue(*(void**)(R_ESP + 8), &arg8); } @@ -2295,8 +2279,10 @@ void CFui(x86emu_t *emu, uintptr_t fcn) { CFui_t fn = (CFui_t)fcn; R_EAX=(unsign void CFpi(x86emu_t *emu, uintptr_t fcn) { CFpi_t fn = (CFpi_t)fcn; R_EAX=(unsigned char)fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); } void CFpu(x86emu_t *emu, uintptr_t fcn) { CFpu_t fn = (CFpu_t)fcn; R_EAX=(unsigned char)fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8)); } void CFpp(x86emu_t *emu, uintptr_t fcn) { CFpp_t fn = (CFpp_t)fcn; R_EAX=(unsigned char)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8)); } +void uFEv(x86emu_t *emu, uintptr_t fcn) { uFEv_t fn = (uFEv_t)fcn; R_EAX=(uint32_t)fn(emu); } void uFEu(x86emu_t *emu, uintptr_t fcn) { uFEu_t fn = (uFEu_t)fcn; R_EAX=(uint32_t)fn(emu, *(uint32_t*)(R_ESP + 4)); } void uFEp(x86emu_t *emu, uintptr_t fcn) { uFEp_t fn = (uFEp_t)fcn; R_EAX=(uint32_t)fn(emu, *(void**)(R_ESP + 4)); } +void uFii(x86emu_t *emu, uintptr_t fcn) { uFii_t fn = (uFii_t)fcn; R_EAX=(uint32_t)fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); } void uFiu(x86emu_t *emu, uintptr_t fcn) { uFiu_t fn = (uFiu_t)fcn; R_EAX=(uint32_t)fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8)); } void uFui(x86emu_t *emu, uintptr_t fcn) { uFui_t fn = (uFui_t)fcn; R_EAX=(uint32_t)fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); } void uFuu(x86emu_t *emu, uintptr_t fcn) { uFuu_t fn = (uFuu_t)fcn; R_EAX=(uint32_t)fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8)); } @@ -2313,7 +2299,7 @@ void UFuu(x86emu_t *emu, uintptr_t fcn) { UFuu_t fn = (UFuu_t)fcn; ui64_t r; r.u void UFUU(x86emu_t *emu, uintptr_t fcn) { UFUU_t fn = (UFUU_t)fcn; ui64_t r; r.u=(uint64_t)fn(*(uint64_t*)(R_ESP + 4), *(uint64_t*)(R_ESP + 12)); R_EAX=r.d[0]; R_EDX=r.d[1]; } void UFUp(x86emu_t *emu, uintptr_t fcn) { UFUp_t fn = (UFUp_t)fcn; ui64_t r; r.u=(uint64_t)fn(*(uint64_t*)(R_ESP + 4), *(void**)(R_ESP + 12)); R_EAX=r.d[0]; R_EDX=r.d[1]; } void UFpp(x86emu_t *emu, uintptr_t fcn) { UFpp_t fn = (UFpp_t)fcn; ui64_t r; r.u=(uint64_t)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8)); R_EAX=r.d[0]; R_EDX=r.d[1]; } -void UFVV(x86emu_t *emu, uintptr_t fcn) { UFVV_t fn = (UFVV_t)fcn; ui64_t r; r.u=(uint64_t)fn((void*)(R_ESP + 4), (void*)(R_ESP + 4)); R_EAX=r.d[0]; R_EDX=r.d[1]; } +void UFss(x86emu_t *emu, uintptr_t fcn) { UFss_t fn = (UFss_t)fcn; ui64_t r; r.u=(uint64_t)fn((void*)(R_ESP + 4), (void*)(R_ESP + 4)); R_EAX=r.d[0]; R_EDX=r.d[1]; } void fFEp(x86emu_t *emu, uintptr_t fcn) { fFEp_t fn = (fFEp_t)fcn; float fl=fn(emu, *(void**)(R_ESP + 4)); fpu_do_push(emu); ST0val = fl; } void fFif(x86emu_t *emu, uintptr_t fcn) { fFif_t fn = (fFif_t)fcn; float fl=fn(*(int32_t*)(R_ESP + 4), *(float*)(R_ESP + 8)); fpu_do_push(emu); ST0val = fl; } void fFfi(x86emu_t *emu, uintptr_t fcn) { fFfi_t fn = (fFfi_t)fcn; float fl=fn(*(float*)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); fpu_do_push(emu); ST0val = fl; } @@ -2336,15 +2322,13 @@ void lFpi(x86emu_t *emu, uintptr_t fcn) { lFpi_t fn = (lFpi_t)fcn; R_EAX=(intptr void lFpp(x86emu_t *emu, uintptr_t fcn) { lFpp_t fn = (lFpp_t)fcn; R_EAX=(intptr_t)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8)); } void LFii(x86emu_t *emu, uintptr_t fcn) { LFii_t fn = (LFii_t)fcn; R_EAX=(uintptr_t)fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); } void LFLi(x86emu_t *emu, uintptr_t fcn) { LFLi_t fn = (LFLi_t)fcn; R_EAX=(uintptr_t)fn(*(uintptr_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); } -void LFLp(x86emu_t *emu, uintptr_t fcn) { LFLp_t fn = (LFLp_t)fcn; R_EAX=(uintptr_t)fn(*(uintptr_t*)(R_ESP + 4), *(void**)(R_ESP + 8)); } void LFpL(x86emu_t *emu, uintptr_t fcn) { LFpL_t fn = (LFpL_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8)); } void LFpp(x86emu_t *emu, uintptr_t fcn) { LFpp_t fn = (LFpp_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8)); } +void pFEv(x86emu_t *emu, uintptr_t fcn) { pFEv_t fn = (pFEv_t)fcn; R_EAX=(uintptr_t)fn(emu); } void pFEi(x86emu_t *emu, uintptr_t fcn) { pFEi_t fn = (pFEi_t)fcn; R_EAX=(uintptr_t)fn(emu, *(int32_t*)(R_ESP + 4)); } void pFEp(x86emu_t *emu, uintptr_t fcn) { pFEp_t fn = (pFEp_t)fcn; R_EAX=(uintptr_t)fn(emu, *(void**)(R_ESP + 4)); } -void pFEV(x86emu_t *emu, uintptr_t fcn) { pFEV_t fn = (pFEV_t)fcn; R_EAX=(uintptr_t)fn(emu, (void*)(R_ESP + 4)); } void pFii(x86emu_t *emu, uintptr_t fcn) { pFii_t fn = (pFii_t)fcn; R_EAX=(uintptr_t)fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); } void pFiu(x86emu_t *emu, uintptr_t fcn) { pFiu_t fn = (pFiu_t)fcn; R_EAX=(uintptr_t)fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8)); } -void pFiL(x86emu_t *emu, uintptr_t fcn) { pFiL_t fn = (pFiL_t)fcn; R_EAX=(uintptr_t)fn(*(int32_t*)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8)); } void pFip(x86emu_t *emu, uintptr_t fcn) { pFip_t fn = (pFip_t)fcn; R_EAX=(uintptr_t)fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8)); } void pFiV(x86emu_t *emu, uintptr_t fcn) { pFiV_t fn = (pFiV_t)fcn; R_EAX=(uintptr_t)fn(*(int32_t*)(R_ESP + 4), (void*)(R_ESP + 8)); } void pFui(x86emu_t *emu, uintptr_t fcn) { pFui_t fn = (pFui_t)fcn; R_EAX=(uintptr_t)fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); } @@ -2367,6 +2351,7 @@ void pFpL(x86emu_t *emu, uintptr_t fcn) { pFpL_t fn = (pFpL_t)fcn; R_EAX=(uintpt void pFpp(x86emu_t *emu, uintptr_t fcn) { pFpp_t fn = (pFpp_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8)); } void pFpV(x86emu_t *emu, uintptr_t fcn) { pFpV_t fn = (pFpV_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), (void*)(R_ESP + 8)); } void pFpG(x86emu_t *emu, uintptr_t fcn) { pFpG_t fn = (pFpG_t)fcn; my_GValue_t arg8; alignGValue(&arg8, *(void**)(R_ESP + 8)); R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), &arg8); unalignGValue(*(void**)(R_ESP + 8), &arg8); } +void pFps(x86emu_t *emu, uintptr_t fcn) { pFps_t fn = (pFps_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), (void*)(R_ESP + 8)); } void pFSi(x86emu_t *emu, uintptr_t fcn) { pFSi_t fn = (pFSi_t)fcn; R_EAX=(uintptr_t)fn(io_convert(*(void**)(R_ESP + 4)), *(int32_t*)(R_ESP + 8)); } void vFEip(x86emu_t *emu, uintptr_t fcn) { vFEip_t fn = (vFEip_t)fcn; fn(emu, *(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8)); } void vFEpi(x86emu_t *emu, uintptr_t fcn) { vFEpi_t fn = (vFEpi_t)fcn; fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); } @@ -2417,7 +2402,7 @@ void vFpiu(x86emu_t *emu, uintptr_t fcn) { vFpiu_t fn = (vFpiu_t)fcn; fn(*(void* void vFpif(x86emu_t *emu, uintptr_t fcn) { vFpif_t fn = (vFpif_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(float*)(R_ESP + 12)); } void vFpid(x86emu_t *emu, uintptr_t fcn) { vFpid_t fn = (vFpid_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(double*)(R_ESP + 12)); } void vFpip(x86emu_t *emu, uintptr_t fcn) { vFpip_t fn = (vFpip_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); } -void vFpiP(x86emu_t *emu, uintptr_t fcn) { vFpiP_t fn = (vFpiP_t)fcn; void* save12=NULL; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12), &save12); fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), arg12); VulkanTox86(arg12, save12); } +void vFpiP(x86emu_t *emu, uintptr_t fcn) { vFpiP_t fn = (vFpiP_t)fcn; void* save12 = NULL; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12), &save12); fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), arg12); VulkanTox86(arg12, save12); } void vFpui(x86emu_t *emu, uintptr_t fcn) { vFpui_t fn = (vFpui_t)fcn; fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); } void vFpuI(x86emu_t *emu, uintptr_t fcn) { vFpuI_t fn = (vFpuI_t)fcn; fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int64_t*)(R_ESP + 12)); } void vFpuu(x86emu_t *emu, uintptr_t fcn) { vFpuu_t fn = (vFpuu_t)fcn; fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12)); } @@ -2440,8 +2425,8 @@ void vFppL(x86emu_t *emu, uintptr_t fcn) { vFppL_t fn = (vFppL_t)fcn; fn(*(void* void vFppp(x86emu_t *emu, uintptr_t fcn) { vFppp_t fn = (vFppp_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); } void vFppV(x86emu_t *emu, uintptr_t fcn) { vFppV_t fn = (vFppV_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), (void*)(R_ESP + 12)); } void vFppG(x86emu_t *emu, uintptr_t fcn) { vFppG_t fn = (vFppG_t)fcn; my_GValue_t arg12; alignGValue(&arg12, *(void**)(R_ESP + 12)); fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), &arg12); unalignGValue(*(void**)(R_ESP + 12), &arg12); } -void vFpPp(x86emu_t *emu, uintptr_t fcn) { vFpPp_t fn = (vFpPp_t)fcn; void* save8=NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); fn(*(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12)); VulkanTox86(arg8, save8); } -void vFpPP(x86emu_t *emu, uintptr_t fcn) { vFpPP_t fn = (vFpPP_t)fcn; void* save8=NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); void* save12=NULL; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12), &save12); fn(*(void**)(R_ESP + 4), arg8, arg12); VulkanTox86(arg8, save8); VulkanTox86(arg12, save12); } +void vFpPp(x86emu_t *emu, uintptr_t fcn) { vFpPp_t fn = (vFpPp_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); fn(*(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12)); VulkanTox86(arg8, save8); } +void vFpPP(x86emu_t *emu, uintptr_t fcn) { vFpPP_t fn = (vFpPP_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); void* save12 = NULL; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12), &save12); fn(*(void**)(R_ESP + 4), arg8, arg12); VulkanTox86(arg8, save8); VulkanTox86(arg12, save12); } void iFEiw(x86emu_t *emu, uintptr_t fcn) { iFEiw_t fn = (iFEiw_t)fcn; R_EAX=fn(emu, *(int32_t*)(R_ESP + 4), *(int16_t*)(R_ESP + 8)); } void iFEip(x86emu_t *emu, uintptr_t fcn) { iFEip_t fn = (iFEip_t)fcn; R_EAX=fn(emu, *(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8)); } void iFEWW(x86emu_t *emu, uintptr_t fcn) { iFEWW_t fn = (iFEWW_t)fcn; R_EAX=fn(emu, *(uint16_t*)(R_ESP + 4), *(uint16_t*)(R_ESP + 8)); } @@ -2457,7 +2442,6 @@ void iFiwC(x86emu_t *emu, uintptr_t fcn) { iFiwC_t fn = (iFiwC_t)fcn; R_EAX=fn(* void iFiii(x86emu_t *emu, uintptr_t fcn) { iFiii_t fn = (iFiii_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); } void iFiiI(x86emu_t *emu, uintptr_t fcn) { iFiiI_t fn = (iFiiI_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int64_t*)(R_ESP + 12)); } void iFiiu(x86emu_t *emu, uintptr_t fcn) { iFiiu_t fn = (iFiiu_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12)); } -void iFiiL(x86emu_t *emu, uintptr_t fcn) { iFiiL_t fn = (iFiiL_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12)); } void iFiip(x86emu_t *emu, uintptr_t fcn) { iFiip_t fn = (iFiip_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); } void iFiiO(x86emu_t *emu, uintptr_t fcn) { iFiiO_t fn = (iFiiO_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), of_convert(*(int32_t*)(R_ESP + 12))); } void iFiII(x86emu_t *emu, uintptr_t fcn) { iFiII_t fn = (iFiII_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int64_t*)(R_ESP + 8), *(int64_t*)(R_ESP + 16)); } @@ -2469,6 +2453,7 @@ void iFipu(x86emu_t *emu, uintptr_t fcn) { iFipu_t fn = (iFipu_t)fcn; R_EAX=fn(* void iFipL(x86emu_t *emu, uintptr_t fcn) { iFipL_t fn = (iFipL_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12)); } void iFipp(x86emu_t *emu, uintptr_t fcn) { iFipp_t fn = (iFipp_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); } void iFCiW(x86emu_t *emu, uintptr_t fcn) { iFCiW_t fn = (iFCiW_t)fcn; R_EAX=fn(*(uint8_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint16_t*)(R_ESP + 12)); } +void iFuwp(x86emu_t *emu, uintptr_t fcn) { iFuwp_t fn = (iFuwp_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(int16_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); } void iFuii(x86emu_t *emu, uintptr_t fcn) { iFuii_t fn = (iFuii_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); } void iFuip(x86emu_t *emu, uintptr_t fcn) { iFuip_t fn = (iFuip_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); } void iFuui(x86emu_t *emu, uintptr_t fcn) { iFuui_t fn = (iFuui_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); } @@ -2478,7 +2463,6 @@ void iFuff(x86emu_t *emu, uintptr_t fcn) { iFuff_t fn = (iFuff_t)fcn; R_EAX=fn(* void iFuLp(x86emu_t *emu, uintptr_t fcn) { iFuLp_t fn = (iFuLp_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); } void iFupp(x86emu_t *emu, uintptr_t fcn) { iFupp_t fn = (iFupp_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); } void iFfff(x86emu_t *emu, uintptr_t fcn) { iFfff_t fn = (iFfff_t)fcn; R_EAX=fn(*(float*)(R_ESP + 4), *(float*)(R_ESP + 8), *(float*)(R_ESP + 12)); } -void iFLwp(x86emu_t *emu, uintptr_t fcn) { iFLwp_t fn = (iFLwp_t)fcn; R_EAX=fn(*(uintptr_t*)(R_ESP + 4), *(int16_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); } void iFpwp(x86emu_t *emu, uintptr_t fcn) { iFpwp_t fn = (iFpwp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int16_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); } void iFpii(x86emu_t *emu, uintptr_t fcn) { iFpii_t fn = (iFpii_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); } void iFpiu(x86emu_t *emu, uintptr_t fcn) { iFpiu_t fn = (iFpiu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12)); } @@ -2494,11 +2478,11 @@ void iFpuL(x86emu_t *emu, uintptr_t fcn) { iFpuL_t fn = (iFpuL_t)fcn; R_EAX=fn(* void iFpup(x86emu_t *emu, uintptr_t fcn) { iFpup_t fn = (iFpup_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); } void iFpuV(x86emu_t *emu, uintptr_t fcn) { iFpuV_t fn = (iFpuV_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), (void*)(R_ESP + 12)); } void iFpu2(x86emu_t *emu, uintptr_t fcn) { iFpu2_t fn = (iFpu2_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), (_2uint_struct_t){*(uintptr_t*)(R_ESP + 12),*(uintptr_t*)(R_ESP + 12 + 4)}); } -void iFpuP(x86emu_t *emu, uintptr_t fcn) { iFpuP_t fn = (iFpuP_t)fcn; void* save12=NULL; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12), &save12); R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), arg12); VulkanTox86(arg12, save12); } +void iFpuP(x86emu_t *emu, uintptr_t fcn) { iFpuP_t fn = (iFpuP_t)fcn; void* save12 = NULL; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12), &save12); R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), arg12); VulkanTox86(arg12, save12); } void iFpUi(x86emu_t *emu, uintptr_t fcn) { iFpUi_t fn = (iFpUi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 16)); } void iFpUU(x86emu_t *emu, uintptr_t fcn) { iFpUU_t fn = (iFpUU_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint64_t*)(R_ESP + 16)); } void iFpUp(x86emu_t *emu, uintptr_t fcn) { iFpUp_t fn = (iFpUp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(void**)(R_ESP + 16)); } -void iFpUP(x86emu_t *emu, uintptr_t fcn) { iFpUP_t fn = (iFpUP_t)fcn; void* save16=NULL; void *arg16 = VulkanFromx86(*(void**)(R_ESP + 16), &save16); R_EAX=fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), arg16); VulkanTox86(arg16, save16); } +void iFpUP(x86emu_t *emu, uintptr_t fcn) { iFpUP_t fn = (iFpUP_t)fcn; void* save16 = NULL; void *arg16 = VulkanFromx86(*(void**)(R_ESP + 16), &save16); R_EAX=fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), arg16); VulkanTox86(arg16, save16); } void iFpfu(x86emu_t *emu, uintptr_t fcn) { iFpfu_t fn = (iFpfu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(float*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12)); } void iFpff(x86emu_t *emu, uintptr_t fcn) { iFpff_t fn = (iFpff_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(float*)(R_ESP + 8), *(float*)(R_ESP + 12)); } void iFpdd(x86emu_t *emu, uintptr_t fcn) { iFpdd_t fn = (iFpdd_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(double*)(R_ESP + 8), *(double*)(R_ESP + 16)); } @@ -2506,7 +2490,6 @@ void iFpli(x86emu_t *emu, uintptr_t fcn) { iFpli_t fn = (iFpli_t)fcn; R_EAX=fn(* void iFpll(x86emu_t *emu, uintptr_t fcn) { iFpll_t fn = (iFpll_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12)); } void iFplp(x86emu_t *emu, uintptr_t fcn) { iFplp_t fn = (iFplp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); } void iFpLi(x86emu_t *emu, uintptr_t fcn) { iFpLi_t fn = (iFpLi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); } -void iFpLL(x86emu_t *emu, uintptr_t fcn) { iFpLL_t fn = (iFpLL_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12)); } void iFpLp(x86emu_t *emu, uintptr_t fcn) { iFpLp_t fn = (iFpLp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); } void iFppi(x86emu_t *emu, uintptr_t fcn) { iFppi_t fn = (iFppi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); } void iFppI(x86emu_t *emu, uintptr_t fcn) { iFppI_t fn = (iFppI_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int64_t*)(R_ESP + 12)); } @@ -2519,8 +2502,8 @@ void iFppL(x86emu_t *emu, uintptr_t fcn) { iFppL_t fn = (iFppL_t)fcn; R_EAX=fn(* void iFppp(x86emu_t *emu, uintptr_t fcn) { iFppp_t fn = (iFppp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); } void iFppV(x86emu_t *emu, uintptr_t fcn) { iFppV_t fn = (iFppV_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), (void*)(R_ESP + 12)); } void iFppG(x86emu_t *emu, uintptr_t fcn) { iFppG_t fn = (iFppG_t)fcn; my_GValue_t arg12; alignGValue(&arg12, *(void**)(R_ESP + 12)); R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), &arg12); unalignGValue(*(void**)(R_ESP + 12), &arg12); } -void iFpPp(x86emu_t *emu, uintptr_t fcn) { iFpPp_t fn = (iFpPp_t)fcn; void* save8=NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); R_EAX=fn(*(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12)); VulkanTox86(arg8, save8); } -void iFpPP(x86emu_t *emu, uintptr_t fcn) { iFpPP_t fn = (iFpPP_t)fcn; void* save8=NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); void* save12=NULL; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12), &save12); R_EAX=fn(*(void**)(R_ESP + 4), arg8, arg12); VulkanTox86(arg8, save8); VulkanTox86(arg12, save12); } +void iFpPp(x86emu_t *emu, uintptr_t fcn) { iFpPp_t fn = (iFpPp_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); R_EAX=fn(*(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12)); VulkanTox86(arg8, save8); } +void iFpPP(x86emu_t *emu, uintptr_t fcn) { iFpPP_t fn = (iFpPP_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); void* save12 = NULL; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12), &save12); R_EAX=fn(*(void**)(R_ESP + 4), arg8, arg12); VulkanTox86(arg8, save8); VulkanTox86(arg12, save12); } void iFpGG(x86emu_t *emu, uintptr_t fcn) { iFpGG_t fn = (iFpGG_t)fcn; my_GValue_t arg8; alignGValue(&arg8, *(void**)(R_ESP + 8)); my_GValue_t arg12; alignGValue(&arg12, *(void**)(R_ESP + 12)); R_EAX=fn(*(void**)(R_ESP + 4), &arg8, &arg12); unalignGValue(*(void**)(R_ESP + 8), &arg8); unalignGValue(*(void**)(R_ESP + 12), &arg12); } void iFSpi(x86emu_t *emu, uintptr_t fcn) { iFSpi_t fn = (iFSpi_t)fcn; R_EAX=fn(io_convert(*(void**)(R_ESP + 4)), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); } void iFSpL(x86emu_t *emu, uintptr_t fcn) { iFSpL_t fn = (iFSpL_t)fcn; R_EAX=fn(io_convert(*(void**)(R_ESP + 4)), *(void**)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12)); } @@ -2536,8 +2519,6 @@ void uFEpU(x86emu_t *emu, uintptr_t fcn) { uFEpU_t fn = (uFEpU_t)fcn; R_EAX=(uin void uFEpp(x86emu_t *emu, uintptr_t fcn) { uFEpp_t fn = (uFEpp_t)fcn; R_EAX=(uint32_t)fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8)); } void uFipu(x86emu_t *emu, uintptr_t fcn) { uFipu_t fn = (uFipu_t)fcn; R_EAX=(uint32_t)fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12)); } void uFuip(x86emu_t *emu, uintptr_t fcn) { uFuip_t fn = (uFuip_t)fcn; R_EAX=(uint32_t)fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); } -void uFuui(x86emu_t *emu, uintptr_t fcn) { uFuui_t fn = (uFuui_t)fcn; R_EAX=(uint32_t)fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); } -void uFuuI(x86emu_t *emu, uintptr_t fcn) { uFuuI_t fn = (uFuuI_t)fcn; R_EAX=(uint32_t)fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int64_t*)(R_ESP + 12)); } void uFuuu(x86emu_t *emu, uintptr_t fcn) { uFuuu_t fn = (uFuuu_t)fcn; R_EAX=(uint32_t)fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12)); } void uFuup(x86emu_t *emu, uintptr_t fcn) { uFuup_t fn = (uFuup_t)fcn; R_EAX=(uint32_t)fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); } void uFupi(x86emu_t *emu, uintptr_t fcn) { uFupi_t fn = (uFupi_t)fcn; R_EAX=(uint32_t)fn(*(uint32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); } @@ -2555,7 +2536,6 @@ void uFppu(x86emu_t *emu, uintptr_t fcn) { uFppu_t fn = (uFppu_t)fcn; R_EAX=(uin void uFppp(x86emu_t *emu, uintptr_t fcn) { uFppp_t fn = (uFppp_t)fcn; R_EAX=(uint32_t)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); } void UFppi(x86emu_t *emu, uintptr_t fcn) { UFppi_t fn = (UFppi_t)fcn; ui64_t r; r.u=(uint64_t)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); R_EAX=r.d[0]; R_EDX=r.d[1]; } void UFppu(x86emu_t *emu, uintptr_t fcn) { UFppu_t fn = (UFppu_t)fcn; ui64_t r; r.u=(uint64_t)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12)); R_EAX=r.d[0]; R_EDX=r.d[1]; } -void fFuii(x86emu_t *emu, uintptr_t fcn) { fFuii_t fn = (fFuii_t)fcn; float fl=fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); fpu_do_push(emu); ST0val = fl; } void fFull(x86emu_t *emu, uintptr_t fcn) { fFull_t fn = (fFull_t)fcn; float fl=fn(*(uint32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12)); fpu_do_push(emu); ST0val = fl; } void fFfff(x86emu_t *emu, uintptr_t fcn) { fFfff_t fn = (fFfff_t)fcn; float fl=fn(*(float*)(R_ESP + 4), *(float*)(R_ESP + 8), *(float*)(R_ESP + 12)); fpu_do_push(emu); ST0val = fl; } void fFffp(x86emu_t *emu, uintptr_t fcn) { fFffp_t fn = (fFffp_t)fcn; float fl=fn(*(float*)(R_ESP + 4), *(float*)(R_ESP + 8), *(void**)(R_ESP + 12)); fpu_do_push(emu); ST0val = fl; } @@ -2571,12 +2551,15 @@ void lFipi(x86emu_t *emu, uintptr_t fcn) { lFipi_t fn = (lFipi_t)fcn; R_EAX=(int void lFipL(x86emu_t *emu, uintptr_t fcn) { lFipL_t fn = (lFipL_t)fcn; R_EAX=(intptr_t)fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12)); } void lFlll(x86emu_t *emu, uintptr_t fcn) { lFlll_t fn = (lFlll_t)fcn; R_EAX=(intptr_t)fn(*(intptr_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12)); } void lFlpi(x86emu_t *emu, uintptr_t fcn) { lFlpi_t fn = (lFlpi_t)fcn; R_EAX=(intptr_t)fn(*(intptr_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); } +void lFpli(x86emu_t *emu, uintptr_t fcn) { lFpli_t fn = (lFpli_t)fcn; R_EAX=(intptr_t)fn(*(void**)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); } void lFpLp(x86emu_t *emu, uintptr_t fcn) { lFpLp_t fn = (lFpLp_t)fcn; R_EAX=(intptr_t)fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); } void lFppi(x86emu_t *emu, uintptr_t fcn) { lFppi_t fn = (lFppi_t)fcn; R_EAX=(intptr_t)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); } void lFppL(x86emu_t *emu, uintptr_t fcn) { lFppL_t fn = (lFppL_t)fcn; R_EAX=(intptr_t)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12)); } void lFSpl(x86emu_t *emu, uintptr_t fcn) { lFSpl_t fn = (lFSpl_t)fcn; R_EAX=(intptr_t)fn(io_convert(*(void**)(R_ESP + 4)), *(void**)(R_ESP + 8), *(intptr_t*)(R_ESP + 12)); } void LFiii(x86emu_t *emu, uintptr_t fcn) { LFiii_t fn = (LFiii_t)fcn; R_EAX=(uintptr_t)fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); } -void LFpii(x86emu_t *emu, uintptr_t fcn) { LFpii_t fn = (LFpii_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); } +void LFLLl(x86emu_t *emu, uintptr_t fcn) { LFLLl_t fn = (LFLLl_t)fcn; R_EAX=(uintptr_t)fn(*(uintptr_t*)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12)); } +void LFLpu(x86emu_t *emu, uintptr_t fcn) { LFLpu_t fn = (LFLpu_t)fcn; R_EAX=(uintptr_t)fn(*(uintptr_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12)); } +void LFLpL(x86emu_t *emu, uintptr_t fcn) { LFLpL_t fn = (LFLpL_t)fcn; R_EAX=(uintptr_t)fn(*(uintptr_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12)); } void LFpip(x86emu_t *emu, uintptr_t fcn) { LFpip_t fn = (LFpip_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); } void LFpLi(x86emu_t *emu, uintptr_t fcn) { LFpLi_t fn = (LFpLi_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12)); } void LFpLp(x86emu_t *emu, uintptr_t fcn) { LFpLp_t fn = (LFpLp_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); } @@ -2637,8 +2620,8 @@ void pFppf(x86emu_t *emu, uintptr_t fcn) { pFppf_t fn = (pFppf_t)fcn; R_EAX=(uin void pFppl(x86emu_t *emu, uintptr_t fcn) { pFppl_t fn = (pFppl_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(intptr_t*)(R_ESP + 12)); } void pFppL(x86emu_t *emu, uintptr_t fcn) { pFppL_t fn = (pFppL_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12)); } void pFppp(x86emu_t *emu, uintptr_t fcn) { pFppp_t fn = (pFppp_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); } -void pFpVV(x86emu_t *emu, uintptr_t fcn) { pFpVV_t fn = (pFpVV_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), (void*)(R_ESP + 8), (void*)(R_ESP + 8)); } void pFpOM(x86emu_t *emu, uintptr_t fcn) { pFpOM_t fn = (pFpOM_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), of_convert(*(int32_t*)(R_ESP + 8)), *(void**)(R_ESP + 12),*(void**)(R_ESP + 12 + 4)); } +void pFpss(x86emu_t *emu, uintptr_t fcn) { pFpss_t fn = (pFpss_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), (void*)(R_ESP + 8), (void*)(R_ESP + 8)); } void pFSpl(x86emu_t *emu, uintptr_t fcn) { pFSpl_t fn = (pFSpl_t)fcn; R_EAX=(uintptr_t)fn(io_convert(*(void**)(R_ESP + 4)), *(void**)(R_ESP + 8), *(intptr_t*)(R_ESP + 12)); } void pFSpp(x86emu_t *emu, uintptr_t fcn) { pFSpp_t fn = (pFSpp_t)fcn; R_EAX=(uintptr_t)fn(io_convert(*(void**)(R_ESP + 4)), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); } void vFEiip(x86emu_t *emu, uintptr_t fcn) { vFEiip_t fn = (vFEiip_t)fcn; fn(emu, *(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); } @@ -2768,7 +2751,7 @@ void vFpppL(x86emu_t *emu, uintptr_t fcn) { vFpppL_t fn = (vFpppL_t)fcn; fn(*(vo void vFpppp(x86emu_t *emu, uintptr_t fcn) { vFpppp_t fn = (vFpppp_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); } void vFpppV(x86emu_t *emu, uintptr_t fcn) { vFpppV_t fn = (vFpppV_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), (void*)(R_ESP + 16)); } void vFpppG(x86emu_t *emu, uintptr_t fcn) { vFpppG_t fn = (vFpppG_t)fcn; my_GValue_t arg16; alignGValue(&arg16, *(void**)(R_ESP + 16)); fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), &arg16); unalignGValue(*(void**)(R_ESP + 16), &arg16); } -void vFpPpp(x86emu_t *emu, uintptr_t fcn) { vFpPpp_t fn = (vFpPpp_t)fcn; void* save8=NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); fn(*(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); VulkanTox86(arg8, save8); } +void vFpPpp(x86emu_t *emu, uintptr_t fcn) { vFpPpp_t fn = (vFpPpp_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); fn(*(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); VulkanTox86(arg8, save8); } void vFSppi(x86emu_t *emu, uintptr_t fcn) { vFSppi_t fn = (vFSppi_t)fcn; fn(io_convert(*(void**)(R_ESP + 4)), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void cFpiii(x86emu_t *emu, uintptr_t fcn) { cFpiii_t fn = (cFpiii_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void iFEiip(x86emu_t *emu, uintptr_t fcn) { iFEiip_t fn = (iFEiip_t)fcn; R_EAX=fn(emu, *(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12)); } @@ -2788,23 +2771,22 @@ void iFEppu(x86emu_t *emu, uintptr_t fcn) { iFEppu_t fn = (iFEppu_t)fcn; R_EAX=f void iFEppL(x86emu_t *emu, uintptr_t fcn) { iFEppL_t fn = (iFEppL_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12)); } void iFEppp(x86emu_t *emu, uintptr_t fcn) { iFEppp_t fn = (iFEppp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); } void iFEppV(x86emu_t *emu, uintptr_t fcn) { iFEppV_t fn = (iFEppV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), (void*)(R_ESP + 12)); } -void iFEpVV(x86emu_t *emu, uintptr_t fcn) { iFEpVV_t fn = (iFEpVV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), (void*)(R_ESP + 8), (void*)(R_ESP + 8)); } void iFEpOu(x86emu_t *emu, uintptr_t fcn) { iFEpOu_t fn = (iFEpOu_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), of_convert(*(int32_t*)(R_ESP + 8)), *(uint32_t*)(R_ESP + 12)); } void iFEpOV(x86emu_t *emu, uintptr_t fcn) { iFEpOV_t fn = (iFEpOV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), of_convert(*(int32_t*)(R_ESP + 8)), (void*)(R_ESP + 12)); } -void iFEPpp(x86emu_t *emu, uintptr_t fcn) { iFEPpp_t fn = (iFEPpp_t)fcn; void* save4=NULL; void *arg4 = VulkanFromx86(*(void**)(R_ESP + 4), &save4); R_EAX=fn(emu, arg4, *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); VulkanTox86(arg4, save4); } +void iFEPpp(x86emu_t *emu, uintptr_t fcn) { iFEPpp_t fn = (iFEPpp_t)fcn; void* save4 = NULL; void *arg4 = VulkanFromx86(*(void**)(R_ESP + 4), &save4); R_EAX=fn(emu, arg4, *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); VulkanTox86(arg4, save4); } void iFwwww(x86emu_t *emu, uintptr_t fcn) { iFwwww_t fn = (iFwwww_t)fcn; R_EAX=fn(*(int16_t*)(R_ESP + 4), *(int16_t*)(R_ESP + 8), *(int16_t*)(R_ESP + 12), *(int16_t*)(R_ESP + 16)); } void iFwppp(x86emu_t *emu, uintptr_t fcn) { iFwppp_t fn = (iFwppp_t)fcn; R_EAX=fn(*(int16_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); } void iFiiii(x86emu_t *emu, uintptr_t fcn) { iFiiii_t fn = (iFiiii_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void iFiiiu(x86emu_t *emu, uintptr_t fcn) { iFiiiu_t fn = (iFiiiu_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); } void iFiiip(x86emu_t *emu, uintptr_t fcn) { iFiiip_t fn = (iFiiip_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); } void iFiiII(x86emu_t *emu, uintptr_t fcn) { iFiiII_t fn = (iFiiII_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int64_t*)(R_ESP + 12), *(int64_t*)(R_ESP + 20)); } -void iFiiLi(x86emu_t *emu, uintptr_t fcn) { iFiiLi_t fn = (iFiiLi_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } +void iFiiui(x86emu_t *emu, uintptr_t fcn) { iFiiui_t fn = (iFiiui_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void iFiipi(x86emu_t *emu, uintptr_t fcn) { iFiipi_t fn = (iFiipi_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void iFiipp(x86emu_t *emu, uintptr_t fcn) { iFiipp_t fn = (iFiipp_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); } +void iFiuwp(x86emu_t *emu, uintptr_t fcn) { iFiuwp_t fn = (iFiuwp_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int16_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); } void iFiuii(x86emu_t *emu, uintptr_t fcn) { iFiuii_t fn = (iFiuii_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void iFiuui(x86emu_t *emu, uintptr_t fcn) { iFiuui_t fn = (iFiuui_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void iFiupp(x86emu_t *emu, uintptr_t fcn) { iFiupp_t fn = (iFiupp_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); } -void iFiLwp(x86emu_t *emu, uintptr_t fcn) { iFiLwp_t fn = (iFiLwp_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(int16_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); } void iFipii(x86emu_t *emu, uintptr_t fcn) { iFipii_t fn = (iFipii_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void iFipip(x86emu_t *emu, uintptr_t fcn) { iFipip_t fn = (iFipip_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); } void iFipui(x86emu_t *emu, uintptr_t fcn) { iFipui_t fn = (iFipui_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } @@ -2821,10 +2803,11 @@ void iFuuff(x86emu_t *emu, uintptr_t fcn) { iFuuff_t fn = (iFuuff_t)fcn; R_EAX=f void iFupup(x86emu_t *emu, uintptr_t fcn) { iFupup_t fn = (iFupup_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); } void iFuppi(x86emu_t *emu, uintptr_t fcn) { iFuppi_t fn = (iFuppi_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void iFuppp(x86emu_t *emu, uintptr_t fcn) { iFuppp_t fn = (iFuppp_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); } +void iFpwww(x86emu_t *emu, uintptr_t fcn) { iFpwww_t fn = (iFpwww_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int16_t*)(R_ESP + 8), *(int16_t*)(R_ESP + 12), *(int16_t*)(R_ESP + 16)); } +void iFpwpp(x86emu_t *emu, uintptr_t fcn) { iFpwpp_t fn = (iFpwpp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int16_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); } void iFpiii(x86emu_t *emu, uintptr_t fcn) { iFpiii_t fn = (iFpiii_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void iFpiiu(x86emu_t *emu, uintptr_t fcn) { iFpiiu_t fn = (iFpiiu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); } void iFpiid(x86emu_t *emu, uintptr_t fcn) { iFpiid_t fn = (iFpiid_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(double*)(R_ESP + 16)); } -void iFpiiL(x86emu_t *emu, uintptr_t fcn) { iFpiiL_t fn = (iFpiiL_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uintptr_t*)(R_ESP + 16)); } void iFpiip(x86emu_t *emu, uintptr_t fcn) { iFpiip_t fn = (iFpiip_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); } void iFpiuu(x86emu_t *emu, uintptr_t fcn) { iFpiuu_t fn = (iFpiuu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); } void iFpiuL(x86emu_t *emu, uintptr_t fcn) { iFpiuL_t fn = (iFpiuL_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uintptr_t*)(R_ESP + 16)); } @@ -2838,6 +2821,7 @@ void iFpIip(x86emu_t *emu, uintptr_t fcn) { iFpIip_t fn = (iFpIip_t)fcn; R_EAX=f void iFpCCC(x86emu_t *emu, uintptr_t fcn) { iFpCCC_t fn = (iFpCCC_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint8_t*)(R_ESP + 8), *(uint8_t*)(R_ESP + 12), *(uint8_t*)(R_ESP + 16)); } void iFpCpi(x86emu_t *emu, uintptr_t fcn) { iFpCpi_t fn = (iFpCpi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint8_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void iFpWWu(x86emu_t *emu, uintptr_t fcn) { iFpWWu_t fn = (iFpWWu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint16_t*)(R_ESP + 8), *(uint16_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); } +void iFpuwp(x86emu_t *emu, uintptr_t fcn) { iFpuwp_t fn = (iFpuwp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int16_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); } void iFpuii(x86emu_t *emu, uintptr_t fcn) { iFpuii_t fn = (iFpuii_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void iFpuiu(x86emu_t *emu, uintptr_t fcn) { iFpuiu_t fn = (iFpuiu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); } void iFpuiL(x86emu_t *emu, uintptr_t fcn) { iFpuiL_t fn = (iFpuiL_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uintptr_t*)(R_ESP + 16)); } @@ -2852,13 +2836,12 @@ void iFpupi(x86emu_t *emu, uintptr_t fcn) { iFpupi_t fn = (iFpupi_t)fcn; R_EAX=f void iFpupu(x86emu_t *emu, uintptr_t fcn) { iFpupu_t fn = (iFpupu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); } void iFpupp(x86emu_t *emu, uintptr_t fcn) { iFpupp_t fn = (iFpupp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); } void iFpupV(x86emu_t *emu, uintptr_t fcn) { iFpupV_t fn = (iFpupV_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), (void*)(R_ESP + 16)); } -void iFpuPU(x86emu_t *emu, uintptr_t fcn) { iFpuPU_t fn = (iFpuPU_t)fcn; void* save12=NULL; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12), &save12); R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), arg12, *(uint64_t*)(R_ESP + 16)); VulkanTox86(arg12, save12); } +void iFpuPU(x86emu_t *emu, uintptr_t fcn) { iFpuPU_t fn = (iFpuPU_t)fcn; void* save12 = NULL; void *arg12 = VulkanFromx86(*(void**)(R_ESP + 12), &save12); R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), arg12, *(uint64_t*)(R_ESP + 16)); VulkanTox86(arg12, save12); } void iFpUup(x86emu_t *emu, uintptr_t fcn) { iFpUup_t fn = (iFpUup_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFpUUU(x86emu_t *emu, uintptr_t fcn) { iFpUUU_t fn = (iFpUUU_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint64_t*)(R_ESP + 16), *(uint64_t*)(R_ESP + 24)); } void iFpUpp(x86emu_t *emu, uintptr_t fcn) { iFpUpp_t fn = (iFpUpp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFplii(x86emu_t *emu, uintptr_t fcn) { iFplii_t fn = (iFplii_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void iFplip(x86emu_t *emu, uintptr_t fcn) { iFplip_t fn = (iFplip_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); } -void iFpLwp(x86emu_t *emu, uintptr_t fcn) { iFpLwp_t fn = (iFpLwp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(int16_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); } void iFpLpi(x86emu_t *emu, uintptr_t fcn) { iFpLpi_t fn = (iFpLpi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void iFpLpL(x86emu_t *emu, uintptr_t fcn) { iFpLpL_t fn = (iFpLpL_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(uintptr_t*)(R_ESP + 16)); } void iFppii(x86emu_t *emu, uintptr_t fcn) { iFppii_t fn = (iFppii_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } @@ -2883,7 +2866,7 @@ void iFpppC(x86emu_t *emu, uintptr_t fcn) { iFpppC_t fn = (iFpppC_t)fcn; R_EAX=f void iFpppu(x86emu_t *emu, uintptr_t fcn) { iFpppu_t fn = (iFpppu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); } void iFpppL(x86emu_t *emu, uintptr_t fcn) { iFpppL_t fn = (iFpppL_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(uintptr_t*)(R_ESP + 16)); } void iFpppp(x86emu_t *emu, uintptr_t fcn) { iFpppp_t fn = (iFpppp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); } -void iFpPpp(x86emu_t *emu, uintptr_t fcn) { iFpPpp_t fn = (iFpPpp_t)fcn; void* save8=NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); R_EAX=fn(*(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); VulkanTox86(arg8, save8); } +void iFpPpp(x86emu_t *emu, uintptr_t fcn) { iFpPpp_t fn = (iFpPpp_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); R_EAX=fn(*(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); VulkanTox86(arg8, save8); } void iFpGGi(x86emu_t *emu, uintptr_t fcn) { iFpGGi_t fn = (iFpGGi_t)fcn; my_GValue_t arg8; alignGValue(&arg8, *(void**)(R_ESP + 8)); my_GValue_t arg12; alignGValue(&arg12, *(void**)(R_ESP + 12)); R_EAX=fn(*(void**)(R_ESP + 4), &arg8, &arg12, *(int32_t*)(R_ESP + 16)); unalignGValue(*(void**)(R_ESP + 8), &arg8); unalignGValue(*(void**)(R_ESP + 12), &arg12); } void IFEpIi(x86emu_t *emu, uintptr_t fcn) { IFEpIi_t fn = (IFEpIi_t)fcn; ui64_t r; r.i=fn(emu, *(void**)(R_ESP + 4), *(int64_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 16)); R_EAX=r.d[0]; R_EDX=r.d[1]; } void IFpIip(x86emu_t *emu, uintptr_t fcn) { IFpIip_t fn = (IFpIip_t)fcn; ui64_t r; r.i=fn(*(void**)(R_ESP + 4), *(int64_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); R_EAX=r.d[0]; R_EDX=r.d[1]; } @@ -2955,6 +2938,7 @@ void pFipip(x86emu_t *emu, uintptr_t fcn) { pFipip_t fn = (pFipip_t)fcn; R_EAX=( void pFippi(x86emu_t *emu, uintptr_t fcn) { pFippi_t fn = (pFippi_t)fcn; R_EAX=(uintptr_t)fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void pFippu(x86emu_t *emu, uintptr_t fcn) { pFippu_t fn = (pFippu_t)fcn; R_EAX=(uintptr_t)fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); } void pFuiii(x86emu_t *emu, uintptr_t fcn) { pFuiii_t fn = (pFuiii_t)fcn; R_EAX=(uintptr_t)fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } +void pFuuuu(x86emu_t *emu, uintptr_t fcn) { pFuuuu_t fn = (pFuuuu_t)fcn; R_EAX=(uintptr_t)fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); } void pFulli(x86emu_t *emu, uintptr_t fcn) { pFulli_t fn = (pFulli_t)fcn; R_EAX=(uintptr_t)fn(*(uint32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void pFullu(x86emu_t *emu, uintptr_t fcn) { pFullu_t fn = (pFullu_t)fcn; R_EAX=(uintptr_t)fn(*(uint32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); } void pFffff(x86emu_t *emu, uintptr_t fcn) { pFffff_t fn = (pFffff_t)fcn; R_EAX=(uintptr_t)fn(*(float*)(R_ESP + 4), *(float*)(R_ESP + 8), *(float*)(R_ESP + 12), *(float*)(R_ESP + 16)); } @@ -3022,7 +3006,6 @@ void vFiplll(x86emu_t *emu, uintptr_t fcn) { vFiplll_t fn = (vFiplll_t)fcn; fn(* void vFuiiii(x86emu_t *emu, uintptr_t fcn) { vFuiiii_t fn = (vFuiiii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); } void vFuiiiu(x86emu_t *emu, uintptr_t fcn) { vFuiiiu_t fn = (vFuiiiu_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); } void vFuiiip(x86emu_t *emu, uintptr_t fcn) { vFuiiip_t fn = (vFuiiip_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); } -void vFuiiup(x86emu_t *emu, uintptr_t fcn) { vFuiiup_t fn = (vFuiiup_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); } void vFuiifi(x86emu_t *emu, uintptr_t fcn) { vFuiifi_t fn = (vFuiifi_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(float*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); } void vFuiIII(x86emu_t *emu, uintptr_t fcn) { vFuiIII_t fn = (vFuiIII_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int64_t*)(R_ESP + 12), *(int64_t*)(R_ESP + 20), *(int64_t*)(R_ESP + 28)); } void vFuiuii(x86emu_t *emu, uintptr_t fcn) { vFuiuii_t fn = (vFuiuii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); } @@ -3114,11 +3097,12 @@ void iFEiipV(x86emu_t *emu, uintptr_t fcn) { iFEiipV_t fn = (iFEiipV_t)fcn; R_EA void iFEipuu(x86emu_t *emu, uintptr_t fcn) { iFEipuu_t fn = (iFEipuu_t)fcn; R_EAX=fn(emu, *(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); } void iFEippi(x86emu_t *emu, uintptr_t fcn) { iFEippi_t fn = (iFEippi_t)fcn; R_EAX=fn(emu, *(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void iFEippp(x86emu_t *emu, uintptr_t fcn) { iFEippp_t fn = (iFEippp_t)fcn; R_EAX=fn(emu, *(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); } -void iFEipVV(x86emu_t *emu, uintptr_t fcn) { iFEipVV_t fn = (iFEipVV_t)fcn; R_EAX=fn(emu, *(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), (void*)(R_ESP + 12), (void*)(R_ESP + 12)); } +void iFEuuuu(x86emu_t *emu, uintptr_t fcn) { iFEuuuu_t fn = (iFEuuuu_t)fcn; R_EAX=fn(emu, *(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16)); } void iFEpiii(x86emu_t *emu, uintptr_t fcn) { iFEpiii_t fn = (iFEpiii_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void iFEpiup(x86emu_t *emu, uintptr_t fcn) { iFEpiup_t fn = (iFEpiup_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); } void iFEpipi(x86emu_t *emu, uintptr_t fcn) { iFEpipi_t fn = (iFEpipi_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void iFEpipp(x86emu_t *emu, uintptr_t fcn) { iFEpipp_t fn = (iFEpipp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); } +void iFEpipV(x86emu_t *emu, uintptr_t fcn) { iFEpipV_t fn = (iFEpipV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), (void*)(R_ESP + 16)); } void iFEpupV(x86emu_t *emu, uintptr_t fcn) { iFEpupV_t fn = (iFEpupV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), (void*)(R_ESP + 16)); } void iFEpUup(x86emu_t *emu, uintptr_t fcn) { iFEpUup_t fn = (iFEpUup_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFEpLpp(x86emu_t *emu, uintptr_t fcn) { iFEpLpp_t fn = (iFEpLpp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); } @@ -3129,8 +3113,7 @@ void iFEppiV(x86emu_t *emu, uintptr_t fcn) { iFEppiV_t fn = (iFEppiV_t)fcn; R_EA void iFEpplp(x86emu_t *emu, uintptr_t fcn) { iFEpplp_t fn = (iFEpplp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); } void iFEpppp(x86emu_t *emu, uintptr_t fcn) { iFEpppp_t fn = (iFEpppp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); } void iFEpppV(x86emu_t *emu, uintptr_t fcn) { iFEpppV_t fn = (iFEpppV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), (void*)(R_ESP + 16)); } -void iFEppVV(x86emu_t *emu, uintptr_t fcn) { iFEppVV_t fn = (iFEppVV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), (void*)(R_ESP + 12), (void*)(R_ESP + 12)); } -void iFEpPpp(x86emu_t *emu, uintptr_t fcn) { iFEpPpp_t fn = (iFEpPpp_t)fcn; void* save8=NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); R_EAX=fn(emu, *(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); VulkanTox86(arg8, save8); } +void iFEpPpp(x86emu_t *emu, uintptr_t fcn) { iFEpPpp_t fn = (iFEpPpp_t)fcn; void* save8 = NULL; void *arg8 = VulkanFromx86(*(void**)(R_ESP + 8), &save8); R_EAX=fn(emu, *(void**)(R_ESP + 4), arg8, *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); VulkanTox86(arg8, save8); } void iFiiipu(x86emu_t *emu, uintptr_t fcn) { iFiiipu_t fn = (iFiiipu_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); } void iFiiipp(x86emu_t *emu, uintptr_t fcn) { iFiiipp_t fn = (iFiiipp_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFiiupp(x86emu_t *emu, uintptr_t fcn) { iFiiupp_t fn = (iFiiupp_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); } @@ -3146,16 +3129,18 @@ void iFippup(x86emu_t *emu, uintptr_t fcn) { iFippup_t fn = (iFippup_t)fcn; R_EA void iFipppi(x86emu_t *emu, uintptr_t fcn) { iFipppi_t fn = (iFipppi_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); } void iFipppp(x86emu_t *emu, uintptr_t fcn) { iFipppp_t fn = (iFipppp_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFuppup(x86emu_t *emu, uintptr_t fcn) { iFuppup_t fn = (iFuppup_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); } +void iFpwwww(x86emu_t *emu, uintptr_t fcn) { iFpwwww_t fn = (iFpwwww_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int16_t*)(R_ESP + 8), *(int16_t*)(R_ESP + 12), *(int16_t*)(R_ESP + 16), *(int16_t*)(R_ESP + 20)); } +void iFpwppp(x86emu_t *emu, uintptr_t fcn) { iFpwppp_t fn = (iFpwppp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int16_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFpiiii(x86emu_t *emu, uintptr_t fcn) { iFpiiii_t fn = (iFpiiii_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); } void iFpiiiu(x86emu_t *emu, uintptr_t fcn) { iFpiiiu_t fn = (iFpiiiu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); } void iFpiiiL(x86emu_t *emu, uintptr_t fcn) { iFpiiiL_t fn = (iFpiiiL_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uintptr_t*)(R_ESP + 20)); } void iFpiiip(x86emu_t *emu, uintptr_t fcn) { iFpiiip_t fn = (iFpiiip_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); } +void iFpiiui(x86emu_t *emu, uintptr_t fcn) { iFpiiui_t fn = (iFpiiui_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); } void iFpiiuu(x86emu_t *emu, uintptr_t fcn) { iFpiiuu_t fn = (iFpiiuu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); } -void iFpiiLi(x86emu_t *emu, uintptr_t fcn) { iFpiiLi_t fn = (iFpiiLi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uintptr_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); } void iFpiipi(x86emu_t *emu, uintptr_t fcn) { iFpiipi_t fn = (iFpiipi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); } void iFpiipp(x86emu_t *emu, uintptr_t fcn) { iFpiipp_t fn = (iFpiipp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); } +void iFpiuwp(x86emu_t *emu, uintptr_t fcn) { iFpiuwp_t fn = (iFpiuwp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int16_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFpiupu(x86emu_t *emu, uintptr_t fcn) { iFpiupu_t fn = (iFpiupu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); } -void iFpiLwp(x86emu_t *emu, uintptr_t fcn) { iFpiLwp_t fn = (iFpiLwp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12), *(int16_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFpipii(x86emu_t *emu, uintptr_t fcn) { iFpipii_t fn = (iFpipii_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); } void iFpipiL(x86emu_t *emu, uintptr_t fcn) { iFpipiL_t fn = (iFpipiL_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uintptr_t*)(R_ESP + 20)); } void iFpipip(x86emu_t *emu, uintptr_t fcn) { iFpipip_t fn = (iFpipip_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); } @@ -3184,12 +3169,12 @@ void iFppiip(x86emu_t *emu, uintptr_t fcn) { iFppiip_t fn = (iFppiip_t)fcn; R_EA void iFppiup(x86emu_t *emu, uintptr_t fcn) { iFppiup_t fn = (iFppiup_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFppipi(x86emu_t *emu, uintptr_t fcn) { iFppipi_t fn = (iFppipi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); } void iFppipp(x86emu_t *emu, uintptr_t fcn) { iFppipp_t fn = (iFppipp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); } +void iFppuwp(x86emu_t *emu, uintptr_t fcn) { iFppuwp_t fn = (iFppuwp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int16_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFppuip(x86emu_t *emu, uintptr_t fcn) { iFppuip_t fn = (iFppuip_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFppupi(x86emu_t *emu, uintptr_t fcn) { iFppupi_t fn = (iFppupi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); } void iFppupp(x86emu_t *emu, uintptr_t fcn) { iFppupp_t fn = (iFppupp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFppllp(x86emu_t *emu, uintptr_t fcn) { iFppllp_t fn = (iFppllp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFpplpp(x86emu_t *emu, uintptr_t fcn) { iFpplpp_t fn = (iFpplpp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); } -void iFppLwp(x86emu_t *emu, uintptr_t fcn) { iFppLwp_t fn = (iFppLwp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12), *(int16_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFppLip(x86emu_t *emu, uintptr_t fcn) { iFppLip_t fn = (iFppLip_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFppLpi(x86emu_t *emu, uintptr_t fcn) { iFppLpi_t fn = (iFppLpi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); } void iFppLpL(x86emu_t *emu, uintptr_t fcn) { iFppLpL_t fn = (iFppLpL_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(uintptr_t*)(R_ESP + 20)); } @@ -3200,6 +3185,7 @@ void iFpppip(x86emu_t *emu, uintptr_t fcn) { iFpppip_t fn = (iFpppip_t)fcn; R_EA void iFpppui(x86emu_t *emu, uintptr_t fcn) { iFpppui_t fn = (iFpppui_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); } void iFpppuu(x86emu_t *emu, uintptr_t fcn) { iFpppuu_t fn = (iFpppuu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); } void iFpppup(x86emu_t *emu, uintptr_t fcn) { iFpppup_t fn = (iFpppup_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); } +void iFpppLi(x86emu_t *emu, uintptr_t fcn) { iFpppLi_t fn = (iFpppLi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(uintptr_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); } void iFppppi(x86emu_t *emu, uintptr_t fcn) { iFppppi_t fn = (iFppppi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); } void iFppppu(x86emu_t *emu, uintptr_t fcn) { iFppppu_t fn = (iFppppu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(uint32_t*)(R_ESP + 20)); } void iFppppL(x86emu_t *emu, uintptr_t fcn) { iFppppL_t fn = (iFppppL_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(uintptr_t*)(R_ESP + 20)); } @@ -3322,7 +3308,6 @@ void vFuiupiu(x86emu_t *emu, uintptr_t fcn) { vFuiupiu_t fn = (vFuiupiu_t)fcn; f void vFuiUUUU(x86emu_t *emu, uintptr_t fcn) { vFuiUUUU_t fn = (vFuiUUUU_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint64_t*)(R_ESP + 12), *(uint64_t*)(R_ESP + 20), *(uint64_t*)(R_ESP + 28), *(uint64_t*)(R_ESP + 36)); } void vFuiffff(x86emu_t *emu, uintptr_t fcn) { vFuiffff_t fn = (vFuiffff_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(float*)(R_ESP + 12), *(float*)(R_ESP + 16), *(float*)(R_ESP + 20), *(float*)(R_ESP + 24)); } void vFuidddd(x86emu_t *emu, uintptr_t fcn) { vFuidddd_t fn = (vFuidddd_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(double*)(R_ESP + 12), *(double*)(R_ESP + 20), *(double*)(R_ESP + 28), *(double*)(R_ESP + 36)); } -void vFuipiup(x86emu_t *emu, uintptr_t fcn) { vFuipiup_t fn = (vFuipiup_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(void**)(R_ESP + 24)); } void vFuuiiii(x86emu_t *emu, uintptr_t fcn) { vFuuiiii_t fn = (vFuuiiii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24)); } void vFuuiiiu(x86emu_t *emu, uintptr_t fcn) { vFuuiiiu_t fn = (vFuuiiiu_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24)); } void vFuuiuii(x86emu_t *emu, uintptr_t fcn) { vFuuiuii_t fn = (vFuuiuii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24)); } @@ -3407,17 +3392,14 @@ void iFEpiipV(x86emu_t *emu, uintptr_t fcn) { iFEpiipV_t fn = (iFEpiipV_t)fcn; R void iFEpiLpp(x86emu_t *emu, uintptr_t fcn) { iFEpiLpp_t fn = (iFEpiLpp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFEpippi(x86emu_t *emu, uintptr_t fcn) { iFEpippi_t fn = (iFEpippi_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(int32_t*)(R_ESP + 20)); } void iFEpippp(x86emu_t *emu, uintptr_t fcn) { iFEpippp_t fn = (iFEpippp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); } -void iFEpipVV(x86emu_t *emu, uintptr_t fcn) { iFEpipVV_t fn = (iFEpipVV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), (void*)(R_ESP + 16), (void*)(R_ESP + 16)); } void iFEpuuip(x86emu_t *emu, uintptr_t fcn) { iFEpuuip_t fn = (iFEpuuip_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFEpuppp(x86emu_t *emu, uintptr_t fcn) { iFEpuppp_t fn = (iFEpuppp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); } -void iFEpupVV(x86emu_t *emu, uintptr_t fcn) { iFEpupVV_t fn = (iFEpupVV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), (void*)(R_ESP + 16), (void*)(R_ESP + 16)); } -void iFEpUPpp(x86emu_t *emu, uintptr_t fcn) { iFEpUPpp_t fn = (iFEpUPpp_t)fcn; void* save16=NULL; void *arg16 = VulkanFromx86(*(void**)(R_ESP + 16), &save16); R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), arg16, *(void**)(R_ESP + 20), *(void**)(R_ESP + 24)); VulkanTox86(arg16, save16); } +void iFEpUPpp(x86emu_t *emu, uintptr_t fcn) { iFEpUPpp_t fn = (iFEpUPpp_t)fcn; void* save16 = NULL; void *arg16 = VulkanFromx86(*(void**)(R_ESP + 16), &save16); R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), arg16, *(void**)(R_ESP + 20), *(void**)(R_ESP + 24)); VulkanTox86(arg16, save16); } void iFEpLppp(x86emu_t *emu, uintptr_t fcn) { iFEpLppp_t fn = (iFEpLppp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); } -void iFEpLpVV(x86emu_t *emu, uintptr_t fcn) { iFEpLpVV_t fn = (iFEpLpVV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(void**)(R_ESP + 12), (void*)(R_ESP + 16), (void*)(R_ESP + 16)); } void iFEppppp(x86emu_t *emu, uintptr_t fcn) { iFEppppp_t fn = (iFEppppp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20)); } void iFiiiiii(x86emu_t *emu, uintptr_t fcn) { iFiiiiii_t fn = (iFiiiiii_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24)); } void iFiiiiip(x86emu_t *emu, uintptr_t fcn) { iFiiiiip_t fn = (iFiiiiip_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(void**)(R_ESP + 24)); } -void iFiiiLwp(x86emu_t *emu, uintptr_t fcn) { iFiiiLwp_t fn = (iFiiiLwp_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uintptr_t*)(R_ESP + 16), *(int16_t*)(R_ESP + 20), *(void**)(R_ESP + 24)); } +void iFiiiuwp(x86emu_t *emu, uintptr_t fcn) { iFiiiuwp_t fn = (iFiiiuwp_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(int16_t*)(R_ESP + 20), *(void**)(R_ESP + 24)); } void iFiuiipi(x86emu_t *emu, uintptr_t fcn) { iFiuiipi_t fn = (iFiuiipi_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(int32_t*)(R_ESP + 24)); } void iFipipuu(x86emu_t *emu, uintptr_t fcn) { iFipipuu_t fn = (iFipipuu_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24)); } void iFipuufp(x86emu_t *emu, uintptr_t fcn) { iFipuufp_t fn = (iFipuufp_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(float*)(R_ESP + 20), *(void**)(R_ESP + 24)); } @@ -3535,10 +3517,8 @@ void vFEpuipuV(x86emu_t *emu, uintptr_t fcn) { vFEpuipuV_t fn = (vFEpuipuV_t)fcn void vFEpppppp(x86emu_t *emu, uintptr_t fcn) { vFEpppppp_t fn = (vFEpppppp_t)fcn; fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24)); } void vFiiiiiip(x86emu_t *emu, uintptr_t fcn) { vFiiiiiip_t fn = (vFiiiiiip_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); } void vFiiiiuup(x86emu_t *emu, uintptr_t fcn) { vFiiiiuup_t fn = (vFiiiiuup_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); } -void vFiiupuip(x86emu_t *emu, uintptr_t fcn) { vFiiupuip_t fn = (vFiiupuip_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); } void vFiiffffp(x86emu_t *emu, uintptr_t fcn) { vFiiffffp_t fn = (vFiiffffp_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(float*)(R_ESP + 12), *(float*)(R_ESP + 16), *(float*)(R_ESP + 20), *(float*)(R_ESP + 24), *(void**)(R_ESP + 28)); } void vFiipllli(x86emu_t *emu, uintptr_t fcn) { vFiipllli_t fn = (vFiipllli_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(intptr_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28)); } -void vFiupuuup(x86emu_t *emu, uintptr_t fcn) { vFiupuuup_t fn = (vFiupuuup_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); } void vFuiiiiii(x86emu_t *emu, uintptr_t fcn) { vFuiiiiii_t fn = (vFuiiiiii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28)); } void vFuiiiuip(x86emu_t *emu, uintptr_t fcn) { vFuiiiuip_t fn = (vFuiiiuip_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); } void vFuiiiuup(x86emu_t *emu, uintptr_t fcn) { vFuiiiuup_t fn = (vFuiiiuup_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); } @@ -3614,6 +3594,7 @@ void vFppppppp(x86emu_t *emu, uintptr_t fcn) { vFppppppp_t fn = (vFppppppp_t)fcn void iFEpuiupV(x86emu_t *emu, uintptr_t fcn) { iFEpuiupV_t fn = (iFEpuiupV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(void**)(R_ESP + 20), (void*)(R_ESP + 24)); } void iFEpupppp(x86emu_t *emu, uintptr_t fcn) { iFEpupppp_t fn = (iFEpupppp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24)); } void iFEpUuppp(x86emu_t *emu, uintptr_t fcn) { iFEpUuppp_t fn = (iFEpUuppp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint64_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28)); } +void iFEpLiipV(x86emu_t *emu, uintptr_t fcn) { iFEpLiipV_t fn = (iFEpLiipV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20), (void*)(R_ESP + 24)); } void iFEppiuui(x86emu_t *emu, uintptr_t fcn) { iFEppiuui_t fn = (iFEppiuui_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24)); } void iFEppupIi(x86emu_t *emu, uintptr_t fcn) { iFEppupIi_t fn = (iFEppupIi_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(int64_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 28)); } void iFEppuppp(x86emu_t *emu, uintptr_t fcn) { iFEppuppp_t fn = (iFEppuppp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24)); } @@ -3623,7 +3604,7 @@ void iFEpppppp(x86emu_t *emu, uintptr_t fcn) { iFEpppppp_t fn = (iFEpppppp_t)fcn void iFiiiiiip(x86emu_t *emu, uintptr_t fcn) { iFiiiiiip_t fn = (iFiiiiiip_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); } void iFpiiiiii(x86emu_t *emu, uintptr_t fcn) { iFpiiiiii_t fn = (iFpiiiiii_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28)); } void iFpiiiiip(x86emu_t *emu, uintptr_t fcn) { iFpiiiiip_t fn = (iFpiiiiip_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); } -void iFpiiiLwp(x86emu_t *emu, uintptr_t fcn) { iFpiiiLwp_t fn = (iFpiiiLwp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uintptr_t*)(R_ESP + 20), *(int16_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); } +void iFpiiiuwp(x86emu_t *emu, uintptr_t fcn) { iFpiiiuwp_t fn = (iFpiiiuwp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(int16_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); } void iFpiiuuiu(x86emu_t *emu, uintptr_t fcn) { iFpiiuuiu_t fn = (iFpiiuuiu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28)); } void iFpiiuuuu(x86emu_t *emu, uintptr_t fcn) { iFpiiuuuu_t fn = (iFpiiuuuu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28)); } void iFpiipppp(x86emu_t *emu, uintptr_t fcn) { iFpiipppp_t fn = (iFpiipppp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28)); } @@ -3721,13 +3702,10 @@ void vFEppipppp(x86emu_t *emu, uintptr_t fcn) { vFEppipppp_t fn = (vFEppipppp_t) void vFEpppuipV(x86emu_t *emu, uintptr_t fcn) { vFEpppuipV_t fn = (vFEpppuipV_t)fcn; fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(void**)(R_ESP + 24), (void*)(R_ESP + 28)); } void vFEpppppuu(x86emu_t *emu, uintptr_t fcn) { vFEpppppuu_t fn = (vFEpppppuu_t)fcn; fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28)); } void vFiiiiuuip(x86emu_t *emu, uintptr_t fcn) { vFiiiiuuip_t fn = (vFiiiiuuip_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(void**)(R_ESP + 32)); } -void vFiupuiuup(x86emu_t *emu, uintptr_t fcn) { vFiupuiuup_t fn = (vFiupuiuup_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(void**)(R_ESP + 32)); } -void vFiupuuuup(x86emu_t *emu, uintptr_t fcn) { vFiupuuuup_t fn = (vFiupuuuup_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(void**)(R_ESP + 32)); } void vFilipufip(x86emu_t *emu, uintptr_t fcn) { vFilipufip_t fn = (vFilipufip_t)fcn; fn(*(int32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(float*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(void**)(R_ESP + 32)); } void vFuiiiiiii(x86emu_t *emu, uintptr_t fcn) { vFuiiiiiii_t fn = (vFuiiiiiii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32)); } void vFuiiiiill(x86emu_t *emu, uintptr_t fcn) { vFuiiiiill_t fn = (vFuiiiiill_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(intptr_t*)(R_ESP + 28), *(intptr_t*)(R_ESP + 32)); } void vFuiiiiuup(x86emu_t *emu, uintptr_t fcn) { vFuiiiiuup_t fn = (vFuiiiiuup_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(void**)(R_ESP + 32)); } -void vFuiiipiup(x86emu_t *emu, uintptr_t fcn) { vFuiiipiup_t fn = (vFuiiipiup_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(void**)(R_ESP + 32)); } void vFuiuiiiii(x86emu_t *emu, uintptr_t fcn) { vFuiuiiiii_t fn = (vFuiuiiiii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32)); } void vFuiuiiiip(x86emu_t *emu, uintptr_t fcn) { vFuiuiiiip_t fn = (vFuiuiiiip_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(void**)(R_ESP + 32)); } void vFuiulplpp(x86emu_t *emu, uintptr_t fcn) { vFuiulplpp_t fn = (vFuiulplpp_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(intptr_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(intptr_t*)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32)); } @@ -3768,15 +3746,12 @@ void iFEpippppp(x86emu_t *emu, uintptr_t fcn) { iFEpippppp_t fn = (iFEpippppp_t) void iFEpuuiipp(x86emu_t *emu, uintptr_t fcn) { iFEpuuiipp_t fn = (iFEpuuiipp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28)); } void iFEpuuuipp(x86emu_t *emu, uintptr_t fcn) { iFEpuuuipp_t fn = (iFEpuuuipp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28)); } void iFEpuuLppp(x86emu_t *emu, uintptr_t fcn) { iFEpuuLppp_t fn = (iFEpuuLppp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uintptr_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28)); } -void iFEpLiipVV(x86emu_t *emu, uintptr_t fcn) { iFEpLiipVV_t fn = (iFEpLiipVV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20), (void*)(R_ESP + 24), (void*)(R_ESP + 24)); } void iFEppppipp(x86emu_t *emu, uintptr_t fcn) { iFEppppipp_t fn = (iFEppppipp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28)); } void iFiiiiiiip(x86emu_t *emu, uintptr_t fcn) { iFiiiiiiip_t fn = (iFiiiiiiip_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(void**)(R_ESP + 32)); } void iFiiupiupi(x86emu_t *emu, uintptr_t fcn) { iFiiupiupi_t fn = (iFiiupiupi_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(void**)(R_ESP + 28), *(int32_t*)(R_ESP + 32)); } -void iFuiifpppp(x86emu_t *emu, uintptr_t fcn) { iFuiifpppp_t fn = (iFuiifpppp_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(float*)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32)); } void iFuipuuluf(x86emu_t *emu, uintptr_t fcn) { iFuipuuluf_t fn = (iFuipuuluf_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(intptr_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(float*)(R_ESP + 32)); } +void iFuuuuuuuu(x86emu_t *emu, uintptr_t fcn) { iFuuuuuuuu_t fn = (iFuuuuuuuu_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(uint32_t*)(R_ESP + 32)); } void iFullfpppp(x86emu_t *emu, uintptr_t fcn) { iFullfpppp_t fn = (iFullfpppp_t)fcn; R_EAX=fn(*(uint32_t*)(R_ESP + 4), *(intptr_t*)(R_ESP + 8), *(intptr_t*)(R_ESP + 12), *(float*)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32)); } -void iFLLLLLLLL(x86emu_t *emu, uintptr_t fcn) { iFLLLLLLLL_t fn = (iFLLLLLLLL_t)fcn; R_EAX=fn(*(uintptr_t*)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12), *(uintptr_t*)(R_ESP + 16), *(uintptr_t*)(R_ESP + 20), *(uintptr_t*)(R_ESP + 24), *(uintptr_t*)(R_ESP + 28), *(uintptr_t*)(R_ESP + 32)); } -void iFpiiiiipi(x86emu_t *emu, uintptr_t fcn) { iFpiiiiipi_t fn = (iFpiiiiipi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(void**)(R_ESP + 28), *(int32_t*)(R_ESP + 32)); } void iFpCCWWpWu(x86emu_t *emu, uintptr_t fcn) { iFpCCWWpWu_t fn = (iFpCCWWpWu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint8_t*)(R_ESP + 8), *(uint8_t*)(R_ESP + 12), *(uint16_t*)(R_ESP + 16), *(uint16_t*)(R_ESP + 20), *(void**)(R_ESP + 24), *(uint16_t*)(R_ESP + 28), *(uint32_t*)(R_ESP + 32)); } void iFpWCuWCuu(x86emu_t *emu, uintptr_t fcn) { iFpWCuWCuu_t fn = (iFpWCuWCuu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint16_t*)(R_ESP + 8), *(uint8_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint16_t*)(R_ESP + 20), *(uint8_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(uint32_t*)(R_ESP + 32)); } void iFpuiipppp(x86emu_t *emu, uintptr_t fcn) { iFpuiipppp_t fn = (iFpuiipppp_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32)); } @@ -3838,14 +3813,12 @@ void vFuiiiillli(x86emu_t *emu, uintptr_t fcn) { vFuiiiillli_t fn = (vFuiiiillli void vFuiiilliip(x86emu_t *emu, uintptr_t fcn) { vFuiiilliip_t fn = (vFuiiilliip_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(intptr_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(void**)(R_ESP + 36)); } void vFuiiillilp(x86emu_t *emu, uintptr_t fcn) { vFuiiillilp_t fn = (vFuiiillilp_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(intptr_t*)(R_ESP + 20), *(intptr_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(intptr_t*)(R_ESP + 32), *(void**)(R_ESP + 36)); } void vFuiuiiiiip(x86emu_t *emu, uintptr_t fcn) { vFuiuiiiiip_t fn = (vFuiuiiiiip_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(void**)(R_ESP + 36)); } -void vFuiupuffup(x86emu_t *emu, uintptr_t fcn) { vFuiupuffup_t fn = (vFuiupuffup_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(float*)(R_ESP + 24), *(float*)(R_ESP + 28), *(uint32_t*)(R_ESP + 32), *(void**)(R_ESP + 36)); } void vFuuiiiiiii(x86emu_t *emu, uintptr_t fcn) { vFuuiiiiiii_t fn = (vFuuiiiiiii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36)); } void vFuuiuiiiii(x86emu_t *emu, uintptr_t fcn) { vFuuiuiiiii_t fn = (vFuuiuiiiii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36)); } void vFuuiuiiiip(x86emu_t *emu, uintptr_t fcn) { vFuuiuiiiip_t fn = (vFuuiuiiiip_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(void**)(R_ESP + 36)); } void vFuuiuiiuup(x86emu_t *emu, uintptr_t fcn) { vFuuiuiiuup_t fn = (vFuuiuiiuup_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(uint32_t*)(R_ESP + 32), *(void**)(R_ESP + 36)); } void vFuuuiiiiip(x86emu_t *emu, uintptr_t fcn) { vFuuuiiiiip_t fn = (vFuuuiiiiip_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(void**)(R_ESP + 36)); } void vFuuuuuuuuu(x86emu_t *emu, uintptr_t fcn) { vFuuuuuuuuu_t fn = (vFuuuuuuuuu_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(uint32_t*)(R_ESP + 32), *(uint32_t*)(R_ESP + 36)); } -void vFuupiuiuuf(x86emu_t *emu, uintptr_t fcn) { vFuupiuiuuf_t fn = (vFuupiuiuuf_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(uint32_t*)(R_ESP + 32), *(float*)(R_ESP + 36)); } void vFuffffffff(x86emu_t *emu, uintptr_t fcn) { vFuffffffff_t fn = (vFuffffffff_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(float*)(R_ESP + 8), *(float*)(R_ESP + 12), *(float*)(R_ESP + 16), *(float*)(R_ESP + 20), *(float*)(R_ESP + 24), *(float*)(R_ESP + 28), *(float*)(R_ESP + 32), *(float*)(R_ESP + 36)); } void vFffuuuufff(x86emu_t *emu, uintptr_t fcn) { vFffuuuufff_t fn = (vFffuuuufff_t)fcn; fn(*(float*)(R_ESP + 4), *(float*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(float*)(R_ESP + 28), *(float*)(R_ESP + 32), *(float*)(R_ESP + 36)); } void vFddddddddd(x86emu_t *emu, uintptr_t fcn) { vFddddddddd_t fn = (vFddddddddd_t)fcn; fn(*(double*)(R_ESP + 4), *(double*)(R_ESP + 12), *(double*)(R_ESP + 20), *(double*)(R_ESP + 28), *(double*)(R_ESP + 36), *(double*)(R_ESP + 44), *(double*)(R_ESP + 52), *(double*)(R_ESP + 60), *(double*)(R_ESP + 68)); } @@ -3877,8 +3850,8 @@ void iFdddpppppp(x86emu_t *emu, uintptr_t fcn) { iFdddpppppp_t fn = (iFdddpppppp void iFpiuuupipu(x86emu_t *emu, uintptr_t fcn) { iFpiuuupipu_t fn = (iFpiuuupipu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(void**)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(void**)(R_ESP + 32), *(uint32_t*)(R_ESP + 36)); } void iFpipLpiiip(x86emu_t *emu, uintptr_t fcn) { iFpipLpiiip_t fn = (iFpipLpiiip_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(uintptr_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(void**)(R_ESP + 36)); } void iFpuiuuipip(x86emu_t *emu, uintptr_t fcn) { iFpuiuuipip_t fn = (iFpuiuuipip_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(void**)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(void**)(R_ESP + 36)); } +void iFpuuuuuuuu(x86emu_t *emu, uintptr_t fcn) { iFpuuuuuuuu_t fn = (iFpuuuuuuuu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(uint32_t*)(R_ESP + 32), *(uint32_t*)(R_ESP + 36)); } void iFpupuupWWu(x86emu_t *emu, uintptr_t fcn) { iFpupuupWWu_t fn = (iFpupuupWWu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(void**)(R_ESP + 24), *(uint16_t*)(R_ESP + 28), *(uint16_t*)(R_ESP + 32), *(uint32_t*)(R_ESP + 36)); } -void iFpLLLLLLLL(x86emu_t *emu, uintptr_t fcn) { iFpLLLLLLLL_t fn = (iFpLLLLLLLL_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(uintptr_t*)(R_ESP + 8), *(uintptr_t*)(R_ESP + 12), *(uintptr_t*)(R_ESP + 16), *(uintptr_t*)(R_ESP + 20), *(uintptr_t*)(R_ESP + 24), *(uintptr_t*)(R_ESP + 28), *(uintptr_t*)(R_ESP + 32), *(uintptr_t*)(R_ESP + 36)); } void iFppiiiiiii(x86emu_t *emu, uintptr_t fcn) { iFppiiiiiii_t fn = (iFppiiiiiii_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36)); } void iFppiuiippu(x86emu_t *emu, uintptr_t fcn) { iFppiuiippu_t fn = (iFppiuiippu_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(void**)(R_ESP + 28), *(void**)(R_ESP + 32), *(uint32_t*)(R_ESP + 36)); } void iFppipiiipi(x86emu_t *emu, uintptr_t fcn) { iFppipiiipi_t fn = (iFppipiiipi_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(void**)(R_ESP + 32), *(int32_t*)(R_ESP + 36)); } @@ -3927,7 +3900,6 @@ void vFuuiuiiiiip(x86emu_t *emu, uintptr_t fcn) { vFuuiuiiiiip_t fn = (vFuuiuiii void vFuuiuiiiuup(x86emu_t *emu, uintptr_t fcn) { vFuuiuiiiuup_t fn = (vFuuiuiiiuup_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(uint32_t*)(R_ESP + 32), *(uint32_t*)(R_ESP + 36), *(void**)(R_ESP + 40)); } void vFuuuuuuuiii(x86emu_t *emu, uintptr_t fcn) { vFuuuuuuuiii_t fn = (vFuuuuuuuiii_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(int32_t*)(R_ESP + 40)); } void vFuuuuuuuuuu(x86emu_t *emu, uintptr_t fcn) { vFuuuuuuuuuu_t fn = (vFuuuuuuuuuu_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(uint32_t*)(R_ESP + 12), *(uint32_t*)(R_ESP + 16), *(uint32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(uint32_t*)(R_ESP + 28), *(uint32_t*)(R_ESP + 32), *(uint32_t*)(R_ESP + 36), *(uint32_t*)(R_ESP + 40)); } -void vFuupiiupuuf(x86emu_t *emu, uintptr_t fcn) { vFuupiiupuuf_t fn = (vFuupiiupuuf_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), *(void**)(R_ESP + 28), *(uint32_t*)(R_ESP + 32), *(uint32_t*)(R_ESP + 36), *(float*)(R_ESP + 40)); } void vFuffiiffiip(x86emu_t *emu, uintptr_t fcn) { vFuffiiffiip_t fn = (vFuffiiffiip_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(float*)(R_ESP + 8), *(float*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(float*)(R_ESP + 24), *(float*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(void**)(R_ESP + 40)); } void vFuddiiddiip(x86emu_t *emu, uintptr_t fcn) { vFuddiiddiip_t fn = (vFuddiiddiip_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(double*)(R_ESP + 8), *(double*)(R_ESP + 16), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(double*)(R_ESP + 32), *(double*)(R_ESP + 40), *(int32_t*)(R_ESP + 48), *(int32_t*)(R_ESP + 52), *(void**)(R_ESP + 56)); } void vFffffffffff(x86emu_t *emu, uintptr_t fcn) { vFffffffffff_t fn = (vFffffffffff_t)fcn; fn(*(float*)(R_ESP + 4), *(float*)(R_ESP + 8), *(float*)(R_ESP + 12), *(float*)(R_ESP + 16), *(float*)(R_ESP + 20), *(float*)(R_ESP + 24), *(float*)(R_ESP + 28), *(float*)(R_ESP + 32), *(float*)(R_ESP + 36), *(float*)(R_ESP + 40)); } @@ -3981,7 +3953,7 @@ void vFuuddiiddiip(x86emu_t *emu, uintptr_t fcn) { vFuuddiiddiip_t fn = (vFuuddi void vFuffffffffff(x86emu_t *emu, uintptr_t fcn) { vFuffffffffff_t fn = (vFuffffffffff_t)fcn; fn(*(uint32_t*)(R_ESP + 4), *(float*)(R_ESP + 8), *(float*)(R_ESP + 12), *(float*)(R_ESP + 16), *(float*)(R_ESP + 20), *(float*)(R_ESP + 24), *(float*)(R_ESP + 28), *(float*)(R_ESP + 32), *(float*)(R_ESP + 36), *(float*)(R_ESP + 40), *(float*)(R_ESP + 44)); } void vFpipipiipiii(x86emu_t *emu, uintptr_t fcn) { vFpipipiipiii_t fn = (vFpipipiipiii_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(void**)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(void**)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(int32_t*)(R_ESP + 40), *(int32_t*)(R_ESP + 44)); } void vFpipppiiiipi(x86emu_t *emu, uintptr_t fcn) { vFpipppiiiipi_t fn = (vFpipppiiiipi_t)fcn; fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(void**)(R_ESP + 40), *(int32_t*)(R_ESP + 44)); } -void vFpupiiuPuPuP(x86emu_t *emu, uintptr_t fcn) { vFpupiiuPuPuP_t fn = (vFpupiiuPuPuP_t)fcn; void* save28=NULL; void *arg28 = VulkanFromx86(*(void**)(R_ESP + 28), &save28); void* save36=NULL; void *arg36 = VulkanFromx86(*(void**)(R_ESP + 36), &save36); void* save44=NULL; void *arg44 = VulkanFromx86(*(void**)(R_ESP + 44), &save44); fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), arg28, *(uint32_t*)(R_ESP + 32), arg36, *(uint32_t*)(R_ESP + 40), arg44); VulkanTox86(arg28, save28); VulkanTox86(arg36, save36); VulkanTox86(arg44, save44); } +void vFpupiiuPuPuP(x86emu_t *emu, uintptr_t fcn) { vFpupiiuPuPuP_t fn = (vFpupiiuPuPuP_t)fcn; void* save28 = NULL; void *arg28 = VulkanFromx86(*(void**)(R_ESP + 28), &save28); void* save36 = NULL; void *arg36 = VulkanFromx86(*(void**)(R_ESP + 36), &save36); void* save44 = NULL; void *arg44 = VulkanFromx86(*(void**)(R_ESP + 44), &save44); fn(*(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(uint32_t*)(R_ESP + 24), arg28, *(uint32_t*)(R_ESP + 32), arg36, *(uint32_t*)(R_ESP + 40), arg44); VulkanTox86(arg28, save28); VulkanTox86(arg36, save36); VulkanTox86(arg44, save44); } void vFppiiiiiiiii(x86emu_t *emu, uintptr_t fcn) { vFppiiiiiiiii_t fn = (vFppiiiiiiiii_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(int32_t*)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(int32_t*)(R_ESP + 40), *(int32_t*)(R_ESP + 44)); } void vFppiiiiipiii(x86emu_t *emu, uintptr_t fcn) { vFppiiiiipiii_t fn = (vFppiiiiipiii_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(int32_t*)(R_ESP + 28), *(void**)(R_ESP + 32), *(int32_t*)(R_ESP + 36), *(int32_t*)(R_ESP + 40), *(int32_t*)(R_ESP + 44)); } void vFppiiiiddddi(x86emu_t *emu, uintptr_t fcn) { vFppiiiiddddi_t fn = (vFppiiiiddddi_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(double*)(R_ESP + 28), *(double*)(R_ESP + 36), *(double*)(R_ESP + 44), *(double*)(R_ESP + 52), *(int32_t*)(R_ESP + 60)); } @@ -4097,6 +4069,7 @@ void iFpppppppppppppppppppppppppppppppppp(x86emu_t *emu, uintptr_t fcn) { iFpppp #if defined(NOALIGN) void IFpi(x86emu_t *emu, uintptr_t fcn) { IFpi_t fn = (IFpi_t)fcn; ui64_t r; r.i=fn(*(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); R_EAX=r.d[0]; R_EDX=r.d[1]; } +void iFipV(x86emu_t *emu, uintptr_t fcn) { iFipV_t fn = (iFipV_t)fcn; R_EAX=fn(*(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), (void*)(R_ESP + 12)); } void iFppiiiip(x86emu_t *emu, uintptr_t fcn) { iFppiiiip_t fn = (iFppiiiip_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16), *(int32_t*)(R_ESP + 20), *(int32_t*)(R_ESP + 24), *(void**)(R_ESP + 28)); } #endif @@ -4108,6 +4081,7 @@ void iFEpI(x86emu_t *emu, uintptr_t fcn) { iFEpI_t fn = (iFEpI_t)fcn; R_EAX=fn(e void iFEpd(x86emu_t *emu, uintptr_t fcn) { iFEpd_t fn = (iFEpd_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(double*)(R_ESP + 8)); } void IFEpi(x86emu_t *emu, uintptr_t fcn) { IFEpi_t fn = (IFEpi_t)fcn; ui64_t r; r.i=fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); R_EAX=r.d[0]; R_EDX=r.d[1]; } void dFEpi(x86emu_t *emu, uintptr_t fcn) { dFEpi_t fn = (dFEpi_t)fcn; double db=fn(emu, *(void**)(R_ESP + 4), *(int32_t*)(R_ESP + 8)); fpu_do_push(emu); ST0val = db; } +void iFEipV(x86emu_t *emu, uintptr_t fcn) { iFEipV_t fn = (iFEipV_t)fcn; R_EAX=fn(emu, *(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), (void*)(R_ESP + 12)); } void iFEiiip(x86emu_t *emu, uintptr_t fcn) { iFEiiip_t fn = (iFEiiip_t)fcn; R_EAX=fn(emu, *(int32_t*)(R_ESP + 4), *(int32_t*)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16)); } void iFEipii(x86emu_t *emu, uintptr_t fcn) { iFEipii_t fn = (iFEipii_t)fcn; R_EAX=fn(emu, *(int32_t*)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } void iFEpppi(x86emu_t *emu, uintptr_t fcn) { iFEpppi_t fn = (iFEpppi_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(int32_t*)(R_ESP + 16)); } @@ -4146,16 +4120,15 @@ void iFKipppL(x86emu_t *emu, uintptr_t fcn) { iFKipppL_t fn = (iFKipppL_t)fcn; R void vFppippKKC(x86emu_t *emu, uintptr_t fcn) { vFppippKKC_t fn = (vFppippKKC_t)fcn; fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 8), *(int32_t*)(R_ESP + 12), *(void**)(R_ESP + 16), *(void**)(R_ESP + 20), FromLD((void*)(R_ESP + 24)), FromLD((void*)(R_ESP + 36)), *(uint8_t*)(R_ESP + 48)); } #endif -void vFEv(x86emu_t *emu, uintptr_t fcn) { vFE_t fn = (vFE_t)fcn; fn(emu); } -void iFEv(x86emu_t *emu, uintptr_t fcn) { iFE_t fn = (iFE_t)fcn; R_EAX=fn(emu); } -void uFEv(x86emu_t *emu, uintptr_t fcn) { uFE_t fn = (uFE_t)fcn; R_EAX=(uint32_t)fn(emu); } -void pFEv(x86emu_t *emu, uintptr_t fcn) { pFE_t fn = (pFE_t)fcn; R_EAX=(uintptr_t)fn(emu); } void iFEvpp(x86emu_t *emu, uintptr_t fcn) { iFEpp_t fn = (iFEpp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 8), *(void**)(R_ESP + 12)); } -void UFVvvV(x86emu_t *emu, uintptr_t fcn) { UFVV_t fn = (UFVV_t)fcn; ui64_t r; r.u=(uint64_t)fn((void*)(R_ESP + 4), (void*)(R_ESP + 12)); R_EAX=r.d[0]; R_EDX=r.d[1]; } -void iFEvppp(x86emu_t *emu, uintptr_t fcn) { iFEppp_t fn = (iFEppp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 8), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); } -void iFEvpVV(x86emu_t *emu, uintptr_t fcn) { iFEpVV_t fn = (iFEpVV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 8), (void*)(R_ESP + 12), (void*)(R_ESP + 12)); } +void iFEvpV(x86emu_t *emu, uintptr_t fcn) { iFEpV_t fn = (iFEpV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 8), (void*)(R_ESP + 12)); } +void UFsvvs(x86emu_t *emu, uintptr_t fcn) { UFss_t fn = (UFss_t)fcn; ui64_t r; r.u=(uint64_t)fn((void*)(R_ESP + 4), (void*)(R_ESP + 12)); R_EAX=r.d[0]; R_EDX=r.d[1]; } void iFEpvpp(x86emu_t *emu, uintptr_t fcn) { iFEppp_t fn = (iFEppp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 12), *(void**)(R_ESP + 16)); } -void iFEpvpVV(x86emu_t *emu, uintptr_t fcn) { iFEppVV_t fn = (iFEppVV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 12), (void*)(R_ESP + 16), (void*)(R_ESP + 16)); } -void iFEpvvpVV(x86emu_t *emu, uintptr_t fcn) { iFEppVV_t fn = (iFEppVV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 16), (void*)(R_ESP + 20), (void*)(R_ESP + 20)); } -void pFpVvvvvV(x86emu_t *emu, uintptr_t fcn) { pFpVV_t fn = (pFpVV_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), (void*)(R_ESP + 8), (void*)(R_ESP + 24)); } +void iFEpvpV(x86emu_t *emu, uintptr_t fcn) { iFEppV_t fn = (iFEppV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 12), (void*)(R_ESP + 16)); } +void iFEpvvpV(x86emu_t *emu, uintptr_t fcn) { iFEppV_t fn = (iFEppV_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(void**)(R_ESP + 16), (void*)(R_ESP + 20)); } +void pFpsvvvvs(x86emu_t *emu, uintptr_t fcn) { pFpss_t fn = (pFpss_t)fcn; R_EAX=(uintptr_t)fn(*(void**)(R_ESP + 4), (void*)(R_ESP + 8), (void*)(R_ESP + 24)); } void iFEpuvvppp(x86emu_t *emu, uintptr_t fcn) { iFEpuppp_t fn = (iFEpuppp_t)fcn; R_EAX=fn(emu, *(void**)(R_ESP + 4), *(uint32_t*)(R_ESP + 8), *(void**)(R_ESP + 20), *(void**)(R_ESP + 24), *(void**)(R_ESP + 28)); } + +#if defined(NOALIGN) +void iFpvpV(x86emu_t *emu, uintptr_t fcn) { iFppV_t fn = (iFppV_t)fcn; R_EAX=fn(*(void**)(R_ESP + 4), *(void**)(R_ESP + 12), (void*)(R_ESP + 16)); } +#endif diff --git a/src/wrapped/generated/wrapper.h b/src/wrapped/generated/wrapper.h index aa5aa0c2f1..a27651c1b8 100644 --- a/src/wrapped/generated/wrapper.h +++ b/src/wrapped/generated/wrapper.h @@ -1,6 +1,6 @@ -/***************************************************************** - * File automatically generated by rebuild_wrappers.py (v1.2.0.09) - *****************************************************************/ +/******************************************************************* + * File automatically generated by rebuild_wrappers.py (v2.0.0.10) * + *******************************************************************/ #ifndef __WRAPPER_H_ #define __WRAPPER_H_ #include @@ -11,26 +11,25 @@ typedef struct x86emu_s x86emu_t; // the generic wrapper pointer functions typedef void (*wrapper_t)(x86emu_t* emu, uintptr_t fnc); -// list of defined wrapper -// v = void, i = int32, u = uint32, U/I= (u)int64 -// l = signed long, L = unsigned long (long is an int with the size of a pointer) -// p = pointer, P = callback -// f = float, d = double, D = long double, K = fake long double -// V = vaargs, E = current x86emu struct, e = ref to current x86emu struct -// 0 = constant 0, 1 = constant 1 -// o = stdout +// list of defined wrappers +// E = current x86emu struct +// v = void // C = unsigned byte c = char // W = unsigned short w = short +// u = uint32, i = int32 +// U = uint64, I = int64 +// L = unsigned long, l = signed long (long is an int with the size of a pointer) +// p = pointer +// f = float, d = double, D = long double, K = fake long double +// V = vaargs, s = address on the stack (doesn't move forward the pointer) // O = libc O_ flags bitfield +// o = stdout // S = _IO_2_1_stdXXX_ pointer (or FILE*) -// Q = ... // 2 = struct of 2 uint -// P = Vulkan struture pointer -// G = a single GValue pointer // N = ... automatically sending 1 arg // M = ... automatically sending 2 args +// P = Vulkan struct pointer, G = a single GValue pointer -void vFE(x86emu_t *emu, uintptr_t fnc); void vFv(x86emu_t *emu, uintptr_t fnc); void vFi(x86emu_t *emu, uintptr_t fnc); void vFu(x86emu_t *emu, uintptr_t fnc); @@ -49,7 +48,6 @@ void cFf(x86emu_t *emu, uintptr_t fnc); void cFp(x86emu_t *emu, uintptr_t fnc); void cFG(x86emu_t *emu, uintptr_t fnc); void wFp(x86emu_t *emu, uintptr_t fnc); -void iFE(x86emu_t *emu, uintptr_t fnc); void iFv(x86emu_t *emu, uintptr_t fnc); void iFw(x86emu_t *emu, uintptr_t fnc); void iFi(x86emu_t *emu, uintptr_t fnc); @@ -75,7 +73,6 @@ void CFp(x86emu_t *emu, uintptr_t fnc); void CFG(x86emu_t *emu, uintptr_t fnc); void WFi(x86emu_t *emu, uintptr_t fnc); void WFp(x86emu_t *emu, uintptr_t fnc); -void uFE(x86emu_t *emu, uintptr_t fnc); void uFv(x86emu_t *emu, uintptr_t fnc); void uFi(x86emu_t *emu, uintptr_t fnc); void uFu(x86emu_t *emu, uintptr_t fnc); @@ -87,8 +84,8 @@ void uFG(x86emu_t *emu, uintptr_t fnc); void UFv(x86emu_t *emu, uintptr_t fnc); void UFu(x86emu_t *emu, uintptr_t fnc); void UFp(x86emu_t *emu, uintptr_t fnc); -void UFV(x86emu_t *emu, uintptr_t fnc); void UFG(x86emu_t *emu, uintptr_t fnc); +void UFs(x86emu_t *emu, uintptr_t fnc); void fFi(x86emu_t *emu, uintptr_t fnc); void fFf(x86emu_t *emu, uintptr_t fnc); void fFp(x86emu_t *emu, uintptr_t fnc); @@ -106,9 +103,9 @@ void lFp(x86emu_t *emu, uintptr_t fnc); void lFG(x86emu_t *emu, uintptr_t fnc); void LFv(x86emu_t *emu, uintptr_t fnc); void LFu(x86emu_t *emu, uintptr_t fnc); +void LFL(x86emu_t *emu, uintptr_t fnc); void LFp(x86emu_t *emu, uintptr_t fnc); void LFG(x86emu_t *emu, uintptr_t fnc); -void pFE(x86emu_t *emu, uintptr_t fnc); void pFv(x86emu_t *emu, uintptr_t fnc); void pFw(x86emu_t *emu, uintptr_t fnc); void pFi(x86emu_t *emu, uintptr_t fnc); @@ -123,6 +120,7 @@ void pFL(x86emu_t *emu, uintptr_t fnc); void pFp(x86emu_t *emu, uintptr_t fnc); void pFV(x86emu_t *emu, uintptr_t fnc); void pFG(x86emu_t *emu, uintptr_t fnc); +void vFEv(x86emu_t *emu, uintptr_t fnc); void vFEp(x86emu_t *emu, uintptr_t fnc); void vFii(x86emu_t *emu, uintptr_t fnc); void vFiI(x86emu_t *emu, uintptr_t fnc); @@ -175,9 +173,9 @@ void vFGL(x86emu_t *emu, uintptr_t fnc); void vFGp(x86emu_t *emu, uintptr_t fnc); void vFGG(x86emu_t *emu, uintptr_t fnc); void cFpp(x86emu_t *emu, uintptr_t fnc); +void iFEv(x86emu_t *emu, uintptr_t fnc); void iFEL(x86emu_t *emu, uintptr_t fnc); void iFEp(x86emu_t *emu, uintptr_t fnc); -void iFEV(x86emu_t *emu, uintptr_t fnc); void iFwp(x86emu_t *emu, uintptr_t fnc); void iFii(x86emu_t *emu, uintptr_t fnc); void iFiI(x86emu_t *emu, uintptr_t fnc); @@ -189,8 +187,6 @@ void iFui(x86emu_t *emu, uintptr_t fnc); void iFuu(x86emu_t *emu, uintptr_t fnc); void iFup(x86emu_t *emu, uintptr_t fnc); void iFli(x86emu_t *emu, uintptr_t fnc); -void iFLi(x86emu_t *emu, uintptr_t fnc); -void iFLp(x86emu_t *emu, uintptr_t fnc); void iFpw(x86emu_t *emu, uintptr_t fnc); void iFpi(x86emu_t *emu, uintptr_t fnc); void iFpI(x86emu_t *emu, uintptr_t fnc); @@ -203,6 +199,7 @@ void iFpd(x86emu_t *emu, uintptr_t fnc); void iFpl(x86emu_t *emu, uintptr_t fnc); void iFpL(x86emu_t *emu, uintptr_t fnc); void iFpp(x86emu_t *emu, uintptr_t fnc); +void iFpV(x86emu_t *emu, uintptr_t fnc); void iFpO(x86emu_t *emu, uintptr_t fnc); void iFpP(x86emu_t *emu, uintptr_t fnc); void iFpG(x86emu_t *emu, uintptr_t fnc); @@ -217,8 +214,10 @@ void CFui(x86emu_t *emu, uintptr_t fnc); void CFpi(x86emu_t *emu, uintptr_t fnc); void CFpu(x86emu_t *emu, uintptr_t fnc); void CFpp(x86emu_t *emu, uintptr_t fnc); +void uFEv(x86emu_t *emu, uintptr_t fnc); void uFEu(x86emu_t *emu, uintptr_t fnc); void uFEp(x86emu_t *emu, uintptr_t fnc); +void uFii(x86emu_t *emu, uintptr_t fnc); void uFiu(x86emu_t *emu, uintptr_t fnc); void uFui(x86emu_t *emu, uintptr_t fnc); void uFuu(x86emu_t *emu, uintptr_t fnc); @@ -235,7 +234,7 @@ void UFuu(x86emu_t *emu, uintptr_t fnc); void UFUU(x86emu_t *emu, uintptr_t fnc); void UFUp(x86emu_t *emu, uintptr_t fnc); void UFpp(x86emu_t *emu, uintptr_t fnc); -void UFVV(x86emu_t *emu, uintptr_t fnc); +void UFss(x86emu_t *emu, uintptr_t fnc); void fFEp(x86emu_t *emu, uintptr_t fnc); void fFif(x86emu_t *emu, uintptr_t fnc); void fFfi(x86emu_t *emu, uintptr_t fnc); @@ -258,15 +257,13 @@ void lFpi(x86emu_t *emu, uintptr_t fnc); void lFpp(x86emu_t *emu, uintptr_t fnc); void LFii(x86emu_t *emu, uintptr_t fnc); void LFLi(x86emu_t *emu, uintptr_t fnc); -void LFLp(x86emu_t *emu, uintptr_t fnc); void LFpL(x86emu_t *emu, uintptr_t fnc); void LFpp(x86emu_t *emu, uintptr_t fnc); +void pFEv(x86emu_t *emu, uintptr_t fnc); void pFEi(x86emu_t *emu, uintptr_t fnc); void pFEp(x86emu_t *emu, uintptr_t fnc); -void pFEV(x86emu_t *emu, uintptr_t fnc); void pFii(x86emu_t *emu, uintptr_t fnc); void pFiu(x86emu_t *emu, uintptr_t fnc); -void pFiL(x86emu_t *emu, uintptr_t fnc); void pFip(x86emu_t *emu, uintptr_t fnc); void pFiV(x86emu_t *emu, uintptr_t fnc); void pFui(x86emu_t *emu, uintptr_t fnc); @@ -289,6 +286,7 @@ void pFpL(x86emu_t *emu, uintptr_t fnc); void pFpp(x86emu_t *emu, uintptr_t fnc); void pFpV(x86emu_t *emu, uintptr_t fnc); void pFpG(x86emu_t *emu, uintptr_t fnc); +void pFps(x86emu_t *emu, uintptr_t fnc); void pFSi(x86emu_t *emu, uintptr_t fnc); void vFEip(x86emu_t *emu, uintptr_t fnc); void vFEpi(x86emu_t *emu, uintptr_t fnc); @@ -379,7 +377,6 @@ void iFiwC(x86emu_t *emu, uintptr_t fnc); void iFiii(x86emu_t *emu, uintptr_t fnc); void iFiiI(x86emu_t *emu, uintptr_t fnc); void iFiiu(x86emu_t *emu, uintptr_t fnc); -void iFiiL(x86emu_t *emu, uintptr_t fnc); void iFiip(x86emu_t *emu, uintptr_t fnc); void iFiiO(x86emu_t *emu, uintptr_t fnc); void iFiII(x86emu_t *emu, uintptr_t fnc); @@ -391,6 +388,7 @@ void iFipu(x86emu_t *emu, uintptr_t fnc); void iFipL(x86emu_t *emu, uintptr_t fnc); void iFipp(x86emu_t *emu, uintptr_t fnc); void iFCiW(x86emu_t *emu, uintptr_t fnc); +void iFuwp(x86emu_t *emu, uintptr_t fnc); void iFuii(x86emu_t *emu, uintptr_t fnc); void iFuip(x86emu_t *emu, uintptr_t fnc); void iFuui(x86emu_t *emu, uintptr_t fnc); @@ -400,7 +398,6 @@ void iFuff(x86emu_t *emu, uintptr_t fnc); void iFuLp(x86emu_t *emu, uintptr_t fnc); void iFupp(x86emu_t *emu, uintptr_t fnc); void iFfff(x86emu_t *emu, uintptr_t fnc); -void iFLwp(x86emu_t *emu, uintptr_t fnc); void iFpwp(x86emu_t *emu, uintptr_t fnc); void iFpii(x86emu_t *emu, uintptr_t fnc); void iFpiu(x86emu_t *emu, uintptr_t fnc); @@ -428,7 +425,6 @@ void iFpli(x86emu_t *emu, uintptr_t fnc); void iFpll(x86emu_t *emu, uintptr_t fnc); void iFplp(x86emu_t *emu, uintptr_t fnc); void iFpLi(x86emu_t *emu, uintptr_t fnc); -void iFpLL(x86emu_t *emu, uintptr_t fnc); void iFpLp(x86emu_t *emu, uintptr_t fnc); void iFppi(x86emu_t *emu, uintptr_t fnc); void iFppI(x86emu_t *emu, uintptr_t fnc); @@ -458,8 +454,6 @@ void uFEpU(x86emu_t *emu, uintptr_t fnc); void uFEpp(x86emu_t *emu, uintptr_t fnc); void uFipu(x86emu_t *emu, uintptr_t fnc); void uFuip(x86emu_t *emu, uintptr_t fnc); -void uFuui(x86emu_t *emu, uintptr_t fnc); -void uFuuI(x86emu_t *emu, uintptr_t fnc); void uFuuu(x86emu_t *emu, uintptr_t fnc); void uFuup(x86emu_t *emu, uintptr_t fnc); void uFupi(x86emu_t *emu, uintptr_t fnc); @@ -477,7 +471,6 @@ void uFppu(x86emu_t *emu, uintptr_t fnc); void uFppp(x86emu_t *emu, uintptr_t fnc); void UFppi(x86emu_t *emu, uintptr_t fnc); void UFppu(x86emu_t *emu, uintptr_t fnc); -void fFuii(x86emu_t *emu, uintptr_t fnc); void fFull(x86emu_t *emu, uintptr_t fnc); void fFfff(x86emu_t *emu, uintptr_t fnc); void fFffp(x86emu_t *emu, uintptr_t fnc); @@ -493,12 +486,15 @@ void lFipi(x86emu_t *emu, uintptr_t fnc); void lFipL(x86emu_t *emu, uintptr_t fnc); void lFlll(x86emu_t *emu, uintptr_t fnc); void lFlpi(x86emu_t *emu, uintptr_t fnc); +void lFpli(x86emu_t *emu, uintptr_t fnc); void lFpLp(x86emu_t *emu, uintptr_t fnc); void lFppi(x86emu_t *emu, uintptr_t fnc); void lFppL(x86emu_t *emu, uintptr_t fnc); void lFSpl(x86emu_t *emu, uintptr_t fnc); void LFiii(x86emu_t *emu, uintptr_t fnc); -void LFpii(x86emu_t *emu, uintptr_t fnc); +void LFLLl(x86emu_t *emu, uintptr_t fnc); +void LFLpu(x86emu_t *emu, uintptr_t fnc); +void LFLpL(x86emu_t *emu, uintptr_t fnc); void LFpip(x86emu_t *emu, uintptr_t fnc); void LFpLi(x86emu_t *emu, uintptr_t fnc); void LFpLp(x86emu_t *emu, uintptr_t fnc); @@ -559,8 +555,8 @@ void pFppf(x86emu_t *emu, uintptr_t fnc); void pFppl(x86emu_t *emu, uintptr_t fnc); void pFppL(x86emu_t *emu, uintptr_t fnc); void pFppp(x86emu_t *emu, uintptr_t fnc); -void pFpVV(x86emu_t *emu, uintptr_t fnc); void pFpOM(x86emu_t *emu, uintptr_t fnc); +void pFpss(x86emu_t *emu, uintptr_t fnc); void pFSpl(x86emu_t *emu, uintptr_t fnc); void pFSpp(x86emu_t *emu, uintptr_t fnc); void vFEiip(x86emu_t *emu, uintptr_t fnc); @@ -710,7 +706,6 @@ void iFEppu(x86emu_t *emu, uintptr_t fnc); void iFEppL(x86emu_t *emu, uintptr_t fnc); void iFEppp(x86emu_t *emu, uintptr_t fnc); void iFEppV(x86emu_t *emu, uintptr_t fnc); -void iFEpVV(x86emu_t *emu, uintptr_t fnc); void iFEpOu(x86emu_t *emu, uintptr_t fnc); void iFEpOV(x86emu_t *emu, uintptr_t fnc); void iFEPpp(x86emu_t *emu, uintptr_t fnc); @@ -720,13 +715,13 @@ void iFiiii(x86emu_t *emu, uintptr_t fnc); void iFiiiu(x86emu_t *emu, uintptr_t fnc); void iFiiip(x86emu_t *emu, uintptr_t fnc); void iFiiII(x86emu_t *emu, uintptr_t fnc); -void iFiiLi(x86emu_t *emu, uintptr_t fnc); +void iFiiui(x86emu_t *emu, uintptr_t fnc); void iFiipi(x86emu_t *emu, uintptr_t fnc); void iFiipp(x86emu_t *emu, uintptr_t fnc); +void iFiuwp(x86emu_t *emu, uintptr_t fnc); void iFiuii(x86emu_t *emu, uintptr_t fnc); void iFiuui(x86emu_t *emu, uintptr_t fnc); void iFiupp(x86emu_t *emu, uintptr_t fnc); -void iFiLwp(x86emu_t *emu, uintptr_t fnc); void iFipii(x86emu_t *emu, uintptr_t fnc); void iFipip(x86emu_t *emu, uintptr_t fnc); void iFipui(x86emu_t *emu, uintptr_t fnc); @@ -743,10 +738,11 @@ void iFuuff(x86emu_t *emu, uintptr_t fnc); void iFupup(x86emu_t *emu, uintptr_t fnc); void iFuppi(x86emu_t *emu, uintptr_t fnc); void iFuppp(x86emu_t *emu, uintptr_t fnc); +void iFpwww(x86emu_t *emu, uintptr_t fnc); +void iFpwpp(x86emu_t *emu, uintptr_t fnc); void iFpiii(x86emu_t *emu, uintptr_t fnc); void iFpiiu(x86emu_t *emu, uintptr_t fnc); void iFpiid(x86emu_t *emu, uintptr_t fnc); -void iFpiiL(x86emu_t *emu, uintptr_t fnc); void iFpiip(x86emu_t *emu, uintptr_t fnc); void iFpiuu(x86emu_t *emu, uintptr_t fnc); void iFpiuL(x86emu_t *emu, uintptr_t fnc); @@ -760,6 +756,7 @@ void iFpIip(x86emu_t *emu, uintptr_t fnc); void iFpCCC(x86emu_t *emu, uintptr_t fnc); void iFpCpi(x86emu_t *emu, uintptr_t fnc); void iFpWWu(x86emu_t *emu, uintptr_t fnc); +void iFpuwp(x86emu_t *emu, uintptr_t fnc); void iFpuii(x86emu_t *emu, uintptr_t fnc); void iFpuiu(x86emu_t *emu, uintptr_t fnc); void iFpuiL(x86emu_t *emu, uintptr_t fnc); @@ -780,7 +777,6 @@ void iFpUUU(x86emu_t *emu, uintptr_t fnc); void iFpUpp(x86emu_t *emu, uintptr_t fnc); void iFplii(x86emu_t *emu, uintptr_t fnc); void iFplip(x86emu_t *emu, uintptr_t fnc); -void iFpLwp(x86emu_t *emu, uintptr_t fnc); void iFpLpi(x86emu_t *emu, uintptr_t fnc); void iFpLpL(x86emu_t *emu, uintptr_t fnc); void iFppii(x86emu_t *emu, uintptr_t fnc); @@ -877,6 +873,7 @@ void pFipip(x86emu_t *emu, uintptr_t fnc); void pFippi(x86emu_t *emu, uintptr_t fnc); void pFippu(x86emu_t *emu, uintptr_t fnc); void pFuiii(x86emu_t *emu, uintptr_t fnc); +void pFuuuu(x86emu_t *emu, uintptr_t fnc); void pFulli(x86emu_t *emu, uintptr_t fnc); void pFullu(x86emu_t *emu, uintptr_t fnc); void pFffff(x86emu_t *emu, uintptr_t fnc); @@ -944,7 +941,6 @@ void vFiplll(x86emu_t *emu, uintptr_t fnc); void vFuiiii(x86emu_t *emu, uintptr_t fnc); void vFuiiiu(x86emu_t *emu, uintptr_t fnc); void vFuiiip(x86emu_t *emu, uintptr_t fnc); -void vFuiiup(x86emu_t *emu, uintptr_t fnc); void vFuiifi(x86emu_t *emu, uintptr_t fnc); void vFuiIII(x86emu_t *emu, uintptr_t fnc); void vFuiuii(x86emu_t *emu, uintptr_t fnc); @@ -1036,11 +1032,12 @@ void iFEiipV(x86emu_t *emu, uintptr_t fnc); void iFEipuu(x86emu_t *emu, uintptr_t fnc); void iFEippi(x86emu_t *emu, uintptr_t fnc); void iFEippp(x86emu_t *emu, uintptr_t fnc); -void iFEipVV(x86emu_t *emu, uintptr_t fnc); +void iFEuuuu(x86emu_t *emu, uintptr_t fnc); void iFEpiii(x86emu_t *emu, uintptr_t fnc); void iFEpiup(x86emu_t *emu, uintptr_t fnc); void iFEpipi(x86emu_t *emu, uintptr_t fnc); void iFEpipp(x86emu_t *emu, uintptr_t fnc); +void iFEpipV(x86emu_t *emu, uintptr_t fnc); void iFEpupV(x86emu_t *emu, uintptr_t fnc); void iFEpUup(x86emu_t *emu, uintptr_t fnc); void iFEpLpp(x86emu_t *emu, uintptr_t fnc); @@ -1051,7 +1048,6 @@ void iFEppiV(x86emu_t *emu, uintptr_t fnc); void iFEpplp(x86emu_t *emu, uintptr_t fnc); void iFEpppp(x86emu_t *emu, uintptr_t fnc); void iFEpppV(x86emu_t *emu, uintptr_t fnc); -void iFEppVV(x86emu_t *emu, uintptr_t fnc); void iFEpPpp(x86emu_t *emu, uintptr_t fnc); void iFiiipu(x86emu_t *emu, uintptr_t fnc); void iFiiipp(x86emu_t *emu, uintptr_t fnc); @@ -1068,16 +1064,18 @@ void iFippup(x86emu_t *emu, uintptr_t fnc); void iFipppi(x86emu_t *emu, uintptr_t fnc); void iFipppp(x86emu_t *emu, uintptr_t fnc); void iFuppup(x86emu_t *emu, uintptr_t fnc); +void iFpwwww(x86emu_t *emu, uintptr_t fnc); +void iFpwppp(x86emu_t *emu, uintptr_t fnc); void iFpiiii(x86emu_t *emu, uintptr_t fnc); void iFpiiiu(x86emu_t *emu, uintptr_t fnc); void iFpiiiL(x86emu_t *emu, uintptr_t fnc); void iFpiiip(x86emu_t *emu, uintptr_t fnc); +void iFpiiui(x86emu_t *emu, uintptr_t fnc); void iFpiiuu(x86emu_t *emu, uintptr_t fnc); -void iFpiiLi(x86emu_t *emu, uintptr_t fnc); void iFpiipi(x86emu_t *emu, uintptr_t fnc); void iFpiipp(x86emu_t *emu, uintptr_t fnc); +void iFpiuwp(x86emu_t *emu, uintptr_t fnc); void iFpiupu(x86emu_t *emu, uintptr_t fnc); -void iFpiLwp(x86emu_t *emu, uintptr_t fnc); void iFpipii(x86emu_t *emu, uintptr_t fnc); void iFpipiL(x86emu_t *emu, uintptr_t fnc); void iFpipip(x86emu_t *emu, uintptr_t fnc); @@ -1106,12 +1104,12 @@ void iFppiip(x86emu_t *emu, uintptr_t fnc); void iFppiup(x86emu_t *emu, uintptr_t fnc); void iFppipi(x86emu_t *emu, uintptr_t fnc); void iFppipp(x86emu_t *emu, uintptr_t fnc); +void iFppuwp(x86emu_t *emu, uintptr_t fnc); void iFppuip(x86emu_t *emu, uintptr_t fnc); void iFppupi(x86emu_t *emu, uintptr_t fnc); void iFppupp(x86emu_t *emu, uintptr_t fnc); void iFppllp(x86emu_t *emu, uintptr_t fnc); void iFpplpp(x86emu_t *emu, uintptr_t fnc); -void iFppLwp(x86emu_t *emu, uintptr_t fnc); void iFppLip(x86emu_t *emu, uintptr_t fnc); void iFppLpi(x86emu_t *emu, uintptr_t fnc); void iFppLpL(x86emu_t *emu, uintptr_t fnc); @@ -1122,6 +1120,7 @@ void iFpppip(x86emu_t *emu, uintptr_t fnc); void iFpppui(x86emu_t *emu, uintptr_t fnc); void iFpppuu(x86emu_t *emu, uintptr_t fnc); void iFpppup(x86emu_t *emu, uintptr_t fnc); +void iFpppLi(x86emu_t *emu, uintptr_t fnc); void iFppppi(x86emu_t *emu, uintptr_t fnc); void iFppppu(x86emu_t *emu, uintptr_t fnc); void iFppppL(x86emu_t *emu, uintptr_t fnc); @@ -1244,7 +1243,6 @@ void vFuiupiu(x86emu_t *emu, uintptr_t fnc); void vFuiUUUU(x86emu_t *emu, uintptr_t fnc); void vFuiffff(x86emu_t *emu, uintptr_t fnc); void vFuidddd(x86emu_t *emu, uintptr_t fnc); -void vFuipiup(x86emu_t *emu, uintptr_t fnc); void vFuuiiii(x86emu_t *emu, uintptr_t fnc); void vFuuiiiu(x86emu_t *emu, uintptr_t fnc); void vFuuiuii(x86emu_t *emu, uintptr_t fnc); @@ -1329,17 +1327,14 @@ void iFEpiipV(x86emu_t *emu, uintptr_t fnc); void iFEpiLpp(x86emu_t *emu, uintptr_t fnc); void iFEpippi(x86emu_t *emu, uintptr_t fnc); void iFEpippp(x86emu_t *emu, uintptr_t fnc); -void iFEpipVV(x86emu_t *emu, uintptr_t fnc); void iFEpuuip(x86emu_t *emu, uintptr_t fnc); void iFEpuppp(x86emu_t *emu, uintptr_t fnc); -void iFEpupVV(x86emu_t *emu, uintptr_t fnc); void iFEpUPpp(x86emu_t *emu, uintptr_t fnc); void iFEpLppp(x86emu_t *emu, uintptr_t fnc); -void iFEpLpVV(x86emu_t *emu, uintptr_t fnc); void iFEppppp(x86emu_t *emu, uintptr_t fnc); void iFiiiiii(x86emu_t *emu, uintptr_t fnc); void iFiiiiip(x86emu_t *emu, uintptr_t fnc); -void iFiiiLwp(x86emu_t *emu, uintptr_t fnc); +void iFiiiuwp(x86emu_t *emu, uintptr_t fnc); void iFiuiipi(x86emu_t *emu, uintptr_t fnc); void iFipipuu(x86emu_t *emu, uintptr_t fnc); void iFipuufp(x86emu_t *emu, uintptr_t fnc); @@ -1457,10 +1452,8 @@ void vFEpuipuV(x86emu_t *emu, uintptr_t fnc); void vFEpppppp(x86emu_t *emu, uintptr_t fnc); void vFiiiiiip(x86emu_t *emu, uintptr_t fnc); void vFiiiiuup(x86emu_t *emu, uintptr_t fnc); -void vFiiupuip(x86emu_t *emu, uintptr_t fnc); void vFiiffffp(x86emu_t *emu, uintptr_t fnc); void vFiipllli(x86emu_t *emu, uintptr_t fnc); -void vFiupuuup(x86emu_t *emu, uintptr_t fnc); void vFuiiiiii(x86emu_t *emu, uintptr_t fnc); void vFuiiiuip(x86emu_t *emu, uintptr_t fnc); void vFuiiiuup(x86emu_t *emu, uintptr_t fnc); @@ -1536,6 +1529,7 @@ void vFppppppp(x86emu_t *emu, uintptr_t fnc); void iFEpuiupV(x86emu_t *emu, uintptr_t fnc); void iFEpupppp(x86emu_t *emu, uintptr_t fnc); void iFEpUuppp(x86emu_t *emu, uintptr_t fnc); +void iFEpLiipV(x86emu_t *emu, uintptr_t fnc); void iFEppiuui(x86emu_t *emu, uintptr_t fnc); void iFEppupIi(x86emu_t *emu, uintptr_t fnc); void iFEppuppp(x86emu_t *emu, uintptr_t fnc); @@ -1545,7 +1539,7 @@ void iFEpppppp(x86emu_t *emu, uintptr_t fnc); void iFiiiiiip(x86emu_t *emu, uintptr_t fnc); void iFpiiiiii(x86emu_t *emu, uintptr_t fnc); void iFpiiiiip(x86emu_t *emu, uintptr_t fnc); -void iFpiiiLwp(x86emu_t *emu, uintptr_t fnc); +void iFpiiiuwp(x86emu_t *emu, uintptr_t fnc); void iFpiiuuiu(x86emu_t *emu, uintptr_t fnc); void iFpiiuuuu(x86emu_t *emu, uintptr_t fnc); void iFpiipppp(x86emu_t *emu, uintptr_t fnc); @@ -1643,13 +1637,10 @@ void vFEppipppp(x86emu_t *emu, uintptr_t fnc); void vFEpppuipV(x86emu_t *emu, uintptr_t fnc); void vFEpppppuu(x86emu_t *emu, uintptr_t fnc); void vFiiiiuuip(x86emu_t *emu, uintptr_t fnc); -void vFiupuiuup(x86emu_t *emu, uintptr_t fnc); -void vFiupuuuup(x86emu_t *emu, uintptr_t fnc); void vFilipufip(x86emu_t *emu, uintptr_t fnc); void vFuiiiiiii(x86emu_t *emu, uintptr_t fnc); void vFuiiiiill(x86emu_t *emu, uintptr_t fnc); void vFuiiiiuup(x86emu_t *emu, uintptr_t fnc); -void vFuiiipiup(x86emu_t *emu, uintptr_t fnc); void vFuiuiiiii(x86emu_t *emu, uintptr_t fnc); void vFuiuiiiip(x86emu_t *emu, uintptr_t fnc); void vFuiulplpp(x86emu_t *emu, uintptr_t fnc); @@ -1690,15 +1681,12 @@ void iFEpippppp(x86emu_t *emu, uintptr_t fnc); void iFEpuuiipp(x86emu_t *emu, uintptr_t fnc); void iFEpuuuipp(x86emu_t *emu, uintptr_t fnc); void iFEpuuLppp(x86emu_t *emu, uintptr_t fnc); -void iFEpLiipVV(x86emu_t *emu, uintptr_t fnc); void iFEppppipp(x86emu_t *emu, uintptr_t fnc); void iFiiiiiiip(x86emu_t *emu, uintptr_t fnc); void iFiiupiupi(x86emu_t *emu, uintptr_t fnc); -void iFuiifpppp(x86emu_t *emu, uintptr_t fnc); void iFuipuuluf(x86emu_t *emu, uintptr_t fnc); +void iFuuuuuuuu(x86emu_t *emu, uintptr_t fnc); void iFullfpppp(x86emu_t *emu, uintptr_t fnc); -void iFLLLLLLLL(x86emu_t *emu, uintptr_t fnc); -void iFpiiiiipi(x86emu_t *emu, uintptr_t fnc); void iFpCCWWpWu(x86emu_t *emu, uintptr_t fnc); void iFpWCuWCuu(x86emu_t *emu, uintptr_t fnc); void iFpuiipppp(x86emu_t *emu, uintptr_t fnc); @@ -1760,14 +1748,12 @@ void vFuiiiillli(x86emu_t *emu, uintptr_t fnc); void vFuiiilliip(x86emu_t *emu, uintptr_t fnc); void vFuiiillilp(x86emu_t *emu, uintptr_t fnc); void vFuiuiiiiip(x86emu_t *emu, uintptr_t fnc); -void vFuiupuffup(x86emu_t *emu, uintptr_t fnc); void vFuuiiiiiii(x86emu_t *emu, uintptr_t fnc); void vFuuiuiiiii(x86emu_t *emu, uintptr_t fnc); void vFuuiuiiiip(x86emu_t *emu, uintptr_t fnc); void vFuuiuiiuup(x86emu_t *emu, uintptr_t fnc); void vFuuuiiiiip(x86emu_t *emu, uintptr_t fnc); void vFuuuuuuuuu(x86emu_t *emu, uintptr_t fnc); -void vFuupiuiuuf(x86emu_t *emu, uintptr_t fnc); void vFuffffffff(x86emu_t *emu, uintptr_t fnc); void vFffuuuufff(x86emu_t *emu, uintptr_t fnc); void vFddddddddd(x86emu_t *emu, uintptr_t fnc); @@ -1799,8 +1785,8 @@ void iFdddpppppp(x86emu_t *emu, uintptr_t fnc); void iFpiuuupipu(x86emu_t *emu, uintptr_t fnc); void iFpipLpiiip(x86emu_t *emu, uintptr_t fnc); void iFpuiuuipip(x86emu_t *emu, uintptr_t fnc); +void iFpuuuuuuuu(x86emu_t *emu, uintptr_t fnc); void iFpupuupWWu(x86emu_t *emu, uintptr_t fnc); -void iFpLLLLLLLL(x86emu_t *emu, uintptr_t fnc); void iFppiiiiiii(x86emu_t *emu, uintptr_t fnc); void iFppiuiippu(x86emu_t *emu, uintptr_t fnc); void iFppipiiipi(x86emu_t *emu, uintptr_t fnc); @@ -1849,7 +1835,6 @@ void vFuuiuiiiiip(x86emu_t *emu, uintptr_t fnc); void vFuuiuiiiuup(x86emu_t *emu, uintptr_t fnc); void vFuuuuuuuiii(x86emu_t *emu, uintptr_t fnc); void vFuuuuuuuuuu(x86emu_t *emu, uintptr_t fnc); -void vFuupiiupuuf(x86emu_t *emu, uintptr_t fnc); void vFuffiiffiip(x86emu_t *emu, uintptr_t fnc); void vFuddiiddiip(x86emu_t *emu, uintptr_t fnc); void vFffffffffff(x86emu_t *emu, uintptr_t fnc); @@ -2019,6 +2004,7 @@ void iFpppppppppppppppppppppppppppppppppp(x86emu_t *emu, uintptr_t fnc); #if defined(NOALIGN) void IFpi(x86emu_t *emu, uintptr_t fnc); +void iFipV(x86emu_t *emu, uintptr_t fnc); void iFppiiiip(x86emu_t *emu, uintptr_t fnc); #endif @@ -2030,6 +2016,7 @@ void iFEpI(x86emu_t *emu, uintptr_t fnc); void iFEpd(x86emu_t *emu, uintptr_t fnc); void IFEpi(x86emu_t *emu, uintptr_t fnc); void dFEpi(x86emu_t *emu, uintptr_t fnc); +void iFEipV(x86emu_t *emu, uintptr_t fnc); void iFEiiip(x86emu_t *emu, uintptr_t fnc); void iFEipii(x86emu_t *emu, uintptr_t fnc); void iFEpppi(x86emu_t *emu, uintptr_t fnc); @@ -2068,18 +2055,16 @@ void iFKipppL(x86emu_t *emu, uintptr_t fnc); void vFppippKKC(x86emu_t *emu, uintptr_t fnc); #endif -void vFEv(x86emu_t *emu, uintptr_t fnc); -void iFEv(x86emu_t *emu, uintptr_t fnc); -void uFEv(x86emu_t *emu, uintptr_t fnc); -void pFEv(x86emu_t *emu, uintptr_t fnc); void iFEvpp(x86emu_t *emu, uintptr_t fnc); -void UFVvvV(x86emu_t *emu, uintptr_t fnc); -void iFEvppp(x86emu_t *emu, uintptr_t fnc); -void iFEvpVV(x86emu_t *emu, uintptr_t fnc); +void iFEvpV(x86emu_t *emu, uintptr_t fnc); +void UFsvvs(x86emu_t *emu, uintptr_t fnc); void iFEpvpp(x86emu_t *emu, uintptr_t fnc); -void iFEpvpVV(x86emu_t *emu, uintptr_t fnc); -void iFEpvvpVV(x86emu_t *emu, uintptr_t fnc); -void pFpVvvvvV(x86emu_t *emu, uintptr_t fnc); +void iFEpvpV(x86emu_t *emu, uintptr_t fnc); +void iFEpvvpV(x86emu_t *emu, uintptr_t fnc); +void pFpsvvvvs(x86emu_t *emu, uintptr_t fnc); void iFEpuvvppp(x86emu_t *emu, uintptr_t fnc); +#if defined(NOALIGN) +void iFpvpV(x86emu_t *emu, uintptr_t fnc); +#endif #endif // __WRAPPER_H_ diff --git a/src/wrapped/wrappedbz2.c b/src/wrapped/wrappedbz2.c index c9b4fd5f00..69758abcaa 100755 --- a/src/wrapped/wrappedbz2.c +++ b/src/wrapped/wrappedbz2.c @@ -142,9 +142,9 @@ typedef struct { A->bzalloc = find_alloc_Fct(A->bzalloc); \ A->bzfree = find_free_Fct(A->bzfree); -#define UNWRAP_BZ(A) if(A->bzalloc || A->bzfree) \ - A->bzalloc = reverse_alloc_Fct(A->bzalloc); \ - A->bzfree = reverse_free_Fct(A->bzfree); +#define UNWRAP_BZ(A) \ + if(A->bzalloc) A->bzalloc = reverse_alloc_Fct(A->bzalloc); \ + if(A->bzfree) A->bzfree = reverse_free_Fct(A->bzfree); EXPORT int my_BZ2_bzCompressInit(x86emu_t* emu, my_bz_stream_t* strm, int blocksize, int verbosity, int work) { diff --git a/src/wrapped/wrappedcrypto.c b/src/wrapped/wrappedcrypto.c index d0356b2f95..1a348f50b9 100755 --- a/src/wrapped/wrappedcrypto.c +++ b/src/wrapped/wrappedcrypto.c @@ -25,13 +25,6 @@ const char* cryptoName = "libcrypto.so.1.0.0"; static library_t* my_lib = NULL; -typedef void (*vFv_t) (void); - -#define ADDED_FUNCTIONS() \ - GO(OPENSSL_add_all_algorithms_conf, vFv_t) \ - GO(OPENSSL_add_all_algorithms_noconf, vFv_t) \ - GO(OpenSSL_add_all_ciphers, vFv_t) \ - GO(OpenSSL_add_all_digests, vFv_t) #include "generated/wrappedcryptotypes.h" typedef struct crypto_my_s { diff --git a/src/wrapped/wrappedcrypto_private.h b/src/wrapped/wrappedcrypto_private.h index 6930cce260..e8c31d5de2 100755 --- a/src/wrapped/wrappedcrypto_private.h +++ b/src/wrapped/wrappedcrypto_private.h @@ -2596,10 +2596,10 @@ GO(OBJ_txt2obj, pFpi) //GO(OCSP_SINGLERESP_get_ext_count, //GO(OCSP_SINGLERESP_new, //GO(OCSP_url_svcloc_new, -GOM(OPENSSL_add_all_algorithms_conf, vFv) // No emu parameter -GOM(OPENSSL_add_all_algorithms_noconf, vFv) // No emu parameter -GOM(OpenSSL_add_all_ciphers, vFv) // No emu parameter -GOM(OpenSSL_add_all_digests, vFv) // No emu parameter +GOM(OPENSSL_add_all_algorithms_conf, vFv) //%noE +GOM(OPENSSL_add_all_algorithms_noconf, vFv) //%noE +GOM(OpenSSL_add_all_ciphers, vFv) //%noE +GOM(OpenSSL_add_all_digests, vFv) //%noE //GO(OPENSSL_asc2uni, //GO(OPENSSL_atomic_add, //GO(OPENSSL_cleanse, diff --git a/src/wrapped/wrappedd3dadapter9_genvate.h b/src/wrapped/wrappedd3dadapter9_genvate.h new file mode 100644 index 0000000000..51fe5a1b0f --- /dev/null +++ b/src/wrapped/wrappedd3dadapter9_genvate.h @@ -0,0 +1,231 @@ +GO(AddDirtyBox, iFpp) +GO(AddDirtyRect, iFpip) +GO(AddDirtyRect, iFpp) +GO(AddRef, uFp) +GO(Apply, iFp) +GO(BeginScene, iFp) +GO(BeginStateBlock, iFp) +GO(Capture, iFp) +GO(CheckDepthStencilMatch, iFpiiii) +GO(CheckDepthStencilMatch, iFpuiiii) +GO(CheckDeviceFormatConversion, iFpiii) +GO(CheckDeviceFormatConversion, iFpuiii) +GO(CheckDeviceFormat, iFpiiuii) +GO(CheckDeviceFormat, iFpuiiuii) +GO(CheckDeviceMultiSampleType, iFpiiiip) +GO(CheckDeviceMultiSampleType, iFpuiiiip) +GO(CheckDeviceOverlayType, iFpuiuuipip) +GO(CheckDeviceState, iFpp) +GO(CheckDeviceType, iFpiiii) +GO(CheckDeviceType, iFpuiiii) +GO(Clear, iFpupuufu) +GO(ColorFill, iFpppu) +GO(ComposeRects, iFppppupiii) +GO(Configure, iFpupp) +GO(CreateDeviceEx, iFpuipuppp) +GO(CreateDeviceEx, iFpuipuppppp) +GOM(CreateDevice, iFEpuipupppp) // Note that this one is unique (not a real GOM as it is assigned manually) +GO(CreateDevice, iFpuipupp) +GO(DecryptionBlt, iFpppuppp) +GO(DeletePatch, iFpu) +GO(DrawIndexedPrimitive, iFpiiuuuu) +GO(DrawIndexedPrimitiveUP, iFpiuuupipu) +GO(DrawPrimitive, iFpiuu) +GO(DrawPrimitiveUP, iFpiupu) +GO(DrawRectPatch, iFpupp) +GO(DrawTriPatch, iFpupp) +GO(EncryptionBlt, iFpppup) +GO(EndScene, iFp) +GO(EnumAdapterModesEx, iFpupup) +GO(EnumAdapterModes, iFpuiup) +GO(EvictManagedResources, iFp) +GO(FinishSessionKeyRefresh, iFp) +GO(FreePrivateData, iFpp) +GO(GenerateMipSubLevels, vFp) +GO(GetAdapterCount, uFp) +GO(GetAdapterDisplayModeEx, iFpupp) +GO(GetAdapterDisplayMode, iFpup) +GO(GetAdapterIdentifier, iFpup) +GO(GetAdapterIdentifier, iFpuup) +GO(GetAdapterLUID, iFpup) +GO(GetAdapterModeCountEx, uFpup) +GO(GetAdapterModeCount, uFpui) +GO(GetAdapterMonitor, pFpu) +GO(GetAutoGenFilterType, iFp) +GO(GetAvailableTextureMem, uFp) +GO(GetBackBuffer, iFpuip, 4);) +GO(GetCertificate, iFpup) +GO(GetCertificateSize, iFpp) +GO(GetClipPlane, iFpup) +GO(GetClipStatus, iFpp) +GO(GetContainer, iFppp) +GO(GetContentProtectionCaps, iFpppp) +GO(GetCreationParameters, iFpp) +GO(GetCurrentTexturePalette, iFpp) +GO(GetData, iFppuu) +GO(GetDataSize, uFp) +GO(GetDC, iFpp) +GO(GetDeclaration, iFppp) +GO(GetDesc, iFpp) +GO(GetDeviceCaps, iFpip) +GO(GetDeviceCaps, iFpp) +GO(GetDeviceCaps, iFpuip) +GO(GetDevice, iFpp) +GO(GetDirect3D, iFpp) +GO(GetDisplayModeEx, iFppp) +GO(GetDisplayModeEx, iFpupp) +GO(GetDisplayMode, iFpp) +GO(GetDisplayMode, iFpup) +GO(GetEncryptionBltKey, iFppu) +GO(GetFrontBufferData, iFpp) +GO(GetFrontBufferData, iFpup) +GO(GetFunction, iFppp) +GO(GetFVF, iFpp) +GO(GetGammaRamp, vFpup) +GO(GetGPUThreadPriority, iFpp) +GO(GetIndices, iFpp) +GO(GetLastPresentCount, iFpp) +GO(GetLevelCount, uFp) +GO(GetLevelDesc, iFpup) +GO(GetLightEnable, iFpup) +GO(GetLight, iFpup) +GO(GetLOD, uFp) +GO(GetMaterial, iFpp) +GO(GetMaximumFrameLatency, iFpp) +GO(GetNPatchMode, fFp) +GO(GetNumberOfSwapChains, uFp) +GO(GetPaletteEntries, iFpup) +GO(GetPixelShaderConstantB, iFpupu) +GO(GetPixelShaderConstantF, iFpupu) +GO(GetPixelShaderConstantI, iFpupu) +GO(GetPixelShader, iFpp) +GO(GetPresentParameters, iFpp) +GO(GetPresentStats, iFpp) +GO(GetPriority, uFp) +GO(GetPrivateData, iFpppp) +GO(GetRasterStatus, iFpp) +GO(GetRasterStatus, iFpup) +GO(GetRenderState, iFpip) +GO(GetRenderTargetData, iFppp) +GO(GetSamplerState, iFpuip) +GO(GetScissorRect, iFpp) +GO(GetSoftwareVertexProcessing, iFp) +GO(GetStreamSourceFreq, iFpup) +GO(GetStreamSource, iFpuppp) +GO(GetSurfacePitch, iFppp) +GO(GetTexture, iFpup) +GO(GetTextureStageState, iFpuip) +GO(GetTransform, iFpip) +GO(GetType, iFp) +GO(GetVertexDeclaration, iFpp) +GO(GetVertexShaderConstantB, iFpupu) +GO(GetVertexShaderConstantF, iFpupu) +GO(GetVertexShaderConstantI, iFpupu) +GO(GetVertexShader, iFpp) +GO(GetViewport, iFpp) +GO(Issue, iFpu) +GO(LightEnable, iFpui) +GO(LockBox, iFpppu) +GO(LockBox, iFpuppu) +GO(Lock, iFpuupu) +GO(LockRect, iFpiuppu) +GO(LockRect, iFpppu) +GO(LockRect, iFpuppu) +GOM(CheckResourceResidency, iFEppu) +GOM(CreateAdditionalSwapChain, iFEppp) +GOM(CreateAuthenticatedChannel, iFEpipp) +GOM(CreateCryptoSession, iFEppppp) +GOM(CreateCubeTexture, iFEpuuuiipp) +GOM(CreateDepthStencilSurfaceEx, iFEpuuiiuippu) +GOM(CreateDepthStencilSurface, iFEpuuiiuipp) +GOM(CreateIndexBuffer, iFEpuuiipp) +GOM(CreateOffscreenPlainSurfaceEx, iFEpuuiippu) +GOM(CreateOffscreenPlainSurface, iFEpuuiipp) +GOM(CreatePixelShader, iFEppp) +GOM(CreateQuery, iFEpip) +GOM(CreateRenderTargetEx, iFEpuuiiuippu) +GOM(CreateRenderTarget, iFEpuuiiuipp) +GOM(CreateStateBlock, iFEpip) +GOM(CreateTexture, iFEpuuuuiipp) +GOM(CreateVertexBuffer, iFEpuuuipp) +GOM(CreateVertexDeclaration, iFEppp) +GOM(CreateVertexShader, iFEppp) +GOM(CreateVolumeTexture, iFEpuuuuuiipp) +GOM(EndStateBlock, iFEpp) +GOM(GetBackBuffer, iFEpuuip) +GOM(GetCubeMapSurface, iFEpiup) +GOM(GetDepthStencilSurface, iFEpp) +GOM(GetDirect3D, iFEpp) +GOM(GetRenderTarget, iFEpup) +GOM(GetSurfaceLevel, iFEpup) +GOM(GetSwapChain, iFEpup) +GOM(GetVolumeLevel, iFEpup) +GO(MultiplyTransform, iFpip) +GO(NegotiateKeyExchange, iFpup) +GO(PreLoad, vFp) +GO(PresentEx, iFpppppu) +GO(Present, iFppppp) +GO(Present, iFpppppu) +GO(ProcessVertices, iFpuuuppu) +GO(Query, iFpupup) +GO(QueryInterface, iFppp) +GO(RegisterSoftwareDevice, iFpp) +GO(ReleaseDC, iFpp) +GO(Release, uFp) +GO(ResetEx, iFppp) +GO(Reset, iFpp) +GO(SetAutoGenFilterType, iFpi) +GO(SetClipPlane, iFpup) +GO(SetClipStatus, iFpp) +GO(SetConvolutionMonoKernel, iFpuupp) +GO(SetCurrentTexturePalette, iFpu) +GO(SetCursorPosition, vFpiiu) +GO(SetCursorProperties, iFpuup) +GO(SetDepthStencilSurface, iFpp) +GO(SetDialogBoxMode, iFpi) +GO(SetFVF, iFpu) +GO(SetGammaRamp, vFpuup) +GO(SetGPUThreadPriority, iFpi) +GO(SetIndices, iFpp) +GO(SetLight, iFpup) +GO(SetLOD, uFpu) +GO(SetMaterial, iFpp) +GO(SetMaximumFrameLatency, iFpu) +GO(SetNPatchMode, iFpf) +GO(SetPaletteEntries, iFpup) +GO(SetPixelShaderConstantB, iFpupu) +GO(SetPixelShaderConstantF, iFpupu) +GO(SetPixelShaderConstantI, iFpupu) +GO(SetPixelShader, iFpp) +GO(SetPriority, uFpu) +GO(SetPrivateData, iFpppuu) +GO(SetRenderState, iFpiu) +GO(SetRenderTarget, iFpup) +GO(SetSamplerState, iFpuiu) +GO(SetScissorRect, iFpp) +GO(SetSoftwareVertexProcessing, iFpi) +GO(SetStreamSourceFreq, iFpuu) +GO(SetStreamSource, iFpupuu) +GO(SetTexture, iFpup) +GO(SetTextureStageState, iFpuiu) +GO(SetTransform, iFpip) +GO(SetVertexDeclaration, iFpp) +GO(SetVertexShaderConstantB, iFpupu) +GO(SetVertexShaderConstantF, iFpupu) +GO(SetVertexShaderConstantI, iFpupu) +GO(SetVertexShader, iFpp) +GO(SetViewport, iFpp) +GO(ShowCursor, iFpi) +GO(StartSessionKeyRefresh, iFppu) +GO(StretchRect, iFpppppi) +GO(TestCooperativeLevel, iFp) +GO(UnlockBox, iFp) +GO(UnlockBox, iFpu) +GO(Unlock, iFp) +GO(UnlockRect, iFp) +GO(UnlockRect, iFpiu) +GO(UnlockRect, iFpu) +GO(UpdateSurface, iFppppp) +GO(UpdateTexture, iFppp) +GO(ValidateDevice, iFpp) +GO(WaitForVBlank, iFpu) diff --git a/src/wrapped/wrappedfreetype_private.h b/src/wrapped/wrappedfreetype_private.h index 6453c49b9b..9ca06f23f4 100755 --- a/src/wrapped/wrappedfreetype_private.h +++ b/src/wrapped/wrappedfreetype_private.h @@ -15,25 +15,10 @@ GO(FT_Bitmap_Done, iFpp) GO(FT_Bitmap_Embolden, iFppll) GO(FT_Bitmap_Init, vFp) GO(FT_Bitmap_New, vFp) -//GO(FTC_CMapCache_Lookup, -//GO(FTC_CMapCache_New, //GO(FT_CeilFix, -//GO(FTC_ImageCache_Lookup, -//GO(FTC_ImageCache_LookupScaler, -//GO(FTC_ImageCache_New, //GO(FT_ClassicKern_Free, //GO(FT_ClassicKern_Validate, -//GO(FTC_Manager_Done, -//GO(FTC_Manager_LookupFace, -//GO(FTC_Manager_LookupSize, -//GO(FTC_Manager_New, -//GO(FTC_Manager_RemoveFaceID, -//GO(FTC_Manager_Reset, -//GO(FTC_Node_Unref, GO(FT_Cos, lFl) -//GO(FTC_SBitCache_Lookup, -//GO(FTC_SBitCache_LookupScaler, -//GO(FTC_SBitCache_New, //GO(FT_DivFix, GO(FT_Done_Face, iFp) GO(FT_Done_FreeType, iFp) diff --git a/src/wrapped/wrappedgobject2_private.h b/src/wrapped/wrappedgobject2_private.h index 758fad7d42..36315bdf76 100755 --- a/src/wrapped/wrappedgobject2_private.h +++ b/src/wrapped/wrappedgobject2_private.h @@ -65,8 +65,6 @@ DATA(g_cclosure_marshal_VOID__VARIANT, 4) DATA(g_cclosure_marshal_VOID__VARIANTv, 4) DATA(g_cclosure_marshal_VOID__VOID, 4) DATA(g_cclosure_marshal_VOID__VOIDv, 4) -//GO(g_cclosure_marshal_VOID__STRING, vFppuppp) //old closure definition -//GO(g_cclosure_marshal_VOID__VOID, vFppuppp) //old closure definition //GO(g_cclosure_new, //GO(g_cclosure_new_object, //GO(g_cclosure_new_object_swap, @@ -174,7 +172,7 @@ GO(g_param_spec_enum, pFpppiii) GO(g_param_spec_flags, pFpppiui) GO(g_param_spec_float, pFpppfffi) GO(g_param_spec_get_blurb, pFp) -GOM(g_param_spec_get_default_value, pFp) +GOM(g_param_spec_get_default_value, pFp) //%noE GO(g_param_spec_get_name, pFp) GO(g_param_spec_get_nick, pFp) GO(g_param_spec_get_qdata, pFpu) @@ -384,11 +382,11 @@ GO(g_value_get_uint, uFG) GO(g_value_get_uint64, UFG) GO(g_value_get_ulong, LFG) GO(g_value_get_variant, pFG) -GOM(g_value_init, pFpi) +GOM(g_value_init, pFpi) //%noE GO(g_value_init_from_instance, vFGp) GO(g_value_peek_pointer, pFG) GOM(g_value_register_transform_func, vFEiip) -GOM(g_value_reset, pFp) +GOM(g_value_reset, pFp) //%noE GO(g_value_set_boolean, vFGi) GO(g_value_set_boxed, vFGp) GO(g_value_set_boxed_take_ownership, vFGp) @@ -442,4 +440,4 @@ GO(dummy_drag_data_get, vFpppuu) GO(dummy_drag_motion, iFppiiu) GO(dummy_drag_data_received, vFppiipuu) GO(dummy_marshal, vFppuppp) -GO(dummy_marshalv, vFpppppip) \ No newline at end of file +GO(dummy_marshalv, vFpppppip) diff --git a/src/wrapped/wrappediconv_private.h b/src/wrapped/wrappediconv_private.h index 66077ee3a1..bf9a9ce948 100755 --- a/src/wrapped/wrappediconv_private.h +++ b/src/wrapped/wrappediconv_private.h @@ -2,7 +2,6 @@ #error Meh.... #endif -GO(iconv_canonicalize, pFp) GO(libiconv, uFppppp) GO(libiconv_close, iFp) GO(libiconv_open, pFpp) diff --git a/src/wrapped/wrappedlib_init.h b/src/wrapped/wrappedlib_init.h index c090414119..273e3dad5a 100755 --- a/src/wrapped/wrappedlib_init.h +++ b/src/wrapped/wrappedlib_init.h @@ -11,53 +11,82 @@ #define MAPNAME3(N,M) N##M #define MAPNAME2(N,M) MAPNAME3(N,M) #define MAPNAME(N) MAPNAME2(LIBNAME,N) + // prepare the maps +#define _DOIT(P,Q) QUOTE(generated/wrapped##P##Q.h) +#define DOIT(P,Q) _DOIT(P,Q) +#include DOIT(LIBNAME,defs) + +// regular symbol mapped to itself #define GO(N, W) +// regular symbol mapped to itself, but weak #define GOW(N, W) +// symbol mapped to my_symbol #define GOM(N, W) +// symbol mapped to my_symbol, but weak +#define GOWM(N, W) +// regular symbol mapped to itself, that returns a structure #define GOS(N, W) +// weak symbol mapped to itself, that returns a structure +#define GOWS(N, W) +// symbol mapped to another one #define GO2(N, W, O) +// weak symbol mapped to another one +#define GOW2(N, W, O) +// data #define DATA(N, S) +// data, Weak (type V) #define DATAV(N, S) +// data, Uninitialized (type B) #define DATAB(N, S) +// data, "my_" type #define DATAM(N, S) // #define the 4 maps first #undef GO #define GO(N, W) {#N, W, 0}, +#undef GOW +#define GOW(N, W) {#N, W, 1}, static const map_onesymbol_t MAPNAME(symbolmap)[] = { #include PRIVATE(LIBNAME) }; #undef GO #define GO(N, W) #undef GOW -#define GOW(N, W) {#N, W, 1}, -static const map_onesymbol_t MAPNAME(wsymbolmap)[] = { - #include PRIVATE(LIBNAME) -}; -#undef GOW #define GOW(N, W) #undef GOM #define GOM(N, W) {#N, W, 0}, +#undef GOWM +#define GOWM(N, W) {#N, W, 1}, static const map_onesymbol_t MAPNAME(mysymbolmap)[] = { #include PRIVATE(LIBNAME) }; #undef GOM #define GOM(N, W) +#undef GOWM +#define GOWM(N, W) #undef GOS #define GOS(N, W) {#N, W, 0}, +#undef GOWS +#define GOWS(N, W) {#N, W, 1}, static const map_onesymbol_t MAPNAME(stsymbolmap)[] = { #include PRIVATE(LIBNAME) }; #undef GOS #define GOS(N, W) +#undef GOWS +#define GOWS(N, W) #undef GO2 #define GO2(N, W, O) {#N, W, 0, #O}, +#undef GOW2 +#define GOW2(N, W, O) {#N, W, 1, #O}, static const map_onesymbol2_t MAPNAME(symbol2map)[] = { #include PRIVATE(LIBNAME) }; #undef GO2 #define GO2(N, W, O) +#undef GOW2 +#define GOW2(N, W, O) #undef DATA #undef DATAV #undef DATAB @@ -78,10 +107,25 @@ static const map_onedata_t MAPNAME(datamap)[] = { static const map_onedata_t MAPNAME(mydatamap)[] = { #include PRIVATE(LIBNAME) }; -#include "wrappedlib_undefs.h" +#undef GO +#undef GOW +#undef GOM +#undef GOWM +#undef GOS +#undef GOWS +#undef GO2 +#undef GOW2 +#undef DATA +#undef DATAV +#undef DATAB +#undef DATAM +#include DOIT(LIBNAME,undefs) +#undef DOIT +#undef _DOIT +void NativeLib_CommonInit(library_t* lib); int FUNC(_init)(library_t* lib, box86context_t* box86) { // Init first @@ -108,50 +152,30 @@ int FUNC(_init)(library_t* lib, box86context_t* box86) #endif } else lib->path = strdup(MAPNAME(Name)); } - lib->priv.w.bridge = NewBridge(); -// Create maps - lib->symbolmap = kh_init(symbolmap); - lib->wsymbolmap = kh_init(symbolmap); - lib->mysymbolmap = kh_init(symbolmap); - lib->stsymbolmap = kh_init(symbolmap); - lib->symbol2map = kh_init(symbol2map); - lib->datamap = kh_init(datamap); - lib->wdatamap = kh_init(datamap); - lib->mydatamap = kh_init(datamap); + NativeLib_CommonInit(lib); khint_t k; int ret; int cnt; // populates maps... - cnt = sizeof(MAPNAME(symbolmap))/sizeof(map_onesymbol_t); - for (int i=0; isymbolmap, MAPNAME(symbolmap)[i].name, &ret); - kh_value(lib->symbolmap, k) = MAPNAME(symbolmap)[i].w; - if(strchr(MAPNAME(symbolmap)[i].name, '@')) - AddDictionnary(box86->versym, MAPNAME(symbolmap)[i].name); - } - cnt = sizeof(MAPNAME(wsymbolmap))/sizeof(map_onesymbol_t); - for (int i=0; iwsymbolmap, MAPNAME(wsymbolmap)[i].name, &ret); - kh_value(lib->wsymbolmap, k) = MAPNAME(wsymbolmap)[i].w; - if(strchr(MAPNAME(wsymbolmap)[i].name, '@')) - AddDictionnary(box86->versym, MAPNAME(wsymbolmap)[i].name); - } - cnt = sizeof(MAPNAME(mysymbolmap))/sizeof(map_onesymbol_t); - for (int i=0; imysymbolmap, MAPNAME(mysymbolmap)[i].name, &ret); - kh_value(lib->mysymbolmap, k) = MAPNAME(mysymbolmap)[i].w; - if(strchr(MAPNAME(mysymbolmap)[i].name, '@')) - AddDictionnary(box86->versym, MAPNAME(mysymbolmap)[i].name); - } - cnt = sizeof(MAPNAME(stsymbolmap))/sizeof(map_onesymbol_t); - for (int i=0; istsymbolmap, MAPNAME(stsymbolmap)[i].name, &ret); - kh_value(lib->stsymbolmap, k) = MAPNAME(stsymbolmap)[i].w; - if(strchr(MAPNAME(stsymbolmap)[i].name, '@')) - AddDictionnary(box86->versym, MAPNAME(stsymbolmap)[i].name); - } +#define DOIT(mapname) \ + cnt = sizeof(MAPNAME(mapname))/sizeof(map_onesymbol_t); \ + for (int i = 0; i < cnt; ++i) { \ + if (MAPNAME(mapname)[i].weak) { \ + k = kh_put(symbolmap, lib->w##mapname, MAPNAME(mapname)[i].name, &ret); \ + kh_value(lib->w##mapname, k) = MAPNAME(mapname)[i].w; \ + } else { \ + k = kh_put(symbolmap, lib->mapname, MAPNAME(mapname)[i].name, &ret); \ + kh_value(lib->mapname, k) = MAPNAME(mapname)[i].w; \ + } \ + if (strchr(MAPNAME(mapname)[i].name, '@')) \ + AddDictionnary(box86->versym, MAPNAME(mapname)[i].name); \ + } + DOIT(symbolmap) + DOIT(mysymbolmap) + DOIT(stsymbolmap) +#undef DOIT cnt = sizeof(MAPNAME(symbol2map))/sizeof(map_onesymbol2_t); for (int i=0; isymbol2map, MAPNAME(symbol2map)[i].name, &ret); @@ -183,67 +207,51 @@ int FUNC(_init)(library_t* lib, box86context_t* box86) return 0; } -int FUNC(_fini)(library_t* lib) +void NativeLib_FinishFini(library_t* lib); +void FUNC(_fini)(library_t* lib) { #ifdef CUSTOM_FINI CUSTOM_FINI #endif - if(lib->priv.w.lib) - dlclose(lib->priv.w.lib); - lib->priv.w.lib = NULL; - if(lib->priv.w.altprefix) - free(lib->priv.w.altprefix); - if(lib->priv.w.neededlibs) { - for(int i=0; ipriv.w.needed; ++i) - free(lib->priv.w.neededlibs[i]); - free(lib->priv.w.neededlibs); - } - FreeBridge(&lib->priv.w.bridge); - return 1; + return NativeLib_FinishFini(lib); } +int NativeLib_defget(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, int version, const char* vername, int local); int FUNC(_get)(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, int version, const char* vername, int local) { +#ifdef CUSTOM_FAIL uintptr_t addr = 0; uint32_t size = 0; -#ifdef CUSTOM_FAIL void* symbol = NULL; -#endif -//PRE if (!getSymbolInMaps(lib, name, 0, &addr, &size, version, vername, local)) { -#ifdef CUSTOM_FAIL - CUSTOM_FAIL -#else - return 0; -#endif + CUSTOM_FAIL } -//POST if(!addr && !size) return 0; *offs = addr; *sz = size; return 1; +#else + return NativeLib_defget(lib, name, offs, sz, version, vername, local); +#endif } +int NativeLib_defgetnoweak(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, int version, const char* vername, int local); int FUNC(_getnoweak)(library_t* lib, const char* name, uintptr_t *offs, uint32_t *sz, int version, const char* vername, int local) { +#ifdef CUSTOM_FAIL uintptr_t addr = 0; uint32_t size = 0; -#ifdef CUSTOM_FAIL void* symbol = NULL; -#endif -//PRE if (!getSymbolInMaps(lib, name, 1, &addr, &size, version, vername, local)) { -#ifdef CUSTOM_FAIL - CUSTOM_FAIL -#else - return 0; -#endif + CUSTOM_FAIL } -//POST if(!addr && !size) return 0; *offs = addr; *sz = size; return 1; +#else + return NativeLib_defgetnoweak(lib, name, offs, sz, version, vername, local); +#endif } diff --git a/src/wrapped/wrappedlib_undefs.h b/src/wrapped/wrappedlib_undefs.h deleted file mode 100755 index 7c6ac84bd7..0000000000 --- a/src/wrapped/wrappedlib_undefs.h +++ /dev/null @@ -1,23 +0,0 @@ -// regular symbol mapped to itself -#undef GO - -// regular symbol mapped to itself, but weak (unimplemented for now) -#undef GOW - -// symbol mapped to my_symbol -#undef GOM - -// symbol mapped to another one -#undef GO2 - -// data -#undef DATA - -// data, Weak (type V) -#undef DATAV - -// data, Uninitialized (type B) -#undef DATAB - -// data, "my_" type -#undef DATAM diff --git a/src/wrapped/wrappedlibasound_private.h b/src/wrapped/wrappedlibasound_private.h index f5f41d0a5b..0a80a8ceb2 100755 --- a/src/wrapped/wrappedlibasound_private.h +++ b/src/wrapped/wrappedlibasound_private.h @@ -558,7 +558,7 @@ GO(snd_timer_query_status, iFpp) GO(snd_timer_open, iFppi) GO(snd_timer_open_lconf, iFppip) GO(snd_timer_close, iFp) -//GO(snd_async_add_timer_handler, iFppPp) +//GO(snd_async_add_timer_handler, iFpp@p) //GO(snd_async_handler_get_timer, pFp) GO(snd_timer_poll_descriptors_count, iFp) GO(snd_timer_poll_descriptors, iFppu) @@ -675,7 +675,7 @@ GO(snd_ctl_open, iFppi) GO(snd_ctl_open_lconf, iFppip) GO(snd_ctl_close, iFp) GO(snd_ctl_nonblock, iFpi) -//GO(snd_async_add_ctl_handler, iFppPp) +//GO(snd_async_add_ctl_handler, iFpp@p) //GO(snd_async_handler_get_ctl, pFp) GO(snd_ctl_poll_descriptors_count, iFp) GO(snd_ctl_poll_descriptors, iFppu) @@ -862,7 +862,7 @@ GO(snd_hctl_set_compare, iFpp) GO(snd_hctl_first_elem, pFp) GO(snd_hctl_last_elem, pFp) GO(snd_hctl_find_elem, pFpp) -//GO(snd_hctl_set_callback, vFpP) +//GO(snd_hctl_set_callback, vFp@) //GO(snd_hctl_set_callback_private, vFpp) //GO(snd_hctl_get_callback_private, pFp) GO(snd_hctl_load, iFp) @@ -887,7 +887,7 @@ GO(snd_hctl_elem_get_device, uFp) GO(snd_hctl_elem_get_subdevice, uFp) GO(snd_hctl_elem_get_name, pFp) GO(snd_hctl_elem_get_index, uFp) -//GO(snd_hctl_elem_set_callback, vFpP) +//GO(snd_hctl_elem_set_callback, vFp@) //GO(snd_hctl_elem_get_callback_private, pFp) //GO(snd_hctl_elem_set_callback_private, vFpp) GO(snd_sctl_build, iFppppi) @@ -911,14 +911,14 @@ GO(snd_mixer_load, iFp) GO(snd_mixer_free, vFp) GO(snd_mixer_wait, iFpi) GO(snd_mixer_set_compare, iFpp) -//GO(snd_mixer_set_callback, vFpP) +//GO(snd_mixer_set_callback, vFp@) //GO(snd_mixer_get_callback_private, pFp) //GO(snd_mixer_set_callback_private, vFpp) GO(snd_mixer_get_count, uFp) GO(snd_mixer_class_unregister, iFp) GO(snd_mixer_elem_next, pFp) GO(snd_mixer_elem_prev, pFp) -//GO(snd_mixer_elem_set_callback, vFpP) +//GO(snd_mixer_elem_set_callback, vFp@) //GO(snd_mixer_elem_get_callback_private, pFp) //GO(snd_mixer_elem_set_callback_private, vFpp) GO(snd_mixer_elem_get_type, iFp) @@ -1272,4 +1272,4 @@ GO(snd_seq_parse_address, iFppp) GO(snd_hwdep_info_get_iface, iFp) DATAM(snd_lib_error, 4) -GO(superdummy_error_handler, vFpipipV) // dummy to have the bridge definition \ No newline at end of file +GO(superdummy_error_handler, vFpipipV) // dummy to have the bridge definition diff --git a/src/wrapped/wrappedlibc.c b/src/wrapped/wrappedlibc.c index 1996d05a33..32fd84c578 100755 --- a/src/wrapped/wrappedlibc.c +++ b/src/wrapped/wrappedlibc.c @@ -687,112 +687,100 @@ void myStackAlign(const char* fmt, uint32_t* st, uint32_t* mystack); // align st typedef int (*iFpp_t)(void*, void*); typedef int (*iFppp_t)(void*, void*, void*); typedef int (*iFpupp_t)(void*, uint32_t, void*, void*); -EXPORT int my_printf(x86emu_t *emu, void* fmt, void* b, va_list V) { +EXPORT int my_printf(x86emu_t *emu, void* fmt, void* b) { #ifndef NOALIGN // need to align on arm myStackAlign((const char*)fmt, b, emu->scratch); PREPARE_VALIST; - void* f = vprintf; - return ((iFpp_t)f)(fmt, VARARGS); + return vprintf(fmt, VARARGS); #else // other platform don't need that - return vprintf((const char*)fmt, V); + return vprintf((const char*)fmt, b); #endif } -EXPORT int my___printf_chk(x86emu_t *emu, void* fmt, void* b, va_list V) __attribute__((alias("my_printf"))); +EXPORT int my___printf_chk(x86emu_t *emu, void* fmt, void* b) __attribute__((alias("my_printf"))); -EXPORT int my_vprintf(x86emu_t *emu, void* fmt, void* b, va_list V) { +EXPORT int my_vprintf(x86emu_t *emu, void* fmt, void* b) { #ifndef NOALIGN // need to align on arm - myStackAlign((const char*)fmt, (uint32_t*)b, emu->scratch); + myStackAlign((const char*)fmt, b, emu->scratch); PREPARE_VALIST; - void* f = vprintf; - return ((iFpp_t)f)(fmt, VARARGS); + return vprintf(fmt, VARARGS); #else // other platform don't need that - void* f = vprintf; - return ((iFpp_t)f)(fmt, (uint32_t*)b); + return vprintf(fmt, b); #endif } -EXPORT int my___vprintf_chk(x86emu_t *emu, void* fmt, void* b, va_list V) __attribute__((alias("my_vprintf"))); +EXPORT int my___vprintf_chk(x86emu_t *emu, void* fmt, void* b) __attribute__((alias("my_vprintf"))); EXPORT int my_vfprintf(x86emu_t *emu, void* F, void* fmt, void* b) { #ifndef NOALIGN // need to align on arm - myStackAlign((const char*)fmt, (uint32_t*)b, emu->scratch); + myStackAlign((const char*)fmt, b, emu->scratch); PREPARE_VALIST; - void* f = vfprintf; - return ((iFppp_t)f)(F, fmt, VARARGS); + return vfprintf(F, fmt, VARARGS); #else // other platform don't need that - void* f = vfprintf; - return ((iFppp_t)f)(F, fmt, (uint32_t*)b); + return vfprintf(F, fmt, b); #endif } EXPORT int my___vfprintf_chk(x86emu_t *emu, void* F, void* fmt, void* b) __attribute__((alias("my_vfprintf"))); EXPORT int my__IO_vfprintf(x86emu_t *emu, void* F, void* fmt, void* b) __attribute__((alias("my_vfprintf"))); -EXPORT int my_fprintf(x86emu_t *emu, void* F, void* fmt, void* b, va_list V) { +EXPORT int my_fprintf(x86emu_t *emu, void* F, void* fmt, void* V) { #ifndef NOALIGN // need to align on arm - myStackAlign((const char*)fmt, b, emu->scratch); + myStackAlign((const char*)fmt, V, emu->scratch); PREPARE_VALIST; - void* f = vfprintf; - return ((iFppp_t)f)(F, fmt, VARARGS); + return vfprintf((FILE*)F, (const char*)fmt, VARARGS); #else - // other platform don't need that - return vfprintf((FILE*)F, (const char*)fmt, V); + return vfprintf((FILE*)F, (const char*)fmt, (va_list)V); #endif } -EXPORT int my___fprintf_chk(x86emu_t *emu, void* F, void* fmt, void* b, va_list V) __attribute__((alias("my_fprintf"))); +EXPORT int my___fprintf_chk(x86emu_t *emu, void* F, void* fmt, void* V) __attribute__((alias("my_fprintf"))); -EXPORT int my_wprintf(x86emu_t *emu, void* fmt, void* b, va_list V) { +EXPORT int my_wprintf(x86emu_t *emu, void* fmt, void* V) { #ifndef NOALIGN // need to align on arm - myStackAlignW((const char*)fmt, b, emu->scratch); + myStackAlignW((const char*)fmt, V, emu->scratch); PREPARE_VALIST; - void* f = vwprintf; - return ((iFpp_t)f)(fmt, VARARGS); + return vwprintf(fmt, VARARGS); #else // other platform don't need that - return vwprintf((const wchar_t*)fmt, V); + return vwprintf((const wchar_t*)fmt, (va_list)V); #endif } -EXPORT int my___wprintf_chk(x86emu_t *emu, int flag, void* fmt, void* b, va_list V) { +EXPORT int my___wprintf_chk(x86emu_t *emu, int flag, void* fmt, void* V) { #ifndef NOALIGN // need to align on arm - myStackAlignW((const char*)fmt, b, emu->scratch); + myStackAlignW((const char*)fmt, V, emu->scratch); PREPARE_VALIST; - void* f = vwprintf; - return ((iFpp_t)f)(fmt, VARARGS); + return vwprintf(fmt, VARARGS); #else // other platform don't need that - return vwprintf((const wchar_t*)fmt, V); + return vwprintf((const wchar_t*)fmt, (va_list)V); #endif } -EXPORT int my_fwprintf(x86emu_t *emu, void* F, void* fmt, void* b, va_list V) { +EXPORT int my_fwprintf(x86emu_t *emu, void* F, void* fmt, void* V) { #ifndef NOALIGN // need to align on arm - myStackAlignW((const char*)fmt, b, emu->scratch); + myStackAlignW((const char*)fmt, V, emu->scratch); PREPARE_VALIST; - void* f = vfwprintf; - return ((iFppp_t)f)(F, fmt, VARARGS); + return vfwprintf(F, fmt, VARARGS); #else // other platform don't need that return vfwprintf((FILE*)F, (const wchar_t*)fmt, V); #endif } -EXPORT int my___fwprintf_chk(x86emu_t *emu, void* F, void* fmt, void* b, va_list V) __attribute__((alias("my_fwprintf"))); +EXPORT int my___fwprintf_chk(x86emu_t *emu, void* F, void* fmt, void* V) __attribute__((alias("my_fwprintf"))); EXPORT int my_vfwprintf(x86emu_t *emu, void* F, void* fmt, void* b) { #ifndef NOALIGN myStackAlignW((const char*)fmt, b, emu->scratch); PREPARE_VALIST; - void* f = vfwprintf; - return ((iFppp_t)f)(F, fmt, VARARGS); + return vfwprintf(F, fmt, VARARGS); #else - void* f = vfwprintf; - return ((iFppp_t)f)(F, fmt, b); + return vfwprintf(F, fmt, b); #endif } @@ -813,61 +801,54 @@ EXPORT void *my_div(void *result, int numerator, int denominator) { return result; } -EXPORT int my_snprintf(x86emu_t* emu, void* buff, size_t s, void * fmt, void * b, va_list V) { +EXPORT int my_snprintf(x86emu_t* emu, void* buff, size_t s, void * fmt, void * b) { #ifndef NOALIGN // need to align on arm myStackAlign((const char*)fmt, b, emu->scratch); PREPARE_VALIST; - void* f = vsnprintf; - int r = ((iFpupp_t)f)(buff, s, fmt, VARARGS); - return r; + return vsnprintf(buff, s, fmt, VARARGS); #else - return vsnprintf((char*)buff, s, (char*)fmt, V); + return vsnprintf((char*)buff, s, (char*)fmt, b); #endif } -EXPORT int my___snprintf(x86emu_t* emu, void* buff, size_t s, void * fmt, void * b, va_list V) __attribute__((alias("my_snprintf"))); +EXPORT int my___snprintf(x86emu_t* emu, void* buff, size_t s, void * fmt, void * b) __attribute__((alias("my_snprintf"))); -EXPORT int my___snprintf_chk(x86emu_t* emu, void* buff, size_t s, int f1, int f2, void * fmt, void * b, va_list V) { +EXPORT int my___snprintf_chk(x86emu_t* emu, void* buff, size_t s, int f1, int f2, void * fmt, void * b) { (void)f1; (void)f2; #ifndef NOALIGN // need to align on arm myStackAlign((const char*)fmt, b, emu->scratch); PREPARE_VALIST; - void* f = vsnprintf; - int r = ((iFpupp_t)f)(buff, s, fmt, VARARGS); - return r; + return vsnprintf(buff, s, fmt, VARARGS); #else - return vsnprintf((char*)buff, s, (char*)fmt, V); + return vsnprintf((char*)buff, s, (char*)fmt, b); #endif } -EXPORT int my_sprintf(x86emu_t* emu, void* buff, void * fmt, void * b, va_list V) { +EXPORT int my_sprintf(x86emu_t* emu, void* buff, void * fmt, void * b) { #ifndef NOALIGN // need to align on arm myStackAlign((const char*)fmt, b, emu->scratch); PREPARE_VALIST; - void* f = vsprintf; - return ((iFppp_t)f)(buff, fmt, VARARGS); + return vsprintf(buff, fmt, VARARGS); #else - return vsprintf((char*)buff, (char*)fmt, V); + return vsprintf((char*)buff, (char*)fmt, b); #endif } -EXPORT int my___sprintf_chk(x86emu_t* emu, void* buff, void * fmt, void * b, va_list V) __attribute__((alias("my_sprintf"))); +EXPORT int my___sprintf_chk(x86emu_t* emu, void* buff, void * fmt, void * b) __attribute__((alias("my_sprintf"))); -EXPORT int my_asprintf(x86emu_t* emu, void** buff, void * fmt, void * b, va_list V) { +EXPORT int my_asprintf(x86emu_t* emu, void** buff, void * fmt, void * b) { #ifndef NOALIGN // need to align on arm myStackAlign((const char*)fmt, b, emu->scratch); PREPARE_VALIST; - void* f = vasprintf; - return ((iFppp_t)f)(buff, fmt, VARARGS); + return vasprintf(buff, fmt, VARARGS); #else - return vasprintf((char**)buff, (char*)fmt, V); + return vasprintf((char**)buff, (char*)fmt, b); #endif } -EXPORT int my___asprintf(x86emu_t* emu, void** buff, void * fmt, void * b, va_list V) __attribute__((alias("my_asprintf"))); - +EXPORT int my___asprintf(x86emu_t* emu, void** buff, void * fmt, void * b) __attribute__((alias("my_asprintf"))); EXPORT int my_vsprintf(x86emu_t* emu, void* buff, void * fmt, uint32_t * b) { #ifndef NOALIGN @@ -985,15 +966,14 @@ EXPORT int my___vasprintf_chk(x86emu_t* emu, void* strp, int flags, void* fmt, v #endif } -EXPORT int my___asprintf_chk(x86emu_t* emu, void* result_ptr, int flags, void* fmt, void* b, va_list V) +EXPORT int my___asprintf_chk(x86emu_t* emu, void* result_ptr, int flags, void* fmt, void* b) { #ifndef NOALIGN myStackAlign((const char*)fmt, b, emu->scratch); PREPARE_VALIST; - void* f = vasprintf; - return ((iFppp_t)f)(result_ptr, fmt, VARARGS); + return vasprintf(result_ptr, fmt, VARARGS); #else - return vasprintf((char**)result_ptr, (char*)fmt, V); + return vasprintf((char**)result_ptr, (char*)fmt, b); #endif } diff --git a/src/wrapped/wrappedlibc_private.h b/src/wrapped/wrappedlibc_private.h index 8b2275ecb3..f94d185423 100755 --- a/src/wrapped/wrappedlibc_private.h +++ b/src/wrapped/wrappedlibc_private.h @@ -64,9 +64,9 @@ GOW(argz_next, pFpLp) GOW(argz_stringify, vFpLi) GO(asctime, pFp) GOW(asctime_r, pFpp) -GOM(asprintf, iFEppVV) //%% Weak -GOM(__asprintf, iFEppVV) //%% -GOM(__asprintf_chk, iFEpipVV) //%% +GOWM(asprintf, iFEppV) //%% +GOM(__asprintf, iFEppV) //%% +GOM(__asprintf_chk, iFEpipV) //%% // __assert GO(__assert_fail, vFppup) GO(__assert_perror_fail, vFipup) @@ -196,7 +196,7 @@ GO(__dgettext, pFpp) GO(difftime, dFuu) GO(dirfd, iFp) GO(dirname, pFp) -GOS(div, pFpii) //%% +GOS(div, pFpii) //%%,noE // _dl_addr GOM(dl_iterate_phdr, iFEpp) //%% // _dl_mcount_wrapper @@ -284,8 +284,8 @@ GO(eventfd_read, iFip) GO(eventfd_write, iFiU) GO2(execl, iFEpV, my_execv) GO2(execle, iFEpV, my_execve) // Nope! This one needs wrapping, because is char*, char*, ..., char*[] -GO2(execlp, iFEpV, execvp) -GOM(execv, iFEpp) //%% Weak +GO2(execlp, iFpV, execvp) +GOWM(execv, iFEpp) //%% GOM(execve, iFEppp) //%% and this one too... GOW(execvp, iFpp) GO(exit, vFi) @@ -361,17 +361,20 @@ GO(fmemopen, pFpup) // fmtmsg GO(fnmatch, iFppi) GOM(fopen, pFEpp) //%% -GOM(fopen64, pFEpp) //%% Weak +GOWM(fopen64, pFEpp) //%% GOM(fopencookie, pFEpppppp) //%% last 4p are a struct with 4 callbacks... -GOM(fork, iFEv) //%% Weak +GOWM(fork, iFEv) //%% GOM(__fork, iFEv) //%% // __fortify_fail GOW(fpathconf, iFii) GO(__fpending, uFp) -GOM(fprintf, iFEppVV) //%% -GOM(__fprintf_chk, iFEpvpVV) //%% -//GO2(fprintf, iFppV, vfprintf) -//GO2(__fprintf_chk, iFpvpV, vfprintf) +#ifdef NOALIGN +GO(fprintf, iFppV) +GO(__fprintf_chk, iFpvpV) +#else +GOM(fprintf, iFEppV) //%% +GOM(__fprintf_chk, iFEpvpV) //%% +#endif // __fpu_control // type B GO(__fpurge, vFp) GOW(fputc, iFip) @@ -409,7 +412,7 @@ GO(fsetpos, iFpp) GO(fsetpos64, iFpp) GO(fsetxattr, iFippui) GOW(fstatfs, iFip) -GOM(fstatfs64, iFip) //%% weak +GOWM(fstatfs64, iFip) //%%,noE GO(fstatvfs, iFip) GOW(fstatvfs64, iFip) // alignment? GOW(fsync, iFi) @@ -433,8 +436,8 @@ GO(futimens, iFip) GOW(futimes, iFip) //int futimes(int fd, const struct timeval tv[2]) GO(futimesat, iFippp) // fwide -GOM(fwprintf, iFEppVV) //%% Weak -GOM(__fwprintf_chk, iFEpvpVV) //%% +GOWM(fwprintf, iFEppV) //%% +GOM(__fwprintf_chk, iFEpvpV) //%% GO(__fwritable, iFp) GOW(fwrite, LFpLLp) GO(fwrite_unlocked, uFpuup) @@ -527,9 +530,9 @@ GO(getnameinfo, iFpupupui) // getnetname GOW(get_nprocs, iFv) GOW(get_nprocs_conf, iFv) -GOM(getopt, iFipp) -GOM(getopt_long, iFipppp) -GOM(getopt_long_only, iFipppp) +GOM(getopt, iFipp) //%noE +GOM(getopt_long, iFipppp) //%noE +GOM(getopt_long_only, iFipppp) //%noE GOW(getpagesize, iFv) GO(__getpagesize, iFv) GO(getpass, pFp) @@ -651,9 +654,9 @@ GO(hstrerror, pFi) GO(htonl, uFu) GO(htons, uFu) GO(iconv, LFLpppp) +GO(iconv_canonicalize, pFp) GO(iconv_close, iFL) GO(iconv_open, LFpp) -GO(iconv_canonicalize, pFp) GO(if_freenameindex, vFp) GO(if_indextoname, pFup) GO(if_nameindex, pFv) @@ -890,15 +893,15 @@ GO(__isnanf, iFf) // isnanl // Weak // __isnanl #ifdef POWERPCLE -GOM(__isoc99_fscanf, iFppV) //%% +GOM(__isoc99_fscanf, iFEppV) //%% // __isoc99_fwscanf // __isoc99_scanf -GOM(__isoc99_sscanf, iFppV) //%% +GOM(__isoc99_sscanf, iFEppV) //%% // __isoc99_swscanf -GOM(__isoc99_vfscanf, iFppp) //%% +GOM(__isoc99_vfscanf, iFEppp) //%% // __isoc99_vfwscanf // __isoc99_vscanf -GOM(__isoc99_vsscanf, iFppp) //%% TODO: check if ok +GOM(__isoc99_vsscanf, iFEppp) //%% TODO: check if ok // __isoc99_vswscanf // __isoc99_vwscanf // __isoc99_wscanf @@ -1073,7 +1076,7 @@ GOW(mallinfo, pFv) #ifdef NOALIGN GO(malloc, pFL) #else -GOM(malloc, pFL) //%% +GOM(malloc, pFL) //%%,noE #endif // malloc_get_state // Weak DATAV(__malloc_hook, 4) @@ -1101,7 +1104,7 @@ GO(mbtowc, iFppL) // mcheck_check_all // mcheck_pedantic // _mcleanup -GOM(mcount, vFpp) //%% Weak +GOWM(mcount, vFpp) //%%,noE // _mcount GOW(memalign, pFuu) DATAV(__memalign_hook, 4) @@ -1149,7 +1152,7 @@ GOW(mount, iFpppup) GOM(mprotect, iFEpLi) //%% // mrand48 // mrand48_r -GOM(mremap, pFEpLLiN) //%% Weak, 5th hidden paramerer "void* new_addr" if flags is MREMAP_FIXED +GOWM(mremap, pFEpLLiN) //%% 5th hidden paramerer "void* new_addr" if flags is MREMAP_FIXED GO(msgctl, iFiip) GOW(msgget, iFpi) GOW(msgrcv, lFipLli) @@ -1160,7 +1163,7 @@ GO(munlock, iFpL) GO(munlockall, iFv) GOM(munmap, iFEpL) //%% // muntrace -GOM(nanosleep, iFpp) //%% weak +GOWM(nanosleep, iFpp) //%%,noE // __nanosleep // Weak // netname2host // netname2user @@ -1203,22 +1206,22 @@ GOW(ntohs, uFu) // _null_auth // type B // _obstack_allocated_p DATAM(obstack_alloc_failed_handler, 4) -GOM(_obstack_begin, iFpLLpp) //%% +GOM(_obstack_begin, iFpLLpp) //%%,noE // _obstack_begin_1 DATA(obstack_exit_failure, 4) -GOM(_obstack_free, vFpp) //%% -GOM(obstack_free, vFpp) //%% +GOM(_obstack_free, vFpp) //%%,noE +GOM(obstack_free, vFpp) //%%,noE // _obstack_memory_used -GOM(_obstack_newchunk, vFpi) //%% +GOM(_obstack_newchunk, vFpi) //%%,noE // obstack_printf // Weak // __obstack_printf_chk -GOM(obstack_vprintf, iFEpppp) //%% Weak +GOWM(obstack_vprintf, iFEpppp) //%% // __obstack_vprintf_chk // on_exit // Weak -GOM(open, iFEpOu) //%% Weak -GOM(__open, iFEpOu) //%% Weak +GOWM(open, iFEpOu) //%% +GOWM(__open, iFEpOu) //%% GO(__open_2, iFpO) -GOM(open64, iFEpOu) //%% Weak +GOWM(open64, iFEpOu) //%% // __open64 // Weak GO(__open64_2, iFpO) GOW(openat, iFipON) @@ -1293,8 +1296,8 @@ GOW(pread64, lFipLI) // __pread64_chk GOM(preadv64, lFEipiI) //%% not always present // __pread_chk -GOM(printf, iFEpVV) //%% -GOM(__printf_chk, iFEvpVV) //%% +GOM(printf, iFEpV) //%% +GOM(__printf_chk, iFEvpV) //%% GO(__printf_fp, iFppp) // does this needs aligment? // printf_size // printf_size_info @@ -1360,7 +1363,7 @@ GO(__rawmemchr, pFpi) // rcmd // rcmd_af // __rcmd_errstr // type B -GOM(read, lFipL) //%% +GOM(read, lFipL) //%%,noE GOW(__read, lFipL) // readahead // Weak GO(__read_chk, lFipLL) @@ -1404,7 +1407,7 @@ GO(removexattr, iFpp) GO(rename, iFpp) GO(renameat, iFipip) #ifdef PANDORA -GOM(renameat2, iFipipu) //%% +GOM(renameat2, iFipipu) //%%,noE #else GO(renameat2, iFipipu) #endif @@ -1560,11 +1563,11 @@ GOW(shmctl, iFiip) GOW(shmdt, iFp) GOW(shmget, iFuui) GOW(shutdown, iFii) -GOM(sigaction, iFEipp) //%% Weak -GOM(__sigaction, iFEipp) //%% Weak +GOWM(sigaction, iFEipp) //%% +GOWM(__sigaction, iFEipp) //%% GO(sigaddset, iFpi) // __sigaddset -GOM(sigaltstack, iFEpp) //%% Weak +GOWM(sigaltstack, iFEpp) //%% // sigandset GOW(sigblock, iFi) GO(sigdelset, iFpi) @@ -1579,7 +1582,7 @@ GO(siginterrupt, iFii) // no need to wrap this one? GO(sigismember, iFpi) // __sigismember GOM(siglongjmp, vFEip) //%% -GOM(signal, pFEip) //%% Weak +GOWM(signal, pFEip) //%% // signalfd GO(__signbit, iFd) GO(__signbitf, iFf) @@ -1602,15 +1605,15 @@ GOW(sigvec, iFipp) GOW(sigwait, iFpp) GOW(sigwaitinfo, iFpp) GOW(sleep, uFu) -GOM(snprintf, iFEpLpVV) //%% -GOM(__snprintf_chk, iFEpLiipVV) //%% -GOM(__snprintf, iFEpLpVV) //%% +GOM(snprintf, iFEpLpV) //%% +GOM(__snprintf_chk, iFEpLiipV) //%% +GOM(__snprintf, iFEpLpV) //%% // sockatmark GOW(socket, iFiii) GOW(socketpair, iFiiip) GO(splice, iFipipuu) -GOM(sprintf, iFEppVV) //%% -GOM(__sprintf_chk, iFEpvvpVV) //%% +GOM(sprintf, iFEppV) //%% +GOM(__sprintf_chk, iFEpvvpV) //%% // sprofil // Weak GOW(srand, vFu) GO(srand48, vFi) @@ -1618,7 +1621,7 @@ GO(srand48, vFi) GOW(srandom, vFu) GOW(srandom_r, iFup) #ifdef POWERPCLE -GOM(sscanf, iFppV) //%% +GOM(sscanf, iFEppV) //%% #else GO2(sscanf, iFppV, vsscanf) // sscanf va_list is only pointer, no realign to do #endif @@ -1627,7 +1630,7 @@ GO2(sscanf, iFppV, vsscanf) // sscanf va_list is only pointer, no realign to GOM(__stack_chk_fail, vFEv) //%% GOW(statfs, iFpp) // __statfs -GOM(statfs64, iFpp) //%% Weak +GOWM(statfs64, iFpp) //%%,noE GO(statvfs, iFpp) GOW(statvfs64, iFpp) // is alignment ok? DATA(stderr, 4) @@ -1728,7 +1731,7 @@ GOW(strtold_l, DFppu) GO(strtold, KFpp) GO2(__strtold_internal, KFppi, __strtod_internal) GO2(__strtold_l, KFppip, __strtod_l) -GO2(strtold_l, KFppu, strtod_l) +GOW2(strtold_l, KFppu, strtod_l) #endif GO(__strtol_internal, lFppi) GO(strtoll, IFppi) @@ -1811,7 +1814,7 @@ DATA(_sys_siglist, 4) DATA(sys_siglist, 4) GOW(system, iFp) // Need to wrap to use box86 if needed? GOM(__sysv_signal, pFEip) //%% -GOM(sysv_signal, pFEip) //%% Weak +GOWM(sysv_signal, pFEip) //%% GOW(tcdrain, iFi) GO(tcflow, iFii) GO(tcflush, iFii) @@ -1880,7 +1883,7 @@ GO(__uflow, iFp) GOW(umask, uFu) GOW(umount, iFp) GOW(umount2, iFpi) -GOM(uname, iFp) //%% Weak +GOWM(uname, iFp) //%%,noE GO(__underflow, iFp) GOW(ungetc, iFip) GO(ungetwc, iFip) @@ -1911,38 +1914,38 @@ GOM(verr, vFEpV) //%% // verrx GO(versionsort, iFpp) GO(versionsort64, iFpp) //need to align dirent64? -GOM(vfork, iFEv) //%% Weak +GOWM(vfork, iFEv) //%% // __vfork GOM(vfprintf, iFEppp) //%% GOM(__vfprintf_chk, iFEpvpp) //%% #ifdef POWERPCLE -GOM(vfscanf, iFEppp) //%% Weak +GOWM(vfscanf, iFEppp) //%% #else -GOW(vfscanf, iFppp) // Weak +GOW(vfscanf, iFppp) #endif // __vfscanf -GOM(vfwprintf, iFEppp) //%% Weak +GOWM(vfwprintf, iFEppp) //%% GO2(__vfwprintf_chk, iFEpvpp, my_vfwprintf) GOW(vfwscanf, iFppp) // vhangup // vlimit // vmsplice -GOM(vprintf, iFEppp) //%% -GOM(__vprintf_chk, iFEvppp) //%% +GOM(vprintf, iFEpp) //%% +GOM(__vprintf_chk, iFEvpp) //%% // vscanf // Weak -GOM(vsnprintf, iFEpLppp) //%% Weak -GOM(__vsnprintf, iFEpuppp) //%% Weak -GOM(__vsnprintf_chk, iFEpuvvppp) //%% -GOM(vsprintf, iFEppp) //%% Weak -GOM(__vsprintf_chk, iFEpiLpp) //%% +GOWM(vsnprintf, iFEpLppp) //%% +GOWM(__vsnprintf, iFEpuppp) //%% +GOM(__vsnprintf_chk, iFEpuvvppp) //%% +GOWM(vsprintf, iFEppp) //%% +GOM(__vsprintf_chk, iFEpiLpp) //%% #ifdef POWERPCLE GOM(vsscanf, iFEppp) //%% #else GO(vsscanf, iFppp) #endif // __vsscanf // Weak -GOM(vswprintf, iFEpuppp) //%% Weak -GOM(__vswprintf_chk, iFEpuvvppp) //%% Weak +GOWM(vswprintf, iFEpuppp) //%% +GOWM(__vswprintf_chk, iFEpuvvppp) //%% GO(vswscanf, iFppp) GO(vsyslog, vFipp) GO(__vsyslog_chk, vFiipp) @@ -2066,8 +2069,13 @@ GO(wmemset, pFpuL) GO(wordexp, iFppi) GO(wordfree, vFp) // __woverflow -GOM(wprintf, iFEpVV) //%% -GOM(__wprintf_chk, iFEipVV) //%% +#ifdef NOALIGN +GO(wprintf, iFpV) +GO(__wprintf_chk, iFipV) +#else +GOM(wprintf, iFEpV) //%% +GOM(__wprintf_chk, iFEipV) //%% +#endif GOW(write, lFipL) GOW(__write, lFipL) GOW(writev, lFipi) @@ -2156,16 +2164,16 @@ GOM(__xstat, iFEipp) //%% GOM(__xstat64, iFEipp) //%% // forcing a custom __gmon_start__ that does nothing -GOM(__gmon_start__, vFv) //%% +GOM(__gmon_start__, vFEv) //%% -GOM(_Jv_RegisterClasses, vFv) //%% dummy +GOM(_Jv_RegisterClasses, vFv) //%%,noE dummy -GOM(__fdelt_chk, iFi) //%% +GOM(__fdelt_chk, LFL) //%%,noE GOM(getauxval, uFEu) //%% implemented since glibc 2.16 -GOM(prlimit64, lFpupp) //%% -GOM(reallocarray, pFpLL) //%% +GOM(prlimit64, lFpupp) //%%,noE +GOM(reallocarray, pFpLL) //%%,noE GOM(__open_nocancel, iFEpOV) //%% GO2(__read_nocancel, lFipL, read) GO2(__close_nocancel, iFi, close) @@ -2175,29 +2183,29 @@ GOM(getentropy, iFEpL) //%% starting from glibc 2.25 // not found (libitm???), but it seems OK to declare dummies: -GOM(_ITM_RU1, uFp) //%% -GOM(_ITM_RU4, uFp) //%% +GOM(_ITM_RU1, uFp) //%%,noE +GOM(_ITM_RU4, uFp) //%%,noE //GOM(_ITM_RU8, UFp) -GOM(_ITM_memcpyRtWn, vFppu) //%% register(2) -GOM(_ITM_memcpyRnWt, vFppu) //%% register(2) +GOM(_ITM_memcpyRtWn, vFppu) //%%,noE register(2) +GOM(_ITM_memcpyRnWt, vFppu) //%%,noE register(2) GOM(_ITM_addUserCommitAction, vFEpup) GOM(_ITM_registerTMCloneTable, vFEpu) //%% GOM(_ITM_deregisterTMCloneTable, vFEp) //%% -GOM(__umoddi3, UFUU) //%% -GOM(__udivdi3, UFUU) //%% -GOM(__divdi3, IFII) //%% -GOM(__poll_chk, iFpuii) //%% +GOM(__umoddi3, UFUU) //%%,noE +GOM(__udivdi3, UFUU) //%%,noE +GOM(__divdi3, IFII) //%%,noE +GOM(__poll_chk, iFpuii) //%%,noE -GOM(fallocate64, iFiiII) //%% +GOM(fallocate64, iFiiII) //%%,noE DATAM(__libc_stack_end, 4) DATAM(___brk_addr, 4) DATA(__libc_enable_secure, 4) -GOM(__register_frame_info, vFpp) //%% faked function -GOM(__deregister_frame_info, pFp) //%% +GOM(__register_frame_info, vFpp) //%%,noE faked function +GOM(__deregister_frame_info, pFp) //%%,noE GO(name_to_handle_at, iFipppi) // only glibc 2.14+, so may not be present... @@ -2205,12 +2213,21 @@ GOM(modify_ldt, iFEipL) // there is suposedly no glibc wrapper for this one #ifdef ANDROID GOM(__libc_init, vFEpppp) -GOM(stat, iFpp) -GOM(lstat, iFpp) -GOM(fstat, iFip) +GOM(stat, iFpp) //%noE +GOM(lstat, iFpp) //%noE +GOM(fstat, iFip) //%noE GO(__errno, pFv) GO(setprogname, vFp) GO(getprogname, pFv) #include "wrappedlibpthread_private.h" #include "wrappedlibrt_private.h" +#else +// Those symbols don't exist in non-Android builds +//GOM(__libc_init, +//GOM(stat, +//GOM(lstat, +//GOM(fstat, +//GO(__errno, +//GO(setprogname, +//GO(getprogname, #endif diff --git a/src/wrapped/wrappedlibformw_private.h b/src/wrapped/wrappedlibformw_private.h index d204dffc0a..a1674901de 100644 --- a/src/wrapped/wrappedlibformw_private.h +++ b/src/wrapped/wrappedlibformw_private.h @@ -2,11 +2,11 @@ #error Meh.... #endif -//GOM(new_fieldtype, pFPP) +//GOM(new_fieldtype, pF@@) GO(link_fieldtype, pFpp) GO(free_fieldtype, iFp) -//GOM(set_fieldtype_arg, iFpPPP) -//GOM(set_fieldtype_choice, iFpPP) +//GOM(set_fieldtype_arg, iFp@@@) +//GOM(set_fieldtype_choice, iFp@@) GO(new_field, pFiiiiii) GO(dup_field, pFpii) GO(link_field, pFpii) @@ -43,10 +43,10 @@ GO(form_fields, pFp) GO(current_field, pFp) GO(form_win, pFp) GO(form_sub, pFp) -//GOM(form_init, PFp) -//GOM(form_term, PFp) -//GOM(field_init, PFp) -//GOM(field_term, PFp) +//GOM(form_init, @Fp) +//GOM(form_term, @Fp) +//GOM(field_init, @Fp) +//GOM(field_term, @Fp) GO(free_form, iFp) GO(set_form_fields, iFpp) GO(field_count, iFp) @@ -58,10 +58,10 @@ GO(field_index, iFp) GO(set_form_page, iFpi) GO(form_page, iFp) GO(scale_form, iFppp) -//GOM(set_form_init, iFpP) -//GOM(set_form_term, iFpP) -//GOM(set_field_init, iFpP) -//GOM(set_field_term, iFpP) +//GOM(set_form_init, iFp@) +//GOM(set_form_term, iFp@) +//GOM(set_field_init, iFp@) +//GOM(set_field_term, iFp@) GO(post_form, iFp) GO(unpost_form, iFp) GO(pos_form_cursor, iFp) diff --git a/src/wrapped/wrappedlibgl_private.h b/src/wrapped/wrappedlibgl_private.h index 7dda9761f3..c351d8d9c6 100755 --- a/src/wrapped/wrappedlibgl_private.h +++ b/src/wrapped/wrappedlibgl_private.h @@ -1113,8 +1113,6 @@ GO(glFogCoordfEXT,vFf) GO(glFogCoordfvEXT,vFp) //EXT_framebuffer_blit GO(glBlitFramebufferEXT,vFiiiiiiiiiu) -//EXT_framebuffer_multisample -GO(glRenderbufferStorageMultisampleEXT,vFuiuii) //EXT_framebuffer_object GO(glBindFramebufferEXT,vFuu) GO(glBindRenderbufferEXT,vFuu) @@ -1580,56 +1578,6 @@ GO(glIsOcclusionQueryNV,iFu) GO(glProgramBufferParametersIivNV,vFuuuip) GO(glProgramBufferParametersIuivNV,vFuuuip) GO(glProgramBufferParametersfvNV,vFuuuip) -//NV_path_rendering -GO(glCopyPathNV,vFuu) -GO(glCoverFillPathInstancedNV,vFiupuuup) -GO(glCoverFillPathNV,vFuu) -GO(glCoverStrokePathInstancedNV,vFiupuuup) -GO(glCoverStrokePathNV,vFuu) -GO(glDeletePathsNV,vFui) -GO(glGenPathsNV,uFi) -GO(glGetPathColorGenfvNV,vFuup) -GO(glGetPathColorGenivNV,vFuup) -GO(glGetPathCommandsNV,vFup) -GO(glGetPathCoordsNV,vFup) -GO(glGetPathDashArrayNV,vFup) -GO(glGetPathLengthNV,fFuii) -GO(glGetPathMetricRangeNV,vFiuiip) -GO(glGetPathMetricsNV,vFiiupuip) -GO(glGetPathParameterfvNV,vFuup) -GO(glGetPathParameterivNV,vFuup) -GO(glGetPathSpacingNV,vFuiupuffup) -GO(glGetPathTexGenfvNV,vFuup) -GO(glGetPathTexGenivNV,vFuup) -GO(glInterpolatePathsNV,vFuuuf) -GO(glIsPathNV,iFu) -GO(glIsPointInFillPathNV,iFuuff) -GO(glIsPointInStrokePathNV,iFuff) -GO(glPathColorGenNV,vFuuup) -GO(glPathCommandsNV,vFuipiup) -GO(glPathCoordsNV,vFuiup) -GO(glPathCoverDepthFuncNV,vFu) -GO(glPathDashArrayNV,vFuip) -GO(glPathFogGenNV,vFu) -GO(glPathGlyphRangeNV,vFuupiuiuuf) -GO(glPathGlyphsNV,vFuupiiupuuf) -GO(glPathParameterfNV,vFuuf) -GO(glPathParameterfvNV,vFuup) -GO(glPathParameteriNV,vFuui) -GO(glPathParameterivNV,vFuup) -GO(glPathStencilDepthOffsetNV,vFff) -GO(glPathStencilFuncNV,vFuiu) -GO(glPathStringNV,vFuuip) -GO(glPathSubCommandsNV,vFuiiipiup) -GO(glPathSubCoordsNV,vFuiiup) -GO(glPathTexGenNV,vFuuip) -GO(glPointAlongPathNV,iFuiifpppp) -GO(glStencilFillPathInstancedNV,vFiupuuuup) -GO(glStencilFillPathNV,vFuuu) -GO(glStencilStrokePathInstancedNV,vFiupuiuup) -GO(glStencilStrokePathNV,vFuiu) -GO(glTransformPathNV,vFuuup) -GO(glWeightPathsNV,vFuipp) //NV_pixel_data_range GO(glFlushPixelDataRangeNV,vFu) GO(glPixelDataRangeNV,vFuip) @@ -3106,7 +3054,7 @@ GO(glXSwapIntervalEXT,pFppi) //nothing //GLX_MESA_swap_control -GOM(glXSwapIntervalMESA,iFi) +GOM(glXSwapIntervalMESA, iFi) //%noE GO(glXGetSwapIntervalMESA, iFv) //GLX_SGI_swap_control diff --git a/src/wrapped/wrappedlibjpeg62_private.h b/src/wrapped/wrappedlibjpeg62_private.h index 678ef94c04..c96db32264 100755 --- a/src/wrapped/wrappedlibjpeg62_private.h +++ b/src/wrapped/wrappedlibjpeg62_private.h @@ -109,7 +109,7 @@ GOM(jpeg_set_defaults, vFEp) GO(jpeg_set_linear_quality, vFpii) GOM(jpeg_set_marker_processor, vFEpip) GOM(jpeg_set_quality, vFEpii) -GOM(jpeg_simd_cpu_support, iFv) // No emu parameter +GOM(jpeg_simd_cpu_support, iFv) //%noE GO(jpeg_simple_progression, vFp) GO(jpeg_skip_scanlines, uFpu) GOM(jpeg_start_compress, vFEpi) diff --git a/src/wrapped/wrappedlibjpeg_private.h b/src/wrapped/wrappedlibjpeg_private.h index ac9e940a2f..0e39f52efd 100755 --- a/src/wrapped/wrappedlibjpeg_private.h +++ b/src/wrapped/wrappedlibjpeg_private.h @@ -108,7 +108,7 @@ GO(jpeg_set_defaults, vFp) GO(jpeg_set_linear_quality, vFpii) GOM(jpeg_set_marker_processor, vFEpip) GO(jpeg_set_quality, vFpii) -GOM(jpeg_simd_cpu_support, iFv) // No emu parameter +GOM(jpeg_simd_cpu_support, iFv) //%noE GO(jpeg_simple_progression, vFp) GO(jpeg_skip_scanlines, uFpu) GO(jpeg_start_compress, vFpi) diff --git a/src/wrapped/wrappedlibm.c b/src/wrapped/wrappedlibm.c index e0f4e3f442..7ce7fe1a08 100755 --- a/src/wrapped/wrappedlibm.c +++ b/src/wrapped/wrappedlibm.c @@ -81,12 +81,13 @@ GO_cFc(catanh) GO_cFcc(cpow) #undef GO_cFc +#undef GO_cFcc #define FINITE(N, T, R, P, ...) \ EXPORT R my___##N##_finite P \ { \ static int check = 0; \ - T f = NULL; \ + static T f = NULL; \ if(!check) { \ f = (T)dlsym(my_lib->priv.w.lib, "__" #N "_finite"); \ ++check; \ @@ -94,7 +95,7 @@ EXPORT R my___##N##_finite P \ if(f) \ return f(__VA_ARGS__); \ else \ - return N (__VA_ARGS__); \ + return N(__VA_ARGS__); \ } #define F1F(N) FINITE(N, fFf_t, float, (float a), a) @@ -145,4 +146,3 @@ F1D(log) my_lib = NULL; #include "wrappedlib_init.h" - diff --git a/src/wrapped/wrappedlibm_private.h b/src/wrapped/wrappedlibm_private.h index d29a7cc45e..56bf6b075f 100755 --- a/src/wrapped/wrappedlibm_private.h +++ b/src/wrapped/wrappedlibm_private.h @@ -2,45 +2,47 @@ #error meh! #endif +// Complex numbers are passed in as an address in the stack + GOW(acos, dFd) GOW(acosf, fFf) -GOM(__acosf_finite, fFf) -GOM(__acos_finite, dFd) +GOM(__acosf_finite, fFf) //%noE +GOM(__acos_finite, dFd) //%noE GOW(acosh, dFd) GOW(acoshf, fFf) -GOM(__acoshf_finite, fFf) -GOM(__acosh_finite, dFd) +GOM(__acoshf_finite, fFf) //%noE +GOM(__acosh_finite, dFd) //%noE #ifdef HAVE_LD80BITS GOW(acoshl, DFD) #else -GO2(acoshl, KFK, acosh) +GOW2(acoshl, KFK, acosh) #endif #ifdef HAVE_LD80BITS -GOW(acpsl, DFD) +GOW(acosl, DFD) #else -GO2(acosl, KFK, acos) +GOW2(acosl, KFK, acos) #endif GOW(asin, dFd) GOW(asinf, fFf) -GOM(__asinf_finite, fFf) -GOM(__asin_finite, dFd) +GOM(__asinf_finite, fFf) //%noE +GOM(__asin_finite, dFd) //%noE GOW(asinh, dFd) GOW(asinhf, fFf) #ifdef HAVE_LD80BITS GOW(asinhl, DFD) #else -GO2(asinhl, KFK, asinh) +GOW2(asinhl, KFK, asinh) #endif #ifdef HAVE_LD80BITS GOW(asinl, DFD) #else -GO2(asinl, KFK, asin) +GOW2(asinl, KFK, asin) #endif GO(atan, dFd) GOW(atan2, dFdd) GOW(atan2f, fFff) -GOM(__atan2f_finite, fFff) -GOM(__atan2_finite, dFdd) +GOM(__atan2f_finite, fFff) //%noE +GOM(__atan2_finite, dFdd) //%noE // atan2l // Weak GOW(atanf, fFf) GOW(atanh, dFd) @@ -50,31 +52,31 @@ GOW(atanhf, fFf) #ifdef HAVE_LD80BITS GOW(atanhl, DFD) #else -GO2(atanhl, KFK, atanh) +GOW2(atanhl, KFK, atanh) #endif // atanl // Weak GOW(cabs, dFdd) // only 1 arg, but is a double complex GOW(cabsf, fFff) // only 1 arg, but is a float complex // cabsl // Weak -GOS(cacos, pFpV) // Weak, complex -GOM(cacosf, UFV) // Weak -GOS(cacosh, pFpV) // Weak, complex -GOM(cacoshf, UFV) // Weak +GOWS(cacos, pFps) //%% complex +GOWM(cacosf, UFs) //%noE +GOWS(cacosh, pFps) //%% complex +GOWM(cacoshf, UFs) //%noE // cacoshl // Weak // cacosl // Weak GOW(carg, dFdd) // 1arg, double complex GOW(cargf, fFff) // 1arg, float complex // cargl // Weak -GOS(casin, pFpV) // Weak, complex -GOM(casinf, UFV) // Weak -GOS(casinh, pFpV) // Weak, complex -GOM(casinhf, UFV) // Weak +GOWS(casin, pFps) //%% complex +GOWM(casinf, UFs) //%noE +GOWS(casinh, pFps) //%% complex +GOWM(casinhf, UFs) //%noE // casinhl // Weak // casinl // Weak -GOS(catan, pFpV) // Weak, complex -GOM(catanf, UFV) // Weak -GOS(catanh, pFpV) // Weak, complex -GOM(catanhf, UFV) // Weak +GOWS(catan, pFps) //%% complex +GOWM(catanf, UFs) //%noE +GOWS(catanh, pFps) //%% complex +GOWM(catanhf, UFs) //%noE // catanhl // Weak // catanl // Weak GOW(cbrt, dFd) @@ -82,31 +84,31 @@ GOW(cbrtf, fFf) #ifdef HAVE_LD80BITS GOW(cbrtl, DFD) #else -GO2(cbrtl, KFK, cbrt) +GOW2(cbrtl, KFK, cbrt) #endif -GOS(ccos, pFpV) // Weak, return complex -GOM(ccosf, UFV) // Weak, return complex -GOS(ccosh, pFpV) // Weak, return complex -GOM(ccoshf, UFV) // Weak, return complex +GOWS(ccos, pFps) //%% return complex +GOWM(ccosf, UFs) //%noE return complex +GOWS(ccosh, pFps) //%% return complex +GOWM(ccoshf, UFs) //%noE return complex // ccoshl // Weak // ccosl // Weak GOW(ceil, dFd) GOW(ceilf, fFf) // ceill // Weak -GOS(cexp, pFpV) // Weak, return complex -GOM(cexpf, UFV) // Weak, return complex +GOWS(cexp, pFps) //%% return complex +GOWM(cexpf, UFs) //%noE return complex // cexpl // Weak // cimag // Weak // cimagf // Weak // cimagl // Weak -GOS(clog, pFpV) // return a double complex, so ret 4 +GOS(clog, pFps) //%% return a double complex, so ret 4 // clog10 // Weak // __clog10 // clog10f // Weak // __clog10f // clog10l // Weak // __clog10l -GOM(clogf, UFV) // float complex doesn't trigger the ret 4, but return an u64! +GOM(clogf, UFs) //%noE float complex doesn't trigger the ret 4, but returns an u64! // clogl // Weak // conj // Weak // conjf // Weak @@ -118,32 +120,32 @@ GOW(cos, dFd) GOW(cosf, fFf) GOW(cosh, dFd) GOW(coshf, fFf) -GOM(__coshf_finite, fFf) -GOM(__cosh_finite, dFd) +GOM(__coshf_finite, fFf) //%noE +GOM(__cosh_finite, dFd) //%noE // coshl // Weak // cosl // Weak -GOS(cpow, pFpVvvvvV) // Weak, return complex -GOM(cpowf, UFVvvV) // Weak +GOWS(cpow, pFpsvvvvs) //%% return complex +GOWM(cpowf, UFsvvs) //%noE // cpowl // Weak -GOS(cproj, pFpV) // double complex -GOM(cprojf, UFV) +GOS(cproj, pFps) //%% double complex +GOM(cprojf, UFs) //%noE // cprojl // Weak // creal // Weak // crealf // Weak // creall // Weak -GOS(csin, pFpV) // Weak, return complex -GOM(csinf, UFV) // Weak, return complex -GOS(csinh, pFpV) // Weak, return complex -GOM(csinhf, UFV) // Weak, return complex +GOWS(csin, pFps) //%% return complex +GOWM(csinf, UFs) //%noE return complex +GOWS(csinh, pFps) //%% return complex +GOWM(csinhf, UFs) //%noE return complex // csinhl // Weak // csinl // Weak -GOS(csqrt, pFpV) -GOS(csqrtf, UFV) // Weak +GOWS(csqrt, pFps) //%% +GOWM(csqrtf, UFs) //%noE // csqrtl // Weak -GOS(ctan, pFpV) // Weak, return complex -GOM(ctanf, UFV) // Weak, return complex -GOS(ctanh, pFpV) // Weak, return complex -GOM(ctanhf, UFV) // Weak, return complex +GOWS(ctan, pFps) //%% return complex +GOWM(ctanf, UFs) //%noE return complex +GOWS(ctanh, pFps) //%% return complex +GOWM(ctanhf, UFs) //%noE return complex // ctanhl // Weak // ctanl // Weak // __cxa_finalize // Weak @@ -156,13 +158,13 @@ GOW(erfcf, fFf) #ifdef HAVE_LD80BITS GOW(erfcl, DFD) #else -GO2(erfcl, KFK, erfc) +GOW2(erfcl, KFK, erfc) #endif GOW(erff, fFf) #ifdef HAVE_LD80BITS GOW(erfl, DFD) #else -GO2(erfl, KFK, erf) +GOW2(erfl, KFK, erf) #endif GOW(exp, dFd) GOW(exp10, dFd) @@ -172,12 +174,12 @@ GOW(exp10f, fFf) // exp10l // Weak GOW(exp2, dFd) GOW(exp2f, fFf) -GOM(__exp2f_finite, fFf) -GOM(__exp2_finite, dFd) +GOM(__exp2f_finite, fFf) //%noE +GOM(__exp2_finite, dFd) //%noE // exp2l // Weak GOW(expf, fFf) -GOM(__expf_finite, fFf) -GOM(__exp_finite, dFd) +GOM(__expf_finite, fFf) //%noE +GOM(__exp_finite, dFd) //%noE // expl // Weak GOW(expm1, dFd) GOW(expm1f, fFf) @@ -227,7 +229,7 @@ GOW(fmodf, fFff) #ifdef HAVE_LD80BITS GOW(fmodl, DFDD) #else -GO2(fmodl, KFKK, fmod) +GOW2(fmodl, KFKK, fmod) #endif GO(__fpclassify, iFd) GO(__fpclassifyf, iFf) @@ -236,7 +238,7 @@ GOW(frexpf, fFfp) #ifdef HAVE_LD80BITS GOW(frexpl, DFDp) #else -GO2(frexpl, KFKp, frexp) +GOW2(frexpl, KFKp, frexp) #endif // gamma // Weak // gammaf // Weak @@ -246,8 +248,8 @@ GO2(frexpl, KFKp, frexp) // __gmon_start__ // Weak GOW(hypot, dFdd) GOW(hypotf, fFff) -GOM(__hypotf_finite, fFff) -GOM(__hypot_finite, dFdd) +GOM(__hypotf_finite, fFff) //%noE +GOM(__hypot_finite, dFdd) //%noE // hypotl // Weak GOW(ilogb, iFd) GOW(ilogbf, iFf) @@ -276,7 +278,7 @@ GOW(ldexpf, fFfi) #ifdef HAVE_LD80BITS GOW(ldexpl, DFD) #else -GO2(ldexpl, KFK, ldexp) +GOW2(ldexpl, KFK, ldexp) #endif GOW(lgamma, dFd) GOW(lgammaf, fFf) @@ -285,12 +287,12 @@ GOW(lgammaf_r, fFfp) #ifdef HAVE_LD80BITS GOW(lgammal, DFD) #else -GO2(lgammal, KFK, lgamma) +GOW2(lgammal, KFK, lgamma) #endif #ifdef HAVE_LD80BITS GOW(lgammal_r, DFDp) #else -GO2(lgammal_r, KFKp, lgamma_r) +GOW2(lgammal_r, KFKp, lgamma_r) #endif GOW(lgamma_r, dFdp) // __lgamma_r_finite @@ -304,27 +306,27 @@ GOW(llroundf, IFf) GOW(log, dFd) GOW(log10, dFd) GOW(log10f, fFf) -GOM(__log10f_finite, fFf) -GOM(__log10_finite, dFd) +GOM(__log10f_finite, fFf) //%noE +GOM(__log10_finite, dFd) //%noE // log10l // Weak GOW(log1p, dFd) GOW(log1pf, fFf) // log1pl // Weak GOW(log2, dFd) GOW(log2f, fFf) -GOM(__log2f_finite, fFf) -GOM(__log2_finite, dFd) +GOM(__log2f_finite, fFf) //%noE +GOM(__log2_finite, dFd) //%noE // log2l // Weak GOW(logb, dFd) GOW(logbf, fFf) // logbl // Weak GOW(logf, fFf) -GOM(__logf_finite, fFf) -GOM(__log_finite, dFd) +GOM(__logf_finite, fFf) //%noE +GOM(__log_finite, dFd) //%noE #ifdef HAVE_LD80BITS GOW(logl, DFD) #else -GO2(logl, KFK, log) +GOW2(logl, KFK, log) #endif GOW(lrint, iFd) GOW(lrintf, iFf) @@ -357,12 +359,12 @@ GOW(pow10l, DFD) GOW(pow10l, KFK) #endif GOW(powf, fFff) -GOM(__powf_finite, fFff) -GOM(__pow_finite, dFdd) +GOM(__powf_finite, fFff) //%noE +GOM(__pow_finite, dFdd) //%noE #ifdef HAVE_LD80BITS GOW(powl, DFDD) #else -GO2(powl, KFKK, pow) +GOW2(powl, KFKK, pow) #endif GOW(remainder, dFdd) GOW(remainderf, fFff) @@ -402,14 +404,14 @@ GOW(sincosf, vFfpp) GOW(sinf, fFf) GOW(sinh, dFd) GOW(sinhf, fFf) -GOM(__sinhf_finite, fFf) -GOM(__sinh_finite, dFd) +GOM(__sinhf_finite, fFf) //%noE +GOM(__sinh_finite, dFd) //%noE // sinhl // Weak // sinl // Weak GOW(sqrt, dFd) GOW(sqrtf, fFf) -GOM(__sqrtf_finite, fFf) -GOM(__sqrt_finite, dFd) +GOM(__sqrtf_finite, fFf) //%noE +GOM(__sqrt_finite, dFd) //%noE // sqrtl // Weak GO(tan, dFd) GOW(tanf, fFf) @@ -422,7 +424,7 @@ GOW(tgammaf, fFf) #ifdef HAVE_LD80BITS GOW(tgammal, DFD) #else -GO2(tgammal, KFK, tgamma) +GOW2(tgammal, KFK, tgamma) #endif GOW(trunc, dFd) GOW(truncf, fFf) diff --git a/src/wrapped/wrappedlibncurses.c b/src/wrapped/wrappedlibncurses.c index 2d93243c58..f7f6a8a870 100755 --- a/src/wrapped/wrappedlibncurses.c +++ b/src/wrapped/wrappedlibncurses.c @@ -24,19 +24,8 @@ const char* libncursesName = "libncurses.so.5"; static library_t* my_lib = NULL; -// this is a simple copy of libncursesw wrapper. TODO: check if ok - -typedef void* (*pFv_t)(); -typedef int (*iFppp_t)(void*, void*, void*); -typedef int (*iFpiip_t)(void*, int32_t, int32_t, void*); -typedef int (*iFiipV_t)(int, int, void*, ...); - -#define SUPER() \ - GO(initscr, pFv_t) \ - GO(mvwprintw, iFpiip_t) \ - GO(vwprintw, iFppp_t) \ - GO(stdscr, void*) \ - GO(mvprintw, iFiipV_t) +#define ADDED_FUNCTIONS() GO(stdscr, void*) +#include "generated/wrappedlibncursestypes.h" typedef struct libncurses_my_s { // functions @@ -60,18 +49,17 @@ void freeNCursesMy(void* lib) //libncurses_my_t *my = (libncurses_my_t *)lib; } -EXPORT int my_mvwprintw(x86emu_t* emu, void* win, int32_t y, int32_t x, void* fmt, void* b) +EXPORT int my_mvwprintw(x86emu_t* emu, void* win, int y, int x, void* fmt, void* b) { libncurses_my_t *my = (libncurses_my_t*)my_lib->priv.w.p2; char* buf = NULL; #ifndef NOALIGN myStackAlign((const char*)fmt, b, emu->scratch); - iFppp_t f = (iFppp_t)vasprintf; - f(&buf, fmt, emu->scratch); + PREPARE_VALIST; + vasprintf(&buf, fmt, VARARGS); #else - iFppp_t f = (iFppp_t)vasprintf; - f(&buf, fmt, b); + vasprintf(&buf, fmt, b); #endif // pre-bake the fmt/vaarg, because there is no "va_list" version of this function int ret = my->mvwprintw(win, y, x, buf); @@ -85,9 +73,10 @@ EXPORT int my_printw(x86emu_t* emu, void* fmt, void* b) #ifndef NOALIGN myStackAlign((const char*)fmt, b, emu->scratch); - return my->vwprintw(my->stdscr, fmt, emu->scratch); + PREPARE_VALIST; + return my->vw_printw(my->stdscr, fmt, VARARGS); #else - return my->vwprintw(my->stdscr, fmt, b); + return my->vw_printw(my->stdscr, fmt, b); #endif } @@ -98,11 +87,10 @@ EXPORT int my_mvprintw(x86emu_t* emu, int x, int y, void* fmt, void* b) char* buf = NULL; #ifndef NOALIGN myStackAlign((const char*)fmt, b, emu->scratch); - iFppp_t f = (iFppp_t)vasprintf; - f(&buf, fmt, emu->scratch); + PREPARE_VALIST; + vasprintf(&buf, fmt, VARARGS); #else - iFppp_t f = (iFppp_t)vasprintf; - f(&buf, fmt, b); + vasprintf(&buf, fmt, b); #endif // pre-bake the fmt/vaarg, because there is no "va_list" version of this function int ret = my->mvprintw(x, y, buf); @@ -110,6 +98,20 @@ EXPORT int my_mvprintw(x86emu_t* emu, int x, int y, void* fmt, void* b) return ret; } +EXPORT int my_vw_printw(x86emu_t *emu, void* win, void* fmt, void* b) { + libncurses_my_t *my = (libncurses_my_t*)my_lib->priv.w.p2; + + #ifndef NOALIGN + myStackAlign((const char*)fmt, b, emu->scratch); + PREPARE_VALIST; + return my->vw_printw(win, fmt, VARARGS); + #else + // other platform don't need that + return my->vw_printw(win, fmt, b); + #endif +} +EXPORT int my_vwprintw(x86emu_t *emu, void* win, void* fmt, void* b) __attribute__((alias("my_vw_printw"))); + EXPORT void* my_initscr() { libncurses_my_t *my = (libncurses_my_t*)my_lib->priv.w.p2; @@ -127,7 +129,7 @@ EXPORT void* my_initscr() #define CUSTOM_FINI \ freeNCursesMy(lib->priv.w.p2); \ - free(lib->priv.w.p2); \ + free(lib->priv.w.p2); \ my_lib = NULL; #include "wrappedlib_init.h" diff --git a/src/wrapped/wrappedlibncurses6.c b/src/wrapped/wrappedlibncurses6.c index 2db9fbcff6..0fec48c62e 100755 --- a/src/wrapped/wrappedlibncurses6.c +++ b/src/wrapped/wrappedlibncurses6.c @@ -24,17 +24,8 @@ const char* libncurses6Name = "libncurses.so.6"; static library_t* my_lib = NULL; -// this is a simple copy of libncursesw wrapper. TODO: check if ok - -typedef void* (*pFv_t)(); -typedef int (*iFppp_t)(void*, void*, void*); -typedef int (*iFpiip_t)(void*, int32_t, int32_t, void*); - -#define SUPER() \ - GO(initscr, pFv_t) \ - GO(mvwprintw, iFpiip_t) \ - GO(vwprintw, iFppp_t) \ - GO(stdscr, void*) +#define ADDED_FUNCTIONS() GO(stdscr, void*) +#include "generated/wrappedlibncurses6types.h" typedef struct libncurses6_my_s { // functions @@ -58,7 +49,7 @@ void freeNCurses6My(void* lib) //libncurses6_my_t *my = (libncurses6_my_t *)lib; } -EXPORT int my6_mvwprintw(x86emu_t* emu, void* win, int32_t y, int32_t x, void* fmt, void* b) +EXPORT int my6_mvwprintw(x86emu_t* emu, void* win, int y, int x, void* fmt, void* b) { libncurses6_my_t *my = (libncurses6_my_t*)my_lib->priv.w.p2; @@ -66,11 +57,9 @@ EXPORT int my6_mvwprintw(x86emu_t* emu, void* win, int32_t y, int32_t x, void* f #ifndef NOALIGN myStackAlign((const char*)fmt, b, emu->scratch); PREPARE_VALIST; - iFppp_t f = (iFppp_t)vasprintf; - f(&buf, fmt, VARARGS); + vasprintf(&buf, fmt, VARARGS); #else - iFppp_t f = (iFppp_t)vasprintf; - f(&buf, fmt, b); + vasprintf(&buf, fmt, b); #endif // pre-bake the fmt/vaarg, because there is no "va_list" version of this function int ret = my->mvwprintw(win, y, x, buf); @@ -85,11 +74,43 @@ EXPORT int my6_printw(x86emu_t* emu, void* fmt, void* b) #ifndef NOALIGN myStackAlign((const char*)fmt, b, emu->scratch); PREPARE_VALIST; - return my->vwprintw(my->stdscr, fmt, VARARGS); + return my->vw_printw(my->stdscr, fmt, VARARGS); + #else + return my->vw_printw(my->stdscr, fmt, b); + #endif +} + +EXPORT int my6_mvprintw(x86emu_t* emu, int x, int y, void* fmt, void* b) +{ + libncurses6_my_t *my = (libncurses6_my_t*)my_lib->priv.w.p2; + + char* buf = NULL; + #ifndef NOALIGN + myStackAlign((const char*)fmt, b, emu->scratch); + PREPARE_VALIST; + vasprintf(&buf, fmt, VARARGS); + #else + vasprintf(&buf, fmt, b); + #endif + // pre-bake the fmt/vaarg, because there is no "va_list" version of this function + int ret = my->mvprintw(x, y, buf); + free(buf); + return ret; +} + +EXPORT int my6_vw_printw(x86emu_t *emu, void* win, void* fmt, void* b) { + libncurses6_my_t *my = (libncurses6_my_t*)my_lib->priv.w.p2; + + #ifndef NOALIGN + myStackAlign((const char*)fmt, b, emu->scratch); + PREPARE_VALIST; + return my->vw_printw(win, fmt, VARARGS); #else - return my->vwprintw(my->stdscr, fmt, b); + // other platform don't need that + return my->vw_printw(win, fmt, b); #endif } +EXPORT int my6_vwprintw(x86emu_t *emu, void* win, void* fmt, void* b) __attribute__((alias("my6_vw_printw"))); EXPORT void* my6_initscr() { @@ -99,18 +120,16 @@ EXPORT void* my6_initscr() return ret; } - #define CUSTOM_INIT \ - lib->priv.w.p2 = getNCurses6My(lib); \ - my_lib = lib; \ - lib->altmy = strdup("my6_"); \ - lib->priv.w.needed = 1; \ + lib->priv.w.p2 = getNCurses6My(lib); \ + my_lib = lib; \ + lib->priv.w.needed = 1; \ lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \ - lib->priv.w.neededlibs[0] = strdup("libtinfo.so.6"); + lib->priv.w.neededlibs[0] = strdup("libtinfo.so.5"); #define CUSTOM_FINI \ freeNCurses6My(lib->priv.w.p2); \ - free(lib->priv.w.p2); \ + free(lib->priv.w.p2); \ my_lib = NULL; #include "wrappedlib_init.h" diff --git a/src/wrapped/wrappedlibncurses6_private.h b/src/wrapped/wrappedlibncurses6_private.h index fbb49073b4..31f10ba60a 100755 --- a/src/wrapped/wrappedlibncurses6_private.h +++ b/src/wrapped/wrappedlibncurses6_private.h @@ -2,201 +2,411 @@ #error Meh.... #endif -GO(wgetch_events, iFpp) -GO(wgetnstr_events, iFppip) -GO(addch, iFL) +GO(COLOR_PAIR, iFi) +GO(PAIR_NUMBER, iFi) +GO(_traceattr, pFu) +GO(_traceattr2, pFiu) +GO(_tracecchar_t, pFp) +GO(_tracecchar_t2, pFip) +GO(_tracechar, pFi) +GO(_tracechtype, pFu) +GO(_tracechtype2, pFiu) +//GO(_tracef, vFpV) +GO(add_wch, iFp) +GO(add_wchnstr, iFpi) +GO(add_wchstr, iFp) +GO(addch, iFu) GO(addchnstr, iFpi) GO(addchstr, iFp) GO(addnstr, iFpi) +GO(addnwstr, iFpi) GO(addstr, iFp) +GO(addwstr, iFp) +GO(alloc_pair, iFii) +GO(alloc_pair_sp, iFpii) +GO(assume_default_colors, iFii) +GO(assume_default_colors_sp, iFpii) +GO(attr_get, iFppp) +GO(attr_off, iFup) +GO(attr_on, iFup) +GO(attr_set, iFuwp) GO(attroff, iFi) GO(attron, iFi) GO(attrset, iFi) -GO(attr_get, iFppp) -GO(attr_off, iFLp) -GO(attr_on, iFLp) -GO(attr_set, iFLwp) GO(beep, iFv) -GO(bkgd, iFL) -GO(bkgdset, vFL) -GO(border, iFLLLLLLLL) -GO(box, iFpLL) +GO(beep_sp, iFp) +GO(bkgd, iFu) +GO(bkgdset, vFu) +GO(bkgrnd, iFp) +GO(bkgrndset, vFp) +GO(border, iFuuuuuuuu) +GO(border_set, iFpppppppp) +GO(box, iFpuu) +GO(box_set, iFppp) GO(can_change_color, iFv) -GO(chgat, iFiLwp) +GO(can_change_color_sp, iFp) +GO(chgat, iFiuwp) GO(clear, iFv) GO(clearok, iFpi) GO(clrtobot, iFv) GO(clrtoeol, iFv) GO(color_content, iFwppp) +GO(color_content_sp, iFpwppp) GO(color_set, iFwp) -GO(COLOR_PAIR, iFi) GO(copywin, iFppiiiiiii) +GO(curses_trace, uFu) GO(delch, iFv) +GO(deleteln, iFv) GO(delscreen, vFp) GO(delwin, iFp) -GO(deleteln, iFv) GO(derwin, pFpiiii) GO(doupdate, iFv) +GO(doupdate_sp, iFp) GO(dupwin, pFp) GO(echo, iFv) -GO(echochar, iFL) -GO(erase, iFv) +GO(echo_sp, iFp) +GO(echo_wchar, iFp) +GO(echochar, iFu) GO(endwin, iFv) +GO(endwin_sp, iFp) +GO(erase, iFv) +GO(erasewchar, iFp) +GO(exit_curses, vFi) +GO(extended_color_content, iFippp) +GO(extended_color_content_sp, iFpippp) +GO(extended_pair_content, iFipp) +GO(extended_pair_content_sp, iFpipp) +GO(extended_slk_color, iFi) +GO(extended_slk_color_sp, iFpi) GO(filter, vFv) +GO(filter_sp, vFp) +GO(find_pair, iFii) +GO(find_pair_sp, iFpii) GO(flash, iFv) -GO(getbkgd, LFp) +GO(flash_sp, iFp) +GO(free_pair, iFi) +GO(free_pair_sp, iFpi) +GO(get_escdelay, iFv) +GO(get_escdelay_sp, iFp) +GO(get_wch, iFp) +GO(get_wstr, iFp) +GO(getattrs, iFp) +GO(getbegx, iFp) +GO(getbegy, iFp) +GO(getbkgd, uFp) +GO(getbkgrnd, iFp) +GO(getcchar, iFppppp) GO(getch, iFv) +GO(getcurx, iFp) +GO(getcury, iFp) +GO(getmaxx, iFp) +GO(getmaxy, iFp) +GO(getmouse, iFp) +GO(getmouse_sp, iFpp) +GO(getn_wstr, iFpi) GO(getnstr, iFpi) +GO(getparx, iFp) +GO(getpary, iFp) GO(getstr, iFp) GO(getwin, pFp) +GO(getwin_sp, pFpp) GO(has_colors, iFv) -GO(hline, iFLi) +GO(has_colors_sp, iFp) +GO(has_mouse, iFv) +GO(has_mouse_sp, iFp) +GO(hline, iFui) +GO(hline_set, iFpi) GO(immedok, vFpi) -GO(inch, LFv) +GO(in_wch, iFp) +GO(in_wchnstr, iFpi) +GO(in_wchstr, iFp) +GO(inch, uFv) GO(inchnstr, iFpi) GO(inchstr, iFp) -GOM(initscr, pFv) GO(init_color, iFwwww) +GO(init_color_sp, iFpwwww) +GO(init_extended_color, iFiiii) +GO(init_extended_color_sp, iFpiiii) +GO(init_extended_pair, iFiii) +GO(init_extended_pair_sp, iFpiii) GO(init_pair, iFwww) +GO(init_pair_sp, iFpwww) +GOM(initscr, pFv) //%noE GO(innstr, iFpi) -GO(insch, iFL) +GO(innwstr, iFpi) +GO(ins_nwstr, iFpi) +GO(ins_wch, iFp) +GO(ins_wstr, iFp) +GO(insch, iFu) GO(insdelln, iFi) GO(insertln, iFv) GO(insnstr, iFpi) GO(insstr, iFp) GO(instr, iFp) -GO(isendwin, iFv) +GO(inwstr, iFp) +GO(is_cleared, iFp) +GO(is_idcok, iFp) +GO(is_idlok, iFp) +GO(is_immedok, iFp) +GO(is_keypad, iFp) +GO(is_leaveok, iFp) GO(is_linetouched, iFpi) +GO(is_nodelay, iFp) +GO(is_notimeout, iFp) +GO(is_pad, iFp) +GO(is_scrollok, iFp) +GO(is_subwin, iFp) +GO(is_syncok, iFp) +GO(is_term_resized, iFii) +GO(is_term_resized_sp, iFpii) GO(is_wintouched, iFp) +GO(isendwin, iFv) +GO(isendwin_sp, iFp) +GO(key_name, pFi) +GO(killwchar, iFp) GO(leaveok, iFpi) +GO(mcprint, iFpi) +GO(mcprint_sp, iFppi) +GO(mouse_trafo, iFppi) +GO(mouseinterval, iFi) +GO(mouseinterval_sp, iFpi) +GO(mousemask, uFup) +GO(mousemask_sp, uFpup) GO(move, iFii) -GO(mvaddch, iFiiL) +GO(mvadd_wch, iFiip) +GO(mvadd_wchnstr, iFiipi) +GO(mvadd_wchstr, iFiip) +GO(mvaddch, iFiiu) GO(mvaddchnstr, iFiipi) GO(mvaddchstr, iFiip) GO(mvaddnstr, iFiipi) +GO(mvaddnwstr, iFiipi) GO(mvaddstr, iFiip) -GO(mvchgat, iFiiiLwp) +GO(mvaddwstr, iFiip) +GO(mvchgat, iFiiiuwp) GO(mvcur, iFiiii) +GO(mvcur_sp, iFpiiii) GO(mvdelch, iFii) GO(mvderwin, iFpii) +GO(mvget_wch, iFiip) +GO(mvget_wstr, iFiip) GO(mvgetch, iFii) +GO(mvgetn_wstr, iFiipi) GO(mvgetnstr, iFiipi) GO(mvgetstr, iFiip) -GO(mvhline, iFiiLi) -GO(mvinch, LFii) +GO(mvhline, iFiiui) +GO(mvhline_set, iFiipi) +GO(mvin_wch, iFiip) +GO(mvin_wchnstr, iFiipi) +GO(mvin_wchstr, iFiip) +GO(mvinch, uFii) GO(mvinchnstr, iFiipi) GO(mvinchstr, iFiip) GO(mvinnstr, iFiipi) -GO(mvinsch, iFiiL) +GO(mvinnwstr, iFiipi) +GO(mvins_nwstr, iFiipi) +GO(mvins_wch, iFiip) +GO(mvins_wstr, iFiip) +GO(mvinsch, iFiiu) GO(mvinsnstr, iFiipi) GO(mvinsstr, iFiip) GO(mvinstr, iFiip) -//GO(mvprintw, i(i,i,p,...) -//GO(mvscanw, i(i,i,p,...) -GO(mvvline, iFiiLi) -GO(mvwaddch, iFpiiL) +GO(mvinwstr, iFiip) +GOM(mvprintw, iFEiipV) +//GO(mvscanw, iFiipV) +GO(mvvline, iFiiui) +GO(mvvline_set, iFiipi) +GO(mvwadd_wch, iFpiip) +GO(mvwadd_wchnstr, iFpiipi) +GO(mvwadd_wchstr, iFpiip) +GO(mvwaddch, iFpiiu) GO(mvwaddchnstr, iFpiipi) GO(mvwaddchstr, iFpiip) GO(mvwaddnstr, iFpiipi) +GO(mvwaddnwstr, iFpiipi) GO(mvwaddstr, iFpiip) -GO(mvwchgat, iFpiiiLwp) +GO(mvwaddwstr, iFpiip) +GO(mvwchgat, iFpiiiuwp) GO(mvwdelch, iFpii) +GO(mvwget_wch, iFpiip) +GO(mvwget_wstr, iFpiip) GO(mvwgetch, iFpii) +GO(mvwgetn_wstr, iFpiipi) GO(mvwgetnstr, iFpiipi) GO(mvwgetstr, iFpiip) -GO(mvwhline, iFpiiLi) +GO(mvwhline, iFpiiui) +GO(mvwhline_set, iFpiipi) GO(mvwin, iFpii) -GO(mvwinch, LFpii) +GO(mvwin_wch, iFpiip) +GO(mvwin_wchnstr, iFpiipi) +GO(mvwin_wchstr, iFpiip) +GO(mvwinch, uFpii) GO(mvwinchnstr, iFpiipi) GO(mvwinchstr, iFpiip) GO(mvwinnstr, iFpiipi) -GO(mvwinsch, iFpiiL) +GO(mvwinnwstr, iFpiipi) +GO(mvwins_nwstr, iFpiipi) +GO(mvwins_wch, iFpiip) +GO(mvwins_wstr, iFpiip) +GO(mvwinsch, iFpiiu) GO(mvwinsnstr, iFpiipi) GO(mvwinsstr, iFpiip) GO(mvwinstr, iFpiip) +GO(mvwinwstr, iFpiip) GOM(mvwprintw, iFEpiipV) -//GO(mvwscanw, i(p,i,i,p,...) -GO(mvwvline, iFpiiLi) +//GO(mvwscanw, iFpiipV) +GO(mvwvline, iFpiiui) +GO(mvwvline_set, iFpiipi) +GO(new_prescr, pFv) GO(newpad, pFii) +GO(newpad_sp, pFpii) GO(newterm, pFppp) +GO(newterm_sp, pFpppp) GO(newwin, pFiiii) +GO(newwin_sp, pFpiiii) GO(nl, iFv) +GO(nl_sp, iFp) GO(noecho, iFv) +GO(noecho_sp, iFp) +GO(nofilter, vFv) +GO(nofilter_sp, vFp) GO(nonl, iFv) +GO(nonl_sp, iFp) GO(overlay, iFpp) GO(overwrite, iFpp) GO(pair_content, iFwpp) -GO(PAIR_NUMBER, iFi) -GO(pechochar, iFpL) +GO(pair_content_sp, iFpwpp) +GO(pecho_wchar, iFpp) +GO(pechochar, iFpu) GO(pnoutrefresh, iFpiiiiii) GO(prefresh, iFpiiiiii) GOM(printw, iFEpV) GO(putwin, iFpp) GO(redrawwin, iFp) GO(refresh, iFv) -//GOM(ripoffline, int(int,int (*)(WINDOW*,int))) -//GO(scanw, i(p,...) +GO(reset_color_pairs, vFv) +GO(reset_color_pairs_sp, vFp) +GO(resize_term, iFii) +GO(resize_term_sp, iFpii) +GO(resizeterm, iFii) +GO(resizeterm_sp, iFpii) +//GOM(ripoffline, iFi@) +//GOM(ripoffline_sp, iFpi@) +//GO(scanw, iFpV) GO(scr_dump, iFp) GO(scr_init, iFp) +GO(scr_init_sp, iFpp) +GO(scr_restore, iFp) +GO(scr_restore_sp, iFpp) +GO(scr_set, iFp) +GO(scr_set_sp, iFpp) GO(scrl, iFi) GO(scroll, iFp) GO(scrollok, iFpi) -GO(scr_restore, iFp) -GO(scr_set, iFp) -GO(setscrreg, iFii) +GO(set_escdelay, iFi) +GO(set_escdelay_sp, iFpi) GO(set_term, pFp) -GO(slk_attroff, iFL) -GO(slk_attr_off, iFLp) -GO(slk_attron, iFL) -GO(slk_attr_on, iFLp) -GO(slk_attrset, iFL) -GO(slk_attr, LFv) -GO(slk_attr_set, iFLwp) +GO(setcchar, iFppuwp) +GO(setscrreg, iFii) +GO(slk_attr, uFv) +GO(slk_attr_off, iFup) +GO(slk_attr_on, iFup) +GO(slk_attr_set, iFuwp) +GO(slk_attr_set_sp, iFpuwp) +GO(slk_attr_sp, uFp) +GO(slk_attroff, iFu) +GO(slk_attroff_sp, iFpu) +GO(slk_attron, iFu) +GO(slk_attron_sp, iFpu) +GO(slk_attrset, iFu) +GO(slk_attrset_sp, iFpu) GO(slk_clear, iFv) +GO(slk_clear_sp, iFp) GO(slk_color, iFw) +GO(slk_color_sp, iFpw) GO(slk_init, iFi) +GO(slk_init_sp, iFpi) GO(slk_label, pFi) +GO(slk_label_sp, pFpi) GO(slk_noutrefresh, iFv) +GO(slk_noutrefresh_sp, iFp) GO(slk_refresh, iFv) +GO(slk_refresh_sp, iFp) GO(slk_restore, iFv) +GO(slk_restore_sp, iFp) GO(slk_set, iFipi) +GO(slk_set_sp, iFpipi) GO(slk_touch, iFv) -GO(standout, iFv) +GO(slk_touch_sp, iFp) +GO(slk_wset, iFipi) GO(standend, iFv) +GO(standout, iFv) GO(start_color, iFv) +GO(start_color_sp, iFp) GO(subpad, pFpiiii) GO(subwin, pFpiiii) GO(syncok, iFpi) -GO(termattrs, LFv) +GO(term_attrs, uFv) +GO(term_attrs_sp, uFp) +GO(termattrs, uFv) +GO(termattrs_sp, uFp) GO(timeout, vFi) GO(touchline, iFpii) GO(touchwin, iFp) +GO(trace, vFu) +GO(unget_wch, iFi) +GO(unget_wch_sp, iFpi) GO(ungetch, iFi) +GO(ungetch_sp, iFpi) +GO(ungetmouse, iFp) +GO(ungetmouse_sp, iFpp) GO(untouchwin, iFp) +GO(use_default_colors, iFv) +GO(use_default_colors_sp, iFp) +GO(use_legacy_coding, iFi) +GO(use_legacy_coding_sp, iFpi) +//GOM(use_screen, iFp@p) GO(use_tioctl, vFi) -GO(vidattr, iFL) -//GOM(vidputs, iFLP) -GO(vline, iFLi) -GO(vwprintw, iFppp) -GO(vw_printw, iFppp) -GO(vwscanw, iFppp) -GO(vw_scanw, iFppp) -GO(waddch, iFpL) +GO(use_tioctl_sp, vFpi) +//GOM(use_window, iFp@p) +GO(vid_attr, iFuwp) +GO(vid_attr_sp, iFpuwp) +//GOM(vid_puts, iFuwp@) +//GOM(vid_puts_sp, iFpuwp@) +GO(vidattr, iFu) +GO(vidattr_sp, iFpu) +//GOM(vidputs, iFu@) +//GOM(vidputs_sp, iFpu@) +GO(vline, iFui) +GO(vline_set, iFpi) +GOM(vw_printw, iFEppV) +GO(vw_scanw, iFppV) // TODO: check if OK without aligning +GO2(vwprintw, iFEppV, my_vw_printw) +GO(vwscanw, iFppV) // TODO: check if OK without aligning +GO(wadd_wch, iFpp) +GO(wadd_wchnstr, iFppi) +GO(wadd_wchstr, iFpp) +GO(waddch, iFpu) GO(waddchnstr, iFppi) GO(waddchstr, iFpp) GO(waddnstr, iFppi) +GO(waddnwstr, iFppi) GO(waddstr, iFpp) -GO(wattron, iFpi) +GO(waddwstr, iFpp) +GO(wattr_get, iFpppp) +GO(wattr_off, iFpup) +GO(wattr_on, iFpup) +GO(wattr_set, iFpuwp) GO(wattroff, iFpi) +GO(wattron, iFpi) GO(wattrset, iFpi) -GO(wattr_get, iFpppp) -GO(wattr_on, iFpLp) -GO(wattr_off, iFpLp) -GO(wattr_set, iFpLwp) -GO(wbkgd, iFpL) -GO(wbkgdset, vFpL) -GO(wborder, iFpLLLLLLLL) -GO(wchgat, iFpiLwp) +GO(wbkgd, iFpu) +GO(wbkgdset, vFpu) +GO(wbkgrnd, iFpp) +GO(wbkgrndset, vFpp) +GO(wborder, iFpuuuuuuuu) +GO(wborder_set, iFppppppppp) +GO(wchgat, iFpiuwp) GO(wclear, iFp) GO(wclrtobot, iFp) GO(wclrtoeol, iFp) @@ -204,221 +414,63 @@ GO(wcolor_set, iFpwp) GO(wcursyncup, vFp) GO(wdelch, iFp) GO(wdeleteln, iFp) -GO(wechochar, iFpL) +GO(wecho_wchar, iFpp) +GO(wechochar, iFpu) +GO(wenclose, iFpii) GO(werase, iFp) +GO(wget_wch, iFpp) +GO(wget_wstr, iFpp) +GO(wgetbkgrnd, iFpp) GO(wgetch, iFp) +GO(wgetch_events, iFpp) // Experimental (absent on some builds) +GO(wgetdelay, iFp) +GO(wgetn_wstr, iFppi) GO(wgetnstr, iFppi) +GO(wgetnstr_events, iFppip) +GO(wgetparent, pFp) +GO(wgetscrreg, iFppp) GO(wgetstr, iFpp) -GO(whline, iFpLi) -GO(winch, LFp) +GO(whline, iFpui) +GO(whline_set, iFppi) +GO(win_wch, iFpp) +GO(win_wchnstr, iFppi) +GO(win_wchstr, iFpp) +GO(winch, uFp) GO(winchnstr, iFppi) GO(winchstr, iFpp) GO(winnstr, iFppi) -GO(winsch, iFpL) +GO(winnwstr, iFppi) +GO(wins_nwstr, iFppi) +GO(wins_wch, iFpp) +GO(wins_wstr, iFpp) +GO(winsch, iFpu) GO(winsdelln, iFpi) GO(winsertln, iFp) GO(winsnstr, iFppi) GO(winsstr, iFpp) GO(winstr, iFpp) +GO(winwstr, iFpp) +GO(wmouse_trafo, iFpppi) GO(wmove, iFpii) GO(wnoutrefresh, iFp) -//GO(wprintw, i(p,p,...) +//GO(wprintw, iFppV) GO(wredrawln, iFpii) GO(wrefresh, iFp) -//GO(wscanw, i(p,p,...) +GO(wresize, iFpii) +//GO(wscanw, iFppV) GO(wscrl, iFpi) GO(wsetscrreg, iFpii) -GO(wstandout, iFp) GO(wstandend, iFp) +GO(wstandout, iFp) GO(wsyncdown, vFp) GO(wsyncup, vFp) GO(wtouchln, iFpiii) -GO(wvline, iFpLi) -GO(getattrs, iFp) -GO(getcurx, iFp) -GO(getcury, iFp) -GO(getbegx, iFp) -GO(getbegy, iFp) -GO(getmaxx, iFp) -GO(getmaxy, iFp) -GO(getparx, iFp) -GO(getpary, iFp) -GO(is_term_resized, iFii) -GO(alloc_pair, iFii) -GO(assume_default_colors, iFii) -GO(extended_color_content, iFippp) -GO(extended_pair_content, iFipp) -GO(extended_slk_color, iFi) -GO(find_pair, iFii) -GO(free_pair, iFi) -GO(get_escdelay, iFv) -GO(init_extended_color, iFiiii) -GO(init_extended_pair, iFiii) -GO(reset_color_pairs, vFv) -GO(resize_term, iFii) -GO(resizeterm, iFii) -GO(set_escdelay, iFi) -GO(use_default_colors, iFv) -GO(use_legacy_coding, iFi) -//GOM(use_screen, iFpPp) -//GOM(use_window, iFpPp) -GO(wresize, iFpii) -GO(nofilter, vFv) -GO(wgetparent, pFp) -GO(is_cleared, iFp) -GO(is_idcok, iFp) -GO(is_idlok, iFp) -GO(is_immedok, iFp) -GO(is_keypad, iFp) -GO(is_leaveok, iFp) -GO(is_nodelay, iFp) -GO(is_notimeout, iFp) -GO(is_pad, iFp) -GO(is_scrollok, iFp) -GO(is_subwin, iFp) -GO(is_syncok, iFp) -GO(wgetdelay, iFp) -GO(wgetscrreg, iFppp) -GO(add_wch, iFp) -GO(add_wchnstr, iFpi) -GO(add_wchstr, iFp) -GO(addnwstr, iFpi) -GO(addwstr, iFp) -GO(bkgrnd, iFp) -GO(bkgrndset, vFp) -GO(border_set, iFpppppppp) -GO(box_set, iFppp) -GO(echo_wchar, iFp) -GO(erasewchar, iFp) -GO(get_wch, iFp) -GO(get_wstr, iFp) -GO(getbkgrnd, iFp) -GO(getcchar, iFppppp) -GO(getn_wstr, iFpi) -GO(hline_set, iFpi) -GO(in_wch, iFp) -GO(in_wchnstr, iFpi) -GO(in_wchstr, iFp) -GO(innwstr, iFpi) -GO(ins_nwstr, iFpi) -GO(ins_wch, iFp) -GO(ins_wstr, iFp) -GO(inwstr, iFp) -GO(key_name, pFu) -GO(killwchar, iFp) -GO(mvadd_wch, iFiip) -GO(mvadd_wchnstr, iFiipi) -GO(mvadd_wchstr, iFiip) -GO(mvaddnwstr, iFiipi) -GO(mvaddwstr, iFiip) -GO(mvget_wch, iFiip) -GO(mvget_wstr, iFiip) -GO(mvgetn_wstr, iFiipi) -GO(mvhline_set, iFiipi) -GO(mvin_wch, iFiip) -GO(mvin_wchnstr, iFiipi) -GO(mvin_wchstr, iFiip) -GO(mvinnwstr, iFiipi) -GO(mvins_nwstr, iFiipi) -GO(mvins_wch, iFiip) -GO(mvins_wstr, iFiip) -GO(mvinwstr, iFiip) -GO(mvvline_set, iFiipi) -GO(mvwadd_wch, iFpiip) -GO(mvwadd_wchnstr, iFpiipi) -GO(mvwadd_wchstr, iFpiip) -GO(mvwaddnwstr, iFpiipi) -GO(mvwaddwstr, iFpiip) -GO(mvwget_wch, iFpiip) -GO(mvwget_wstr, iFpiip) -GO(mvwgetn_wstr, iFpiipi) -GO(mvwhline_set, iFpiipi) -GO(mvwin_wch, iFpiip) -GO(mvwin_wchnstr, iFpiipi) -GO(mvwin_wchstr, iFpiip) -GO(mvwinnwstr, iFpiipi) -GO(mvwins_nwstr, iFpiipi) -GO(mvwins_wch, iFpiip) -GO(mvwins_wstr, iFpiip) -GO(mvwinwstr, iFpiip) -GO(mvwvline_set, iFpiipi) -GO(pecho_wchar, iFpp) -GO(setcchar, iFppLwp) -GO(slk_wset, iFipi) -GO(term_attrs, LFv) -GO(unget_wch, iFu) -GO(vid_attr, iFLwp) -//GOM(vid_puts, iFLwpP) -GO(vline_set, iFpi) -GO(wadd_wch, iFpp) -GO(wadd_wchnstr, iFppi) -GO(wadd_wchstr, iFpp) -GO(waddnwstr, iFppi) -GO(waddwstr, iFpp) -GO(wbkgrnd, iFpp) -GO(wbkgrndset, vFpp) -GO(wborder_set, iFppppppppp) -GO(wecho_wchar, iFpp) -GO(wget_wch, iFpp) -GO(wget_wstr, iFpp) -GO(wgetbkgrnd, iFpp) -GO(wgetn_wstr, iFppi) -GO(whline_set, iFppi) -GO(win_wch, iFpp) -GO(win_wchnstr, iFppi) -GO(win_wchstr, iFpp) -GO(winnwstr, iFppi) -GO(wins_nwstr, iFppi) -GO(wins_wch, iFpp) -GO(wins_wstr, iFpp) -GO(winwstr, iFpp) GO(wunctrl, pFp) +GO(wunctrl_sp, pFpp) +GO(wvline, iFpui) GO(wvline_set, iFppi) -GO(term_attrs, LFp) -GO(unget_wch, iFpu) -GO(vid_attr, iFpLwp) -//GOM(vid_puts, iFpLwpP) -GO(_nc_viswbuf, pFp) -GO(_nc_viswibuf, pFp) -GO(has_mouse, iFv) -GO(getmouse, iFp) -GO(ungetmouse, iFp) -GO(mousemask, LFLp) -GO(wenclose, iFpii) -GO(mouseinterval, iFi) -GO(wmouse_trafo, iFpppi) -GO(mouse_trafo, iFppi) -GO(has_mouse, iFp) -GO(getmouse, iFpp) -GO(ungetmouse, iFpp) -GO(mousemask, LFpLp) -GO(mouseinterval, iFpi) -GO(mcprint, iFpi) -GO(mcprint, iFppi) -//GO(_tracef, v(p,...) GCC_PRINTFLIKE(1,2) -GO(_traceattr, pFL) -GO(_traceattr2, pFiL) -GO(_tracechar, pFi) -GO(_tracechtype, pFL) -GO(_tracechtype2, pFiL) -GO(_tracecchar_t, pFp) -GO(_tracecchar_t2, pFip) -GO(trace, vFu) -GO(_nc_visbuf, pFp) - -GO(putp, iFp) -GO(setupterm, iFpip) -GO(tigetstr, pFp) -GO(tparm, pFplllllllll) // va_arg or 9 long, depending on how old the .h is -DATA(COLOR_PAIRS, 4) -DATA(COLS, 4) -DATA(COLORS, 4) -DATA(ESCDELAY, 4) -DATA(LINES, 4) -DATA(TABSIZE, 4) -DATA(curscr, 4) -DATA(newscr, 4) -DATA(stdscr, 4) -DATA(ttytype, 4) -DATA(_nc_wacs, 4) +DATA(COLOR_PAIRS, sizeof(void*)) +DATA(COLORS, sizeof(void*)) +DATA(ESCDELAY, sizeof(void*)) +DATA(_nc_wacs, sizeof(void*)) diff --git a/src/wrapped/wrappedlibncurses_private.h b/src/wrapped/wrappedlibncurses_private.h index 21fad78323..880afba500 100755 --- a/src/wrapped/wrappedlibncurses_private.h +++ b/src/wrapped/wrappedlibncurses_private.h @@ -2,201 +2,411 @@ #error Meh.... #endif -GO(wgetch_events, iFpp) -GO(wgetnstr_events, iFppip) -GO(addch, iFL) +GO(COLOR_PAIR, iFi) +GO(PAIR_NUMBER, iFi) +GO(_traceattr, pFu) +GO(_traceattr2, pFiu) +GO(_tracecchar_t, pFp) +GO(_tracecchar_t2, pFip) +GO(_tracechar, pFi) +GO(_tracechtype, pFu) +GO(_tracechtype2, pFiu) +//GO(_tracef, vFpV) +GO(add_wch, iFp) +GO(add_wchnstr, iFpi) +GO(add_wchstr, iFp) +GO(addch, iFu) GO(addchnstr, iFpi) GO(addchstr, iFp) GO(addnstr, iFpi) +GO(addnwstr, iFpi) GO(addstr, iFp) +GO(addwstr, iFp) +GO(alloc_pair, iFii) +GO(alloc_pair_sp, iFpii) +GO(assume_default_colors, iFii) +GO(assume_default_colors_sp, iFpii) +GO(attr_get, iFppp) +GO(attr_off, iFup) +GO(attr_on, iFup) +GO(attr_set, iFuwp) GO(attroff, iFi) GO(attron, iFi) GO(attrset, iFi) -GO(attr_get, iFppp) -GO(attr_off, iFLp) -GO(attr_on, iFLp) -GO(attr_set, iFLwp) GO(beep, iFv) -GO(bkgd, iFL) -GO(bkgdset, vFL) -GO(border, iFLLLLLLLL) -GO(box, iFpLL) +GO(beep_sp, iFp) +GO(bkgd, iFu) +GO(bkgdset, vFu) +GO(bkgrnd, iFp) +GO(bkgrndset, vFp) +GO(border, iFuuuuuuuu) +GO(border_set, iFpppppppp) +GO(box, iFpuu) +GO(box_set, iFppp) GO(can_change_color, iFv) -GO(chgat, iFiLwp) +GO(can_change_color_sp, iFp) +GO(chgat, iFiuwp) GO(clear, iFv) GO(clearok, iFpi) GO(clrtobot, iFv) GO(clrtoeol, iFv) GO(color_content, iFwppp) +GO(color_content_sp, iFpwppp) GO(color_set, iFwp) -GO(COLOR_PAIR, iFi) GO(copywin, iFppiiiiiii) +GO(curses_trace, uFu) GO(delch, iFv) +GO(deleteln, iFv) GO(delscreen, vFp) GO(delwin, iFp) -GO(deleteln, iFv) GO(derwin, pFpiiii) GO(doupdate, iFv) +GO(doupdate_sp, iFp) GO(dupwin, pFp) GO(echo, iFv) -GO(echochar, iFL) -GO(erase, iFv) +GO(echo_sp, iFp) +GO(echo_wchar, iFp) +GO(echochar, iFu) GO(endwin, iFv) +GO(endwin_sp, iFp) +GO(erase, iFv) +GO(erasewchar, iFp) +GO(exit_curses, vFi) +GO(extended_color_content, iFippp) +GO(extended_color_content_sp, iFpippp) +GO(extended_pair_content, iFipp) +GO(extended_pair_content_sp, iFpipp) +GO(extended_slk_color, iFi) +GO(extended_slk_color_sp, iFpi) GO(filter, vFv) +GO(filter_sp, vFp) +GO(find_pair, iFii) +GO(find_pair_sp, iFpii) GO(flash, iFv) -GO(getbkgd, LFp) +GO(flash_sp, iFp) +GO(free_pair, iFi) +GO(free_pair_sp, iFpi) +GO(get_escdelay, iFv) +GO(get_escdelay_sp, iFp) +GO(get_wch, iFp) +GO(get_wstr, iFp) +GO(getattrs, iFp) +GO(getbegx, iFp) +GO(getbegy, iFp) +GO(getbkgd, uFp) +GO(getbkgrnd, iFp) +GO(getcchar, iFppppp) GO(getch, iFv) +GO(getcurx, iFp) +GO(getcury, iFp) +GO(getmaxx, iFp) +GO(getmaxy, iFp) +GO(getmouse, iFp) +GO(getmouse_sp, iFpp) +GO(getn_wstr, iFpi) GO(getnstr, iFpi) +GO(getparx, iFp) +GO(getpary, iFp) GO(getstr, iFp) GO(getwin, pFp) +GO(getwin_sp, pFpp) GO(has_colors, iFv) -GO(hline, iFLi) +GO(has_colors_sp, iFp) +GO(has_mouse, iFv) +GO(has_mouse_sp, iFp) +GO(hline, iFui) +GO(hline_set, iFpi) GO(immedok, vFpi) -GO(inch, LFv) +GO(in_wch, iFp) +GO(in_wchnstr, iFpi) +GO(in_wchstr, iFp) +GO(inch, uFv) GO(inchnstr, iFpi) GO(inchstr, iFp) -GOM(initscr, pFv) GO(init_color, iFwwww) +GO(init_color_sp, iFpwwww) +GO(init_extended_color, iFiiii) +GO(init_extended_color_sp, iFpiiii) +GO(init_extended_pair, iFiii) +GO(init_extended_pair_sp, iFpiii) GO(init_pair, iFwww) +GO(init_pair_sp, iFpwww) +GOM(initscr, pFv) //%noE GO(innstr, iFpi) -GO(insch, iFL) +GO(innwstr, iFpi) +GO(ins_nwstr, iFpi) +GO(ins_wch, iFp) +GO(ins_wstr, iFp) +GO(insch, iFu) GO(insdelln, iFi) GO(insertln, iFv) GO(insnstr, iFpi) GO(insstr, iFp) GO(instr, iFp) -GO(isendwin, iFv) +GO(inwstr, iFp) +GO(is_cleared, iFp) +GO(is_idcok, iFp) +GO(is_idlok, iFp) +GO(is_immedok, iFp) +GO(is_keypad, iFp) +GO(is_leaveok, iFp) GO(is_linetouched, iFpi) +GO(is_nodelay, iFp) +GO(is_notimeout, iFp) +GO(is_pad, iFp) +GO(is_scrollok, iFp) +GO(is_subwin, iFp) +GO(is_syncok, iFp) +GO(is_term_resized, iFii) +GO(is_term_resized_sp, iFpii) GO(is_wintouched, iFp) +GO(isendwin, iFv) +GO(isendwin_sp, iFp) +GO(key_name, pFi) +GO(killwchar, iFp) GO(leaveok, iFpi) +GO(mcprint, iFpi) +GO(mcprint_sp, iFppi) +GO(mouse_trafo, iFppi) +GO(mouseinterval, iFi) +GO(mouseinterval_sp, iFpi) +GO(mousemask, uFup) +GO(mousemask_sp, uFpup) GO(move, iFii) -GO(mvaddch, iFiiL) +GO(mvadd_wch, iFiip) +GO(mvadd_wchnstr, iFiipi) +GO(mvadd_wchstr, iFiip) +GO(mvaddch, iFiiu) GO(mvaddchnstr, iFiipi) GO(mvaddchstr, iFiip) GO(mvaddnstr, iFiipi) +GO(mvaddnwstr, iFiipi) GO(mvaddstr, iFiip) -GO(mvchgat, iFiiiLwp) +GO(mvaddwstr, iFiip) +GO(mvchgat, iFiiiuwp) GO(mvcur, iFiiii) +GO(mvcur_sp, iFpiiii) GO(mvdelch, iFii) GO(mvderwin, iFpii) +GO(mvget_wch, iFiip) +GO(mvget_wstr, iFiip) GO(mvgetch, iFii) +GO(mvgetn_wstr, iFiipi) GO(mvgetnstr, iFiipi) GO(mvgetstr, iFiip) -GO(mvhline, iFiiLi) -GO(mvinch, LFii) +GO(mvhline, iFiiui) +GO(mvhline_set, iFiipi) +GO(mvin_wch, iFiip) +GO(mvin_wchnstr, iFiipi) +GO(mvin_wchstr, iFiip) +GO(mvinch, uFii) GO(mvinchnstr, iFiipi) GO(mvinchstr, iFiip) GO(mvinnstr, iFiipi) -GO(mvinsch, iFiiL) +GO(mvinnwstr, iFiipi) +GO(mvins_nwstr, iFiipi) +GO(mvins_wch, iFiip) +GO(mvins_wstr, iFiip) +GO(mvinsch, iFiiu) GO(mvinsnstr, iFiipi) GO(mvinsstr, iFiip) GO(mvinstr, iFiip) +GO(mvinwstr, iFiip) GOM(mvprintw, iFEiipV) -//GO(mvscanw, i(i,i,p,...) -GO(mvvline, iFiiLi) -GO(mvwaddch, iFpiiL) +//GO(mvscanw, iFiipV) +GO(mvvline, iFiiui) +GO(mvvline_set, iFiipi) +GO(mvwadd_wch, iFpiip) +GO(mvwadd_wchnstr, iFpiipi) +GO(mvwadd_wchstr, iFpiip) +GO(mvwaddch, iFpiiu) GO(mvwaddchnstr, iFpiipi) GO(mvwaddchstr, iFpiip) GO(mvwaddnstr, iFpiipi) +GO(mvwaddnwstr, iFpiipi) GO(mvwaddstr, iFpiip) -GO(mvwchgat, iFpiiiLwp) +GO(mvwaddwstr, iFpiip) +GO(mvwchgat, iFpiiiuwp) GO(mvwdelch, iFpii) +GO(mvwget_wch, iFpiip) +GO(mvwget_wstr, iFpiip) GO(mvwgetch, iFpii) +GO(mvwgetn_wstr, iFpiipi) GO(mvwgetnstr, iFpiipi) GO(mvwgetstr, iFpiip) -GO(mvwhline, iFpiiLi) +GO(mvwhline, iFpiiui) +GO(mvwhline_set, iFpiipi) GO(mvwin, iFpii) -GO(mvwinch, LFpii) +GO(mvwin_wch, iFpiip) +GO(mvwin_wchnstr, iFpiipi) +GO(mvwin_wchstr, iFpiip) +GO(mvwinch, uFpii) GO(mvwinchnstr, iFpiipi) GO(mvwinchstr, iFpiip) GO(mvwinnstr, iFpiipi) -GO(mvwinsch, iFpiiL) +GO(mvwinnwstr, iFpiipi) +GO(mvwins_nwstr, iFpiipi) +GO(mvwins_wch, iFpiip) +GO(mvwins_wstr, iFpiip) +GO(mvwinsch, iFpiiu) GO(mvwinsnstr, iFpiipi) GO(mvwinsstr, iFpiip) GO(mvwinstr, iFpiip) +GO(mvwinwstr, iFpiip) GOM(mvwprintw, iFEpiipV) -//GO(mvwscanw, i(p,i,i,p,...) -GO(mvwvline, iFpiiLi) +//GO(mvwscanw, iFpiipV) +GO(mvwvline, iFpiiui) +GO(mvwvline_set, iFpiipi) +GO(new_prescr, pFv) GO(newpad, pFii) +GO(newpad_sp, pFpii) GO(newterm, pFppp) +GO(newterm_sp, pFpppp) GO(newwin, pFiiii) +GO(newwin_sp, pFpiiii) GO(nl, iFv) +GO(nl_sp, iFp) GO(noecho, iFv) +GO(noecho_sp, iFp) +GO(nofilter, vFv) +GO(nofilter_sp, vFp) GO(nonl, iFv) +GO(nonl_sp, iFp) GO(overlay, iFpp) GO(overwrite, iFpp) GO(pair_content, iFwpp) -GO(PAIR_NUMBER, iFi) -GO(pechochar, iFpL) +GO(pair_content_sp, iFpwpp) +GO(pecho_wchar, iFpp) +GO(pechochar, iFpu) GO(pnoutrefresh, iFpiiiiii) GO(prefresh, iFpiiiiii) GOM(printw, iFEpV) GO(putwin, iFpp) GO(redrawwin, iFp) GO(refresh, iFv) -//GOM(ripoffline, int(int,int (*)(WINDOW*,int))) -//GO(scanw, i(p,...) +GO(reset_color_pairs, vFv) +GO(reset_color_pairs_sp, vFp) +GO(resize_term, iFii) +GO(resize_term_sp, iFpii) +GO(resizeterm, iFii) +GO(resizeterm_sp, iFpii) +//GOM(ripoffline, iFi@) +//GOM(ripoffline_sp, iFpi@) +//GO(scanw, iFpV) GO(scr_dump, iFp) GO(scr_init, iFp) +GO(scr_init_sp, iFpp) +GO(scr_restore, iFp) +GO(scr_restore_sp, iFpp) +GO(scr_set, iFp) +GO(scr_set_sp, iFpp) GO(scrl, iFi) GO(scroll, iFp) GO(scrollok, iFpi) -GO(scr_restore, iFp) -GO(scr_set, iFp) -GO(setscrreg, iFii) +GO(set_escdelay, iFi) +GO(set_escdelay_sp, iFpi) GO(set_term, pFp) -GO(slk_attroff, iFL) -GO(slk_attr_off, iFLp) -GO(slk_attron, iFL) -GO(slk_attr_on, iFLp) -GO(slk_attrset, iFL) -GO(slk_attr, LFv) -GO(slk_attr_set, iFLwp) +GO(setcchar, iFppuwp) +GO(setscrreg, iFii) +GO(slk_attr, uFv) +GO(slk_attr_off, iFup) +GO(slk_attr_on, iFup) +GO(slk_attr_set, iFuwp) +GO(slk_attr_set_sp, iFpuwp) +GO(slk_attr_sp, uFp) +GO(slk_attroff, iFu) +GO(slk_attroff_sp, iFpu) +GO(slk_attron, iFu) +GO(slk_attron_sp, iFpu) +GO(slk_attrset, iFu) +GO(slk_attrset_sp, iFpu) GO(slk_clear, iFv) +GO(slk_clear_sp, iFp) GO(slk_color, iFw) +GO(slk_color_sp, iFpw) GO(slk_init, iFi) +GO(slk_init_sp, iFpi) GO(slk_label, pFi) +GO(slk_label_sp, pFpi) GO(slk_noutrefresh, iFv) +GO(slk_noutrefresh_sp, iFp) GO(slk_refresh, iFv) +GO(slk_refresh_sp, iFp) GO(slk_restore, iFv) +GO(slk_restore_sp, iFp) GO(slk_set, iFipi) +GO(slk_set_sp, iFpipi) GO(slk_touch, iFv) -GO(standout, iFv) +GO(slk_touch_sp, iFp) +GO(slk_wset, iFipi) GO(standend, iFv) +GO(standout, iFv) GO(start_color, iFv) +GO(start_color_sp, iFp) GO(subpad, pFpiiii) GO(subwin, pFpiiii) GO(syncok, iFpi) -GO(termattrs, LFv) +GO(term_attrs, uFv) +GO(term_attrs_sp, uFp) +GO(termattrs, uFv) +GO(termattrs_sp, uFp) GO(timeout, vFi) GO(touchline, iFpii) GO(touchwin, iFp) +GO(trace, vFu) +GO(unget_wch, iFi) +GO(unget_wch_sp, iFpi) GO(ungetch, iFi) +GO(ungetch_sp, iFpi) +GO(ungetmouse, iFp) +GO(ungetmouse_sp, iFpp) GO(untouchwin, iFp) +GO(use_default_colors, iFv) +GO(use_default_colors_sp, iFp) +GO(use_legacy_coding, iFi) +GO(use_legacy_coding_sp, iFpi) +//GOM(use_screen, iFp@p) GO(use_tioctl, vFi) -GO(vidattr, iFL) -//GOM(vidputs, iFLP) -GO(vline, iFLi) -GO(vwprintw, iFppp) -GO(vw_printw, iFppp) -GO(vwscanw, iFppp) -GO(vw_scanw, iFppp) -GO(waddch, iFpL) +GO(use_tioctl_sp, vFpi) +//GOM(use_window, iFp@p) +GO(vid_attr, iFuwp) +GO(vid_attr_sp, iFpuwp) +//GOM(vid_puts, iFuwp@) +//GOM(vid_puts_sp, iFpuwp@) +GO(vidattr, iFu) +GO(vidattr_sp, iFpu) +//GOM(vidputs, iFu@) +//GOM(vidputs_sp, iFpu@) +GO(vline, iFui) +GO(vline_set, iFpi) +GOM(vw_printw, iFEppV) +GO(vw_scanw, iFppV) // TODO: check if OK without aligning +GOM(vwprintw, iFEppV) +GO(vwscanw, iFppV) // TODO: check if OK without aligning +GO(wadd_wch, iFpp) +GO(wadd_wchnstr, iFppi) +GO(wadd_wchstr, iFpp) +GO(waddch, iFpu) GO(waddchnstr, iFppi) GO(waddchstr, iFpp) GO(waddnstr, iFppi) +GO(waddnwstr, iFppi) GO(waddstr, iFpp) -GO(wattron, iFpi) +GO(waddwstr, iFpp) +GO(wattr_get, iFpppp) +GO(wattr_off, iFpup) +GO(wattr_on, iFpup) +GO(wattr_set, iFpuwp) GO(wattroff, iFpi) +GO(wattron, iFpi) GO(wattrset, iFpi) -GO(wattr_get, iFpppp) -GO(wattr_on, iFpLp) -GO(wattr_off, iFpLp) -GO(wattr_set, iFpLwp) -GO(wbkgd, iFpL) -GO(wbkgdset, vFpL) -GO(wborder, iFpLLLLLLLL) -GO(wchgat, iFpiLwp) +GO(wbkgd, iFpu) +GO(wbkgdset, vFpu) +GO(wbkgrnd, iFpp) +GO(wbkgrndset, vFpp) +GO(wborder, iFpuuuuuuuu) +GO(wborder_set, iFppppppppp) +GO(wchgat, iFpiuwp) GO(wclear, iFp) GO(wclrtobot, iFp) GO(wclrtoeol, iFp) @@ -204,207 +414,61 @@ GO(wcolor_set, iFpwp) GO(wcursyncup, vFp) GO(wdelch, iFp) GO(wdeleteln, iFp) -GO(wechochar, iFpL) +GO(wecho_wchar, iFpp) +GO(wechochar, iFpu) +GO(wenclose, iFpii) GO(werase, iFp) +GO(wget_wch, iFpp) +GO(wget_wstr, iFpp) +GO(wgetbkgrnd, iFpp) GO(wgetch, iFp) +GO(wgetch_events, iFpp) // Experimental (absent on some builds) +GO(wgetdelay, iFp) +GO(wgetn_wstr, iFppi) GO(wgetnstr, iFppi) +GO(wgetnstr_events, iFppip) +GO(wgetparent, pFp) +GO(wgetscrreg, iFppp) GO(wgetstr, iFpp) -GO(whline, iFpLi) -GO(winch, LFp) +GO(whline, iFpui) +GO(whline_set, iFppi) +GO(win_wch, iFpp) +GO(win_wchnstr, iFppi) +GO(win_wchstr, iFpp) +GO(winch, uFp) GO(winchnstr, iFppi) GO(winchstr, iFpp) GO(winnstr, iFppi) -GO(winsch, iFpL) +GO(winnwstr, iFppi) +GO(wins_nwstr, iFppi) +GO(wins_wch, iFpp) +GO(wins_wstr, iFpp) +GO(winsch, iFpu) GO(winsdelln, iFpi) GO(winsertln, iFp) GO(winsnstr, iFppi) GO(winsstr, iFpp) GO(winstr, iFpp) +GO(winwstr, iFpp) +GO(wmouse_trafo, iFpppi) GO(wmove, iFpii) GO(wnoutrefresh, iFp) -//GO(wprintw, i(p,p,...) +//GO(wprintw, iFppV) GO(wredrawln, iFpii) GO(wrefresh, iFp) -//GO(wscanw, i(p,p,...) +GO(wresize, iFpii) +//GO(wscanw, iFppV) GO(wscrl, iFpi) GO(wsetscrreg, iFpii) -GO(wstandout, iFp) GO(wstandend, iFp) +GO(wstandout, iFp) GO(wsyncdown, vFp) GO(wsyncup, vFp) GO(wtouchln, iFpiii) -GO(wvline, iFpLi) -GO(getattrs, iFp) -GO(getcurx, iFp) -GO(getcury, iFp) -GO(getbegx, iFp) -GO(getbegy, iFp) -GO(getmaxx, iFp) -GO(getmaxy, iFp) -GO(getparx, iFp) -GO(getpary, iFp) -GO(is_term_resized, iFii) -GO(alloc_pair, iFii) -GO(assume_default_colors, iFii) -GO(extended_color_content, iFippp) -GO(extended_pair_content, iFipp) -GO(extended_slk_color, iFi) -GO(find_pair, iFii) -GO(free_pair, iFi) -GO(get_escdelay, iFv) -GO(init_extended_color, iFiiii) -GO(init_extended_pair, iFiii) -GO(reset_color_pairs, vFv) -GO(resize_term, iFii) -GO(resizeterm, iFii) -GO(set_escdelay, iFi) -GO(use_default_colors, iFv) -GO(use_legacy_coding, iFi) -//GOM(use_screen, iFpPp) -//GOM(use_window, iFpPp) -GO(wresize, iFpii) -GO(nofilter, vFv) -GO(wgetparent, pFp) -GO(is_cleared, iFp) -GO(is_idcok, iFp) -GO(is_idlok, iFp) -GO(is_immedok, iFp) -GO(is_keypad, iFp) -GO(is_leaveok, iFp) -GO(is_nodelay, iFp) -GO(is_notimeout, iFp) -GO(is_pad, iFp) -GO(is_scrollok, iFp) -GO(is_subwin, iFp) -GO(is_syncok, iFp) -GO(wgetdelay, iFp) -GO(wgetscrreg, iFppp) -GO(add_wch, iFp) -GO(add_wchnstr, iFpi) -GO(add_wchstr, iFp) -GO(addnwstr, iFpi) -GO(addwstr, iFp) -GO(bkgrnd, iFp) -GO(bkgrndset, vFp) -GO(border_set, iFpppppppp) -GO(box_set, iFppp) -GO(echo_wchar, iFp) -GO(erasewchar, iFp) -GO(get_wch, iFp) -GO(get_wstr, iFp) -GO(getbkgrnd, iFp) -GO(getcchar, iFppppp) -GO(getn_wstr, iFpi) -GO(hline_set, iFpi) -GO(in_wch, iFp) -GO(in_wchnstr, iFpi) -GO(in_wchstr, iFp) -GO(innwstr, iFpi) -GO(ins_nwstr, iFpi) -GO(ins_wch, iFp) -GO(ins_wstr, iFp) -GO(inwstr, iFp) -GO(key_name, pFu) -GO(killwchar, iFp) -GO(mvadd_wch, iFiip) -GO(mvadd_wchnstr, iFiipi) -GO(mvadd_wchstr, iFiip) -GO(mvaddnwstr, iFiipi) -GO(mvaddwstr, iFiip) -GO(mvget_wch, iFiip) -GO(mvget_wstr, iFiip) -GO(mvgetn_wstr, iFiipi) -GO(mvhline_set, iFiipi) -GO(mvin_wch, iFiip) -GO(mvin_wchnstr, iFiipi) -GO(mvin_wchstr, iFiip) -GO(mvinnwstr, iFiipi) -GO(mvins_nwstr, iFiipi) -GO(mvins_wch, iFiip) -GO(mvins_wstr, iFiip) -GO(mvinwstr, iFiip) -GO(mvvline_set, iFiipi) -GO(mvwadd_wch, iFpiip) -GO(mvwadd_wchnstr, iFpiipi) -GO(mvwadd_wchstr, iFpiip) -GO(mvwaddnwstr, iFpiipi) -GO(mvwaddwstr, iFpiip) -GO(mvwget_wch, iFpiip) -GO(mvwget_wstr, iFpiip) -GO(mvwgetn_wstr, iFpiipi) -GO(mvwhline_set, iFpiipi) -GO(mvwin_wch, iFpiip) -GO(mvwin_wchnstr, iFpiipi) -GO(mvwin_wchstr, iFpiip) -GO(mvwinnwstr, iFpiipi) -GO(mvwins_nwstr, iFpiipi) -GO(mvwins_wch, iFpiip) -GO(mvwins_wstr, iFpiip) -GO(mvwinwstr, iFpiip) -GO(mvwvline_set, iFpiipi) -GO(pecho_wchar, iFpp) -GO(setcchar, iFppLwp) -GO(slk_wset, iFipi) -GO(term_attrs, LFv) -GO(unget_wch, iFu) -GO(vid_attr, iFLwp) -//GOM(vid_puts, iFLwpP) -GO(vline_set, iFpi) -GO(wadd_wch, iFpp) -GO(wadd_wchnstr, iFppi) -GO(wadd_wchstr, iFpp) -GO(waddnwstr, iFppi) -GO(waddwstr, iFpp) -GO(wbkgrnd, iFpp) -GO(wbkgrndset, vFpp) -GO(wborder_set, iFppppppppp) -GO(wecho_wchar, iFpp) -GO(wget_wch, iFpp) -GO(wget_wstr, iFpp) -GO(wgetbkgrnd, iFpp) -GO(wgetn_wstr, iFppi) -GO(whline_set, iFppi) -GO(win_wch, iFpp) -GO(win_wchnstr, iFppi) -GO(win_wchstr, iFpp) -GO(winnwstr, iFppi) -GO(wins_nwstr, iFppi) -GO(wins_wch, iFpp) -GO(wins_wstr, iFpp) -GO(winwstr, iFpp) GO(wunctrl, pFp) +GO(wunctrl_sp, pFpp) +GO(wvline, iFpui) GO(wvline_set, iFppi) -GO(term_attrs, LFp) -GO(unget_wch, iFpu) -GO(vid_attr, iFpLwp) -//GOM(vid_puts, iFpLwpP) -GO(_nc_viswbuf, pFp) -GO(_nc_viswibuf, pFp) -GO(has_mouse, iFv) -GO(getmouse, iFp) -GO(ungetmouse, iFp) -GO(mousemask, LFLp) -GO(wenclose, iFpii) -GO(mouseinterval, iFi) -GO(wmouse_trafo, iFpppi) -GO(mouse_trafo, iFppi) -GO(has_mouse, iFp) -GO(getmouse, iFpp) -GO(ungetmouse, iFpp) -GO(mousemask, LFpLp) -GO(mouseinterval, iFpi) -GO(mcprint, iFpi) -GO(mcprint, iFppi) -//GO(_tracef, v(p,...) GCC_PRINTFLIKE(1,2) -GO(_traceattr, pFL) -GO(_traceattr2, pFiL) -GO(_tracechar, pFi) -GO(_tracechtype, pFL) -GO(_tracechtype2, pFiL) -GO(_tracecchar_t, pFp) -GO(_tracecchar_t2, pFip) -GO(trace, vFu) -GO(_nc_visbuf, pFp) DATA(COLOR_PAIRS, sizeof(void*)) DATA(COLORS, sizeof(void*)) diff --git a/src/wrapped/wrappedlibncursesw.c b/src/wrapped/wrappedlibncursesw.c index d2d565cf64..76fc561bfb 100755 --- a/src/wrapped/wrappedlibncursesw.c +++ b/src/wrapped/wrappedlibncursesw.c @@ -24,15 +24,8 @@ const char* libncurseswName = "libncursesw.so.5"; static library_t* my_lib = NULL; -typedef void* (*pFv_t)(); -typedef int (*iFppp_t)(void*, void*, void*); -typedef int (*iFpiip_t)(void*, int32_t, int32_t, void*); - -#define SUPER() \ - GO(initscr, pFv_t) \ - GO(mvwprintw, iFpiip_t) \ - GO(vwprintw, iFppp_t) \ - GO(stdscr, void*) +#define ADDED_FUNCTIONS() GO(stdscr, void*) +#include "generated/wrappedlibncurseswtypes.h" typedef struct libncursesw_my_s { // functions @@ -56,7 +49,7 @@ void freeNCurseswMy(void* lib) //libncursesw_my_t *my = (libncursesw_my_t *)lib; } -EXPORT int myw_mvwprintw(x86emu_t* emu, void* win, int32_t y, int32_t x, void* fmt, void* b) +EXPORT int myw_mvwprintw(x86emu_t* emu, void* win, int y, int x, void* fmt, void* b) { libncursesw_my_t *my = (libncursesw_my_t*)my_lib->priv.w.p2; @@ -64,11 +57,9 @@ EXPORT int myw_mvwprintw(x86emu_t* emu, void* win, int32_t y, int32_t x, void* f #ifndef NOALIGN myStackAlign((const char*)fmt, b, emu->scratch); PREPARE_VALIST; - iFppp_t f = (iFppp_t)vasprintf; - f(&buf, fmt, VARARGS); + vasprintf(&buf, fmt, VARARGS); #else - iFppp_t f = (iFppp_t)vasprintf; - f(&buf, fmt, b); + vasprintf(&buf, fmt, b); #endif // pre-bake the fmt/vaarg, because there is no "va_list" version of this function int ret = my->mvwprintw(win, y, x, buf); @@ -83,11 +74,43 @@ EXPORT int myw_printw(x86emu_t* emu, void* fmt, void* b) #ifndef NOALIGN myStackAlign((const char*)fmt, b, emu->scratch); PREPARE_VALIST; - return my->vwprintw(my->stdscr, fmt, VARARGS); + return my->vw_printw(my->stdscr, fmt, VARARGS); + #else + return my->vw_printw(my->stdscr, fmt, b); + #endif +} + +EXPORT int myw_mvprintw(x86emu_t* emu, int x, int y, void* fmt, void* b) +{ + libncursesw_my_t *my = (libncursesw_my_t*)my_lib->priv.w.p2; + + char* buf = NULL; + #ifndef NOALIGN + myStackAlign((const char*)fmt, b, emu->scratch); + PREPARE_VALIST; + vasprintf(&buf, fmt, VARARGS); + #else + vasprintf(&buf, fmt, b); + #endif + // pre-bake the fmt/vaarg, because there is no "va_list" version of this function + int ret = my->mvprintw(x, y, buf); + free(buf); + return ret; +} + +EXPORT int myw_vw_printw(x86emu_t *emu, void* win, void* fmt, void* b) { + libncursesw_my_t *my = (libncursesw_my_t*)my_lib->priv.w.p2; + + #ifndef NOALIGN + myStackAlign((const char*)fmt, b, emu->scratch); + PREPARE_VALIST; + return my->vw_printw(win, fmt, VARARGS); #else - return my->vwprintw(my->stdscr, fmt, b); + // other platform don't need that + return my->vw_printw(win, fmt, b); #endif } +EXPORT int myw_vwprintw(x86emu_t *emu, void* win, void* fmt, void* b) __attribute__((alias("myw_vw_printw"))); EXPORT void* myw_initscr() { diff --git a/src/wrapped/wrappedlibncursesw_private.h b/src/wrapped/wrappedlibncursesw_private.h index 7e6f3b9c21..880afba500 100755 --- a/src/wrapped/wrappedlibncursesw_private.h +++ b/src/wrapped/wrappedlibncursesw_private.h @@ -2,201 +2,411 @@ #error Meh.... #endif -GO(wgetch_events, iFpp) -GO(wgetnstr_events, iFppip) -GO(addch, iFL) +GO(COLOR_PAIR, iFi) +GO(PAIR_NUMBER, iFi) +GO(_traceattr, pFu) +GO(_traceattr2, pFiu) +GO(_tracecchar_t, pFp) +GO(_tracecchar_t2, pFip) +GO(_tracechar, pFi) +GO(_tracechtype, pFu) +GO(_tracechtype2, pFiu) +//GO(_tracef, vFpV) +GO(add_wch, iFp) +GO(add_wchnstr, iFpi) +GO(add_wchstr, iFp) +GO(addch, iFu) GO(addchnstr, iFpi) GO(addchstr, iFp) GO(addnstr, iFpi) +GO(addnwstr, iFpi) GO(addstr, iFp) +GO(addwstr, iFp) +GO(alloc_pair, iFii) +GO(alloc_pair_sp, iFpii) +GO(assume_default_colors, iFii) +GO(assume_default_colors_sp, iFpii) +GO(attr_get, iFppp) +GO(attr_off, iFup) +GO(attr_on, iFup) +GO(attr_set, iFuwp) GO(attroff, iFi) GO(attron, iFi) GO(attrset, iFi) -GO(attr_get, iFppp) -GO(attr_off, iFLp) -GO(attr_on, iFLp) -GO(attr_set, iFLwp) GO(beep, iFv) -GO(bkgd, iFL) -GO(bkgdset, vFL) -GO(border, iFLLLLLLLL) -GO(box, iFpLL) +GO(beep_sp, iFp) +GO(bkgd, iFu) +GO(bkgdset, vFu) +GO(bkgrnd, iFp) +GO(bkgrndset, vFp) +GO(border, iFuuuuuuuu) +GO(border_set, iFpppppppp) +GO(box, iFpuu) +GO(box_set, iFppp) GO(can_change_color, iFv) -GO(chgat, iFiLwp) +GO(can_change_color_sp, iFp) +GO(chgat, iFiuwp) GO(clear, iFv) GO(clearok, iFpi) GO(clrtobot, iFv) GO(clrtoeol, iFv) GO(color_content, iFwppp) +GO(color_content_sp, iFpwppp) GO(color_set, iFwp) -GO(COLOR_PAIR, iFi) GO(copywin, iFppiiiiiii) +GO(curses_trace, uFu) GO(delch, iFv) +GO(deleteln, iFv) GO(delscreen, vFp) GO(delwin, iFp) -GO(deleteln, iFv) GO(derwin, pFpiiii) GO(doupdate, iFv) +GO(doupdate_sp, iFp) GO(dupwin, pFp) GO(echo, iFv) -GO(echochar, iFL) -GO(erase, iFv) +GO(echo_sp, iFp) +GO(echo_wchar, iFp) +GO(echochar, iFu) GO(endwin, iFv) +GO(endwin_sp, iFp) +GO(erase, iFv) +GO(erasewchar, iFp) +GO(exit_curses, vFi) +GO(extended_color_content, iFippp) +GO(extended_color_content_sp, iFpippp) +GO(extended_pair_content, iFipp) +GO(extended_pair_content_sp, iFpipp) +GO(extended_slk_color, iFi) +GO(extended_slk_color_sp, iFpi) GO(filter, vFv) +GO(filter_sp, vFp) +GO(find_pair, iFii) +GO(find_pair_sp, iFpii) GO(flash, iFv) -GO(getbkgd, LFp) +GO(flash_sp, iFp) +GO(free_pair, iFi) +GO(free_pair_sp, iFpi) +GO(get_escdelay, iFv) +GO(get_escdelay_sp, iFp) +GO(get_wch, iFp) +GO(get_wstr, iFp) +GO(getattrs, iFp) +GO(getbegx, iFp) +GO(getbegy, iFp) +GO(getbkgd, uFp) +GO(getbkgrnd, iFp) +GO(getcchar, iFppppp) GO(getch, iFv) +GO(getcurx, iFp) +GO(getcury, iFp) +GO(getmaxx, iFp) +GO(getmaxy, iFp) +GO(getmouse, iFp) +GO(getmouse_sp, iFpp) +GO(getn_wstr, iFpi) GO(getnstr, iFpi) +GO(getparx, iFp) +GO(getpary, iFp) GO(getstr, iFp) GO(getwin, pFp) +GO(getwin_sp, pFpp) GO(has_colors, iFv) -GO(hline, iFLi) +GO(has_colors_sp, iFp) +GO(has_mouse, iFv) +GO(has_mouse_sp, iFp) +GO(hline, iFui) +GO(hline_set, iFpi) GO(immedok, vFpi) -GO(inch, LFv) +GO(in_wch, iFp) +GO(in_wchnstr, iFpi) +GO(in_wchstr, iFp) +GO(inch, uFv) GO(inchnstr, iFpi) GO(inchstr, iFp) -GOM(initscr, pFv) GO(init_color, iFwwww) +GO(init_color_sp, iFpwwww) +GO(init_extended_color, iFiiii) +GO(init_extended_color_sp, iFpiiii) +GO(init_extended_pair, iFiii) +GO(init_extended_pair_sp, iFpiii) GO(init_pair, iFwww) +GO(init_pair_sp, iFpwww) +GOM(initscr, pFv) //%noE GO(innstr, iFpi) -GO(insch, iFL) +GO(innwstr, iFpi) +GO(ins_nwstr, iFpi) +GO(ins_wch, iFp) +GO(ins_wstr, iFp) +GO(insch, iFu) GO(insdelln, iFi) GO(insertln, iFv) GO(insnstr, iFpi) GO(insstr, iFp) GO(instr, iFp) -GO(isendwin, iFv) +GO(inwstr, iFp) +GO(is_cleared, iFp) +GO(is_idcok, iFp) +GO(is_idlok, iFp) +GO(is_immedok, iFp) +GO(is_keypad, iFp) +GO(is_leaveok, iFp) GO(is_linetouched, iFpi) +GO(is_nodelay, iFp) +GO(is_notimeout, iFp) +GO(is_pad, iFp) +GO(is_scrollok, iFp) +GO(is_subwin, iFp) +GO(is_syncok, iFp) +GO(is_term_resized, iFii) +GO(is_term_resized_sp, iFpii) GO(is_wintouched, iFp) +GO(isendwin, iFv) +GO(isendwin_sp, iFp) +GO(key_name, pFi) +GO(killwchar, iFp) GO(leaveok, iFpi) +GO(mcprint, iFpi) +GO(mcprint_sp, iFppi) +GO(mouse_trafo, iFppi) +GO(mouseinterval, iFi) +GO(mouseinterval_sp, iFpi) +GO(mousemask, uFup) +GO(mousemask_sp, uFpup) GO(move, iFii) -GO(mvaddch, iFiiL) +GO(mvadd_wch, iFiip) +GO(mvadd_wchnstr, iFiipi) +GO(mvadd_wchstr, iFiip) +GO(mvaddch, iFiiu) GO(mvaddchnstr, iFiipi) GO(mvaddchstr, iFiip) GO(mvaddnstr, iFiipi) +GO(mvaddnwstr, iFiipi) GO(mvaddstr, iFiip) -GO(mvchgat, iFiiiLwp) +GO(mvaddwstr, iFiip) +GO(mvchgat, iFiiiuwp) GO(mvcur, iFiiii) +GO(mvcur_sp, iFpiiii) GO(mvdelch, iFii) GO(mvderwin, iFpii) +GO(mvget_wch, iFiip) +GO(mvget_wstr, iFiip) GO(mvgetch, iFii) +GO(mvgetn_wstr, iFiipi) GO(mvgetnstr, iFiipi) GO(mvgetstr, iFiip) -GO(mvhline, iFiiLi) -GO(mvinch, LFii) +GO(mvhline, iFiiui) +GO(mvhline_set, iFiipi) +GO(mvin_wch, iFiip) +GO(mvin_wchnstr, iFiipi) +GO(mvin_wchstr, iFiip) +GO(mvinch, uFii) GO(mvinchnstr, iFiipi) GO(mvinchstr, iFiip) GO(mvinnstr, iFiipi) -GO(mvinsch, iFiiL) +GO(mvinnwstr, iFiipi) +GO(mvins_nwstr, iFiipi) +GO(mvins_wch, iFiip) +GO(mvins_wstr, iFiip) +GO(mvinsch, iFiiu) GO(mvinsnstr, iFiipi) GO(mvinsstr, iFiip) GO(mvinstr, iFiip) -//GO(mvprintw, i(i,i,p,...) -//GO(mvscanw, i(i,i,p,...) -GO(mvvline, iFiiLi) -GO(mvwaddch, iFpiiL) +GO(mvinwstr, iFiip) +GOM(mvprintw, iFEiipV) +//GO(mvscanw, iFiipV) +GO(mvvline, iFiiui) +GO(mvvline_set, iFiipi) +GO(mvwadd_wch, iFpiip) +GO(mvwadd_wchnstr, iFpiipi) +GO(mvwadd_wchstr, iFpiip) +GO(mvwaddch, iFpiiu) GO(mvwaddchnstr, iFpiipi) GO(mvwaddchstr, iFpiip) GO(mvwaddnstr, iFpiipi) +GO(mvwaddnwstr, iFpiipi) GO(mvwaddstr, iFpiip) -GO(mvwchgat, iFpiiiLwp) +GO(mvwaddwstr, iFpiip) +GO(mvwchgat, iFpiiiuwp) GO(mvwdelch, iFpii) +GO(mvwget_wch, iFpiip) +GO(mvwget_wstr, iFpiip) GO(mvwgetch, iFpii) +GO(mvwgetn_wstr, iFpiipi) GO(mvwgetnstr, iFpiipi) GO(mvwgetstr, iFpiip) -GO(mvwhline, iFpiiLi) +GO(mvwhline, iFpiiui) +GO(mvwhline_set, iFpiipi) GO(mvwin, iFpii) -GO(mvwinch, LFpii) +GO(mvwin_wch, iFpiip) +GO(mvwin_wchnstr, iFpiipi) +GO(mvwin_wchstr, iFpiip) +GO(mvwinch, uFpii) GO(mvwinchnstr, iFpiipi) GO(mvwinchstr, iFpiip) GO(mvwinnstr, iFpiipi) -GO(mvwinsch, iFpiiL) +GO(mvwinnwstr, iFpiipi) +GO(mvwins_nwstr, iFpiipi) +GO(mvwins_wch, iFpiip) +GO(mvwins_wstr, iFpiip) +GO(mvwinsch, iFpiiu) GO(mvwinsnstr, iFpiipi) GO(mvwinsstr, iFpiip) GO(mvwinstr, iFpiip) +GO(mvwinwstr, iFpiip) GOM(mvwprintw, iFEpiipV) -//GO(mvwscanw, i(p,i,i,p,...) -GO(mvwvline, iFpiiLi) +//GO(mvwscanw, iFpiipV) +GO(mvwvline, iFpiiui) +GO(mvwvline_set, iFpiipi) +GO(new_prescr, pFv) GO(newpad, pFii) +GO(newpad_sp, pFpii) GO(newterm, pFppp) +GO(newterm_sp, pFpppp) GO(newwin, pFiiii) +GO(newwin_sp, pFpiiii) GO(nl, iFv) +GO(nl_sp, iFp) GO(noecho, iFv) +GO(noecho_sp, iFp) +GO(nofilter, vFv) +GO(nofilter_sp, vFp) GO(nonl, iFv) +GO(nonl_sp, iFp) GO(overlay, iFpp) GO(overwrite, iFpp) GO(pair_content, iFwpp) -GO(PAIR_NUMBER, iFi) -GO(pechochar, iFpL) +GO(pair_content_sp, iFpwpp) +GO(pecho_wchar, iFpp) +GO(pechochar, iFpu) GO(pnoutrefresh, iFpiiiiii) GO(prefresh, iFpiiiiii) GOM(printw, iFEpV) GO(putwin, iFpp) GO(redrawwin, iFp) GO(refresh, iFv) -//GOM(ripoffline, int(int,int (*)(WINDOW*,int))) -//GO(scanw, i(p,...) +GO(reset_color_pairs, vFv) +GO(reset_color_pairs_sp, vFp) +GO(resize_term, iFii) +GO(resize_term_sp, iFpii) +GO(resizeterm, iFii) +GO(resizeterm_sp, iFpii) +//GOM(ripoffline, iFi@) +//GOM(ripoffline_sp, iFpi@) +//GO(scanw, iFpV) GO(scr_dump, iFp) GO(scr_init, iFp) +GO(scr_init_sp, iFpp) +GO(scr_restore, iFp) +GO(scr_restore_sp, iFpp) +GO(scr_set, iFp) +GO(scr_set_sp, iFpp) GO(scrl, iFi) GO(scroll, iFp) GO(scrollok, iFpi) -GO(scr_restore, iFp) -GO(scr_set, iFp) -GO(setscrreg, iFii) +GO(set_escdelay, iFi) +GO(set_escdelay_sp, iFpi) GO(set_term, pFp) -GO(slk_attroff, iFL) -GO(slk_attr_off, iFLp) -GO(slk_attron, iFL) -GO(slk_attr_on, iFLp) -GO(slk_attrset, iFL) -GO(slk_attr, LFv) -GO(slk_attr_set, iFLwp) +GO(setcchar, iFppuwp) +GO(setscrreg, iFii) +GO(slk_attr, uFv) +GO(slk_attr_off, iFup) +GO(slk_attr_on, iFup) +GO(slk_attr_set, iFuwp) +GO(slk_attr_set_sp, iFpuwp) +GO(slk_attr_sp, uFp) +GO(slk_attroff, iFu) +GO(slk_attroff_sp, iFpu) +GO(slk_attron, iFu) +GO(slk_attron_sp, iFpu) +GO(slk_attrset, iFu) +GO(slk_attrset_sp, iFpu) GO(slk_clear, iFv) +GO(slk_clear_sp, iFp) GO(slk_color, iFw) +GO(slk_color_sp, iFpw) GO(slk_init, iFi) +GO(slk_init_sp, iFpi) GO(slk_label, pFi) +GO(slk_label_sp, pFpi) GO(slk_noutrefresh, iFv) +GO(slk_noutrefresh_sp, iFp) GO(slk_refresh, iFv) +GO(slk_refresh_sp, iFp) GO(slk_restore, iFv) +GO(slk_restore_sp, iFp) GO(slk_set, iFipi) +GO(slk_set_sp, iFpipi) GO(slk_touch, iFv) -GO(standout, iFv) +GO(slk_touch_sp, iFp) +GO(slk_wset, iFipi) GO(standend, iFv) +GO(standout, iFv) GO(start_color, iFv) +GO(start_color_sp, iFp) GO(subpad, pFpiiii) GO(subwin, pFpiiii) GO(syncok, iFpi) -GO(termattrs, LFv) +GO(term_attrs, uFv) +GO(term_attrs_sp, uFp) +GO(termattrs, uFv) +GO(termattrs_sp, uFp) GO(timeout, vFi) GO(touchline, iFpii) GO(touchwin, iFp) +GO(trace, vFu) +GO(unget_wch, iFi) +GO(unget_wch_sp, iFpi) GO(ungetch, iFi) +GO(ungetch_sp, iFpi) +GO(ungetmouse, iFp) +GO(ungetmouse_sp, iFpp) GO(untouchwin, iFp) +GO(use_default_colors, iFv) +GO(use_default_colors_sp, iFp) +GO(use_legacy_coding, iFi) +GO(use_legacy_coding_sp, iFpi) +//GOM(use_screen, iFp@p) GO(use_tioctl, vFi) -GO(vidattr, iFL) -//GOM(vidputs, iFLP) -GO(vline, iFLi) -GO(vwprintw, iFppp) -GO(vw_printw, iFppp) -GO(vwscanw, iFppp) -GO(vw_scanw, iFppp) -GO(waddch, iFpL) +GO(use_tioctl_sp, vFpi) +//GOM(use_window, iFp@p) +GO(vid_attr, iFuwp) +GO(vid_attr_sp, iFpuwp) +//GOM(vid_puts, iFuwp@) +//GOM(vid_puts_sp, iFpuwp@) +GO(vidattr, iFu) +GO(vidattr_sp, iFpu) +//GOM(vidputs, iFu@) +//GOM(vidputs_sp, iFpu@) +GO(vline, iFui) +GO(vline_set, iFpi) +GOM(vw_printw, iFEppV) +GO(vw_scanw, iFppV) // TODO: check if OK without aligning +GOM(vwprintw, iFEppV) +GO(vwscanw, iFppV) // TODO: check if OK without aligning +GO(wadd_wch, iFpp) +GO(wadd_wchnstr, iFppi) +GO(wadd_wchstr, iFpp) +GO(waddch, iFpu) GO(waddchnstr, iFppi) GO(waddchstr, iFpp) GO(waddnstr, iFppi) +GO(waddnwstr, iFppi) GO(waddstr, iFpp) -GO(wattron, iFpi) +GO(waddwstr, iFpp) +GO(wattr_get, iFpppp) +GO(wattr_off, iFpup) +GO(wattr_on, iFpup) +GO(wattr_set, iFpuwp) GO(wattroff, iFpi) +GO(wattron, iFpi) GO(wattrset, iFpi) -GO(wattr_get, iFpppp) -GO(wattr_on, iFpLp) -GO(wattr_off, iFpLp) -GO(wattr_set, iFpLwp) -GO(wbkgd, iFpL) -GO(wbkgdset, vFpL) -GO(wborder, iFpLLLLLLLL) -GO(wchgat, iFpiLwp) +GO(wbkgd, iFpu) +GO(wbkgdset, vFpu) +GO(wbkgrnd, iFpp) +GO(wbkgrndset, vFpp) +GO(wborder, iFpuuuuuuuu) +GO(wborder_set, iFppppppppp) +GO(wchgat, iFpiuwp) GO(wclear, iFp) GO(wclrtobot, iFp) GO(wclrtoeol, iFp) @@ -204,216 +414,63 @@ GO(wcolor_set, iFpwp) GO(wcursyncup, vFp) GO(wdelch, iFp) GO(wdeleteln, iFp) -GO(wechochar, iFpL) +GO(wecho_wchar, iFpp) +GO(wechochar, iFpu) +GO(wenclose, iFpii) GO(werase, iFp) +GO(wget_wch, iFpp) +GO(wget_wstr, iFpp) +GO(wgetbkgrnd, iFpp) GO(wgetch, iFp) +GO(wgetch_events, iFpp) // Experimental (absent on some builds) +GO(wgetdelay, iFp) +GO(wgetn_wstr, iFppi) GO(wgetnstr, iFppi) +GO(wgetnstr_events, iFppip) +GO(wgetparent, pFp) +GO(wgetscrreg, iFppp) GO(wgetstr, iFpp) -GO(whline, iFpLi) -GO(winch, LFp) +GO(whline, iFpui) +GO(whline_set, iFppi) +GO(win_wch, iFpp) +GO(win_wchnstr, iFppi) +GO(win_wchstr, iFpp) +GO(winch, uFp) GO(winchnstr, iFppi) GO(winchstr, iFpp) GO(winnstr, iFppi) -GO(winsch, iFpL) +GO(winnwstr, iFppi) +GO(wins_nwstr, iFppi) +GO(wins_wch, iFpp) +GO(wins_wstr, iFpp) +GO(winsch, iFpu) GO(winsdelln, iFpi) GO(winsertln, iFp) GO(winsnstr, iFppi) GO(winsstr, iFpp) GO(winstr, iFpp) +GO(winwstr, iFpp) +GO(wmouse_trafo, iFpppi) GO(wmove, iFpii) GO(wnoutrefresh, iFp) -//GO(wprintw, i(p,p,...) +//GO(wprintw, iFppV) GO(wredrawln, iFpii) GO(wrefresh, iFp) -//GO(wscanw, i(p,p,...) +GO(wresize, iFpii) +//GO(wscanw, iFppV) GO(wscrl, iFpi) GO(wsetscrreg, iFpii) -GO(wstandout, iFp) GO(wstandend, iFp) +GO(wstandout, iFp) GO(wsyncdown, vFp) GO(wsyncup, vFp) GO(wtouchln, iFpiii) -GO(wvline, iFpLi) -GO(getattrs, iFp) -GO(getcurx, iFp) -GO(getcury, iFp) -GO(getbegx, iFp) -GO(getbegy, iFp) -GO(getmaxx, iFp) -GO(getmaxy, iFp) -GO(getparx, iFp) -GO(getpary, iFp) -GO(is_term_resized, iFii) -GO(alloc_pair, iFii) -GO(assume_default_colors, iFii) -GO(extended_color_content, iFippp) -GO(extended_pair_content, iFipp) -GO(extended_slk_color, iFi) -GO(find_pair, iFii) -GO(free_pair, iFi) -GO(get_escdelay, iFv) -GO(init_extended_color, iFiiii) -GO(init_extended_pair, iFiii) -GO(reset_color_pairs, vFv) -GO(resize_term, iFii) -GO(resizeterm, iFii) -GO(set_escdelay, iFi) -GO(use_default_colors, iFv) -GO(use_legacy_coding, iFi) -//GOM(use_screen, iFpPp) -//GOM(use_window, iFpPp) -GO(wresize, iFpii) -GO(nofilter, vFv) -GO(wgetparent, pFp) -GO(is_cleared, iFp) -GO(is_idcok, iFp) -GO(is_idlok, iFp) -GO(is_immedok, iFp) -GO(is_keypad, iFp) -GO(is_leaveok, iFp) -GO(is_nodelay, iFp) -GO(is_notimeout, iFp) -GO(is_pad, iFp) -GO(is_scrollok, iFp) -GO(is_subwin, iFp) -GO(is_syncok, iFp) -GO(wgetdelay, iFp) -GO(wgetscrreg, iFppp) -GO(add_wch, iFp) -GO(add_wchnstr, iFpi) -GO(add_wchstr, iFp) -GO(addnwstr, iFpi) -GO(addwstr, iFp) -GO(bkgrnd, iFp) -GO(bkgrndset, vFp) -GO(border_set, iFpppppppp) -GO(box_set, iFppp) -GO(echo_wchar, iFp) -GO(erasewchar, iFp) -GO(get_wch, iFp) -GO(get_wstr, iFp) -GO(getbkgrnd, iFp) -GO(getcchar, iFppppp) -GO(getn_wstr, iFpi) -GO(hline_set, iFpi) -GO(in_wch, iFp) -GO(in_wchnstr, iFpi) -GO(in_wchstr, iFp) -GO(innwstr, iFpi) -GO(ins_nwstr, iFpi) -GO(ins_wch, iFp) -GO(ins_wstr, iFp) -GO(inwstr, iFp) -GO(key_name, pFu) -GO(killwchar, iFp) -GO(mvadd_wch, iFiip) -GO(mvadd_wchnstr, iFiipi) -GO(mvadd_wchstr, iFiip) -GO(mvaddnwstr, iFiipi) -GO(mvaddwstr, iFiip) -GO(mvget_wch, iFiip) -GO(mvget_wstr, iFiip) -GO(mvgetn_wstr, iFiipi) -GO(mvhline_set, iFiipi) -GO(mvin_wch, iFiip) -GO(mvin_wchnstr, iFiipi) -GO(mvin_wchstr, iFiip) -GO(mvinnwstr, iFiipi) -GO(mvins_nwstr, iFiipi) -GO(mvins_wch, iFiip) -GO(mvins_wstr, iFiip) -GO(mvinwstr, iFiip) -GO(mvvline_set, iFiipi) -GO(mvwadd_wch, iFpiip) -GO(mvwadd_wchnstr, iFpiipi) -GO(mvwadd_wchstr, iFpiip) -GO(mvwaddnwstr, iFpiipi) -GO(mvwaddwstr, iFpiip) -GO(mvwget_wch, iFpiip) -GO(mvwget_wstr, iFpiip) -GO(mvwgetn_wstr, iFpiipi) -GO(mvwhline_set, iFpiipi) -GO(mvwin_wch, iFpiip) -GO(mvwin_wchnstr, iFpiipi) -GO(mvwin_wchstr, iFpiip) -GO(mvwinnwstr, iFpiipi) -GO(mvwins_nwstr, iFpiipi) -GO(mvwins_wch, iFpiip) -GO(mvwins_wstr, iFpiip) -GO(mvwinwstr, iFpiip) -GO(mvwvline_set, iFpiipi) -GO(pecho_wchar, iFpp) -GO(setcchar, iFppLwp) -GO(slk_wset, iFipi) -GO(term_attrs, LFv) -GO(unget_wch, iFu) -GO(vid_attr, iFLwp) -//GOM(vid_puts, iFLwpP) -GO(vline_set, iFpi) -GO(wadd_wch, iFpp) -GO(wadd_wchnstr, iFppi) -GO(wadd_wchstr, iFpp) -GO(waddnwstr, iFppi) -GO(waddwstr, iFpp) -GO(wbkgrnd, iFpp) -GO(wbkgrndset, vFpp) -GO(wborder_set, iFppppppppp) -GO(wecho_wchar, iFpp) -GO(wget_wch, iFpp) -GO(wget_wstr, iFpp) -GO(wgetbkgrnd, iFpp) -GO(wgetn_wstr, iFppi) -GO(whline_set, iFppi) -GO(win_wch, iFpp) -GO(win_wchnstr, iFppi) -GO(win_wchstr, iFpp) -GO(winnwstr, iFppi) -GO(wins_nwstr, iFppi) -GO(wins_wch, iFpp) -GO(wins_wstr, iFpp) -GO(winwstr, iFpp) GO(wunctrl, pFp) +GO(wunctrl_sp, pFpp) +GO(wvline, iFpui) GO(wvline_set, iFppi) -GO(term_attrs, LFp) -GO(unget_wch, iFpu) -GO(vid_attr, iFpLwp) -//GOM(vid_puts, iFpLwpP) -GO(_nc_viswbuf, pFp) -GO(_nc_viswibuf, pFp) -GO(has_mouse, iFv) -GO(getmouse, iFp) -GO(ungetmouse, iFp) -GO(mousemask, LFLp) -GO(wenclose, iFpii) -GO(mouseinterval, iFi) -GO(wmouse_trafo, iFpppi) -GO(mouse_trafo, iFppi) -GO(has_mouse, iFp) -GO(getmouse, iFpp) -GO(ungetmouse, iFpp) -GO(mousemask, LFpLp) -GO(mouseinterval, iFpi) -GO(mcprint, iFpi) -GO(mcprint, iFppi) -//GO(_tracef, v(p,...) GCC_PRINTFLIKE(1,2) -GO(_traceattr, pFL) -GO(_traceattr2, pFiL) -GO(_tracechar, pFi) -GO(_tracechtype, pFL) -GO(_tracechtype2, pFiL) -GO(_tracecchar_t, pFp) -GO(_tracecchar_t2, pFip) -GO(trace, vFu) -GO(_nc_visbuf, pFp) -DATA(COLOR_PAIRS, 4) -DATA(COLS, 4) -DATA(COLORS, 4) -DATA(ESCDELAY, 4) -DATA(LINES, 4) -DATA(TABSIZE, 4) -DATA(curscr, 4) -DATA(newscr, 4) -DATA(stdscr, 4) -DATA(ttytype, 4) -DATA(_nc_wacs, 4) +DATA(COLOR_PAIRS, sizeof(void*)) +DATA(COLORS, sizeof(void*)) +DATA(ESCDELAY, sizeof(void*)) +DATA(_nc_wacs, sizeof(void*)) diff --git a/src/wrapped/wrappedlibnm_private.h b/src/wrapped/wrappedlibnm_private.h index 025822df68..8a4c824d60 100755 --- a/src/wrapped/wrappedlibnm_private.h +++ b/src/wrapped/wrappedlibnm_private.h @@ -648,13 +648,11 @@ GO(nm_object_get_type, iFv) //GO(nm_setting_connection_add_permission, //GO(nm_setting_connection_add_secondary, //GO(nm_setting_connection_autoconnect_slaves_get_type, -//GO(nm_setting_connection_autoconnect_slaves_get_type, //GO(nm_setting_connection_get_auth_retries, //GO(nm_setting_connection_get_autoconnect, //GO(nm_setting_connection_get_autoconnect_priority, //GO(nm_setting_connection_get_autoconnect_retries, //GO(nm_setting_connection_get_autoconnect_slaves, -//GO(nm_setting_connection_get_autoconnect_slaves, //GO(nm_setting_connection_get_connection_type, //GO(nm_setting_connection_get_gateway_ping_timeout, //GO(nm_setting_connection_get_id, @@ -663,8 +661,6 @@ GO(nm_object_get_type, iFv) //GO(nm_setting_connection_get_llmnr, //GO(nm_setting_connection_get_master, //GO(nm_setting_connection_get_mdns, -//GO(nm_setting_connection_get_mdns, -//GO(nm_setting_connection_get_metered, //GO(nm_setting_connection_get_metered, //GO(nm_setting_connection_get_multi_connect, //GO(nm_setting_connection_get_num_permissions, @@ -682,7 +678,6 @@ GO(nm_object_get_type, iFv) //GO(nm_setting_connection_lldp_get_type, //GO(nm_setting_connection_llmnr_get_type, //GO(nm_setting_connection_mdns_get_type, -//GO(nm_setting_connection_mdns_get_type, //GO(nm_setting_connection_new, //GO(nm_setting_connection_permissions_user_allowed, //GO(nm_setting_connection_remove_permission, @@ -783,7 +778,6 @@ GO(nm_object_get_type, iFv) //GO(nm_setting_ip_config_get_dns, //GO(nm_setting_ip_config_get_dns_option, //GO(nm_setting_ip_config_get_dns_priority, -//GO(nm_setting_ip_config_get_dns_priority, //GO(nm_setting_ip_config_get_dns_search, //GO(nm_setting_ip_config_get_gateway, //GO(nm_setting_ip_config_get_ignore_auto_dns, @@ -1085,15 +1079,12 @@ GO(nm_object_get_type, iFv) //GO(nm_setting_wired_get_type, //GO(nm_setting_wired_get_valid_s390_options, //GO(nm_setting_wired_get_wake_on_lan, -//GO(nm_setting_wired_get_wake_on_lan, -//GO(nm_setting_wired_get_wake_on_lan_password, //GO(nm_setting_wired_get_wake_on_lan_password, //GO(nm_setting_wired_new, //GO(nm_setting_wired_remove_mac_blacklist_item, //GO(nm_setting_wired_remove_mac_blacklist_item_by_value, //GO(nm_setting_wired_remove_s390_option, //GO(nm_setting_wired_wake_on_lan_get_type, -//GO(nm_setting_wired_wake_on_lan_get_type, //GO(nm_setting_wireless_add_mac_blacklist_item, //GO(nm_setting_wireless_add_seen_bssid, //GO(nm_setting_wireless_ap_security_compatible, @@ -1241,10 +1232,8 @@ GO(nm_setting_wireless_security_set_wep_key, vFpup) //GO(nm_utils_bond_mode_string_to_int, //GO(nm_utils_check_virtual_device_compatibility, //GO(nm_utils_enum_from_str, -//GO(nm_utils_enum_from_str, //GO(nm_utils_enum_get_values, //GO(nm_utils_enum_to_str, -//GO(nm_utils_enum_to_str, //GO(nm_utils_escape_ssid, //GO(nm_utils_file_is_certificate, //GO(nm_utils_file_is_pkcs12, @@ -1300,8 +1289,6 @@ GO(nm_setting_wireless_security_set_wep_key, vFpup) //GO(nm_utils_version, //GO(nm_utils_wep_key_valid, //GO(nm_utils_wifi_2ghz_freqs, -//GO(nm_utils_wifi_2ghz_freqs, -//GO(nm_utils_wifi_5ghz_freqs, //GO(nm_utils_wifi_5ghz_freqs, //GO(nm_utils_wifi_channel_to_freq, //GO(nm_utils_wifi_find_next_channel, diff --git a/src/wrapped/wrappedlibpthread_private.h b/src/wrapped/wrappedlibpthread_private.h index 7e3ae770c3..ce2e3f0267 100755 --- a/src/wrapped/wrappedlibpthread_private.h +++ b/src/wrapped/wrappedlibpthread_private.h @@ -80,7 +80,6 @@ GOM(pthread_cond_wait, iFEpp) GOM(pthread_create, iFEpppp) GO(pthread_detach, iFu) GO(pthread_equal, iFuu) -//GOM(pthread_exit, vFEp) GO(pthread_exit, vFp) GOM(pthread_getaffinity_np, iFEpup) GO(pthread_getattr_np, iFup) @@ -90,7 +89,7 @@ GO(pthread_getschedparam, iFupp) GO(__pthread_getspecific, pFu) GO(pthread_getspecific, pFu) GOM(pthread_getname_np, iFEppu) //not present on Pandora -GOM(__pthread_initialize, vFv) // doesn't exist anymore... +GOM(__pthread_initialize, vFv) //%noE doesn't exist anymore... // __pthread_initialize_minimal GO(pthread_join, iFup) GOM(__pthread_key_create, iFEpp) @@ -130,19 +129,19 @@ GO(__pthread_mutex_unlock, iFp) GO(pthread_mutex_unlock, iFp) #else // pthread_mutex_consistent_np -GOM(__pthread_mutex_destroy, iFp) -GOM(pthread_mutex_destroy, iFp) +GOM(__pthread_mutex_destroy, iFp) //%noE +GOM(pthread_mutex_destroy, iFp) //%noE // pthread_mutex_getprioceiling -GOM(__pthread_mutex_init, iFpp) -GOM(pthread_mutex_init, iFpp) -GOM(__pthread_mutex_lock, iFp) -GOM(pthread_mutex_lock, iFp) +GOM(__pthread_mutex_init, iFpp) //%noE +GOM(pthread_mutex_init, iFpp) //%noE +GOM(__pthread_mutex_lock, iFp) //%noE +GOM(pthread_mutex_lock, iFp) //%noE // pthread_mutex_setprioceiling -GOM(pthread_mutex_timedlock, iFpp) -GOM(__pthread_mutex_trylock, iFp) -GOM(pthread_mutex_trylock, iFp) -GOM(__pthread_mutex_unlock, iFp) -GOM(pthread_mutex_unlock, iFp) +GOM(pthread_mutex_timedlock, iFpp) //%noE +GOM(__pthread_mutex_trylock, iFp) //%noE +GOM(pthread_mutex_trylock, iFp) //%noE +GOM(__pthread_mutex_unlock, iFp) //%noE +GOM(pthread_mutex_unlock, iFp) //%noE #endif GOM(pthread_once, iFEpp) GOM(__pthread_once, iFEpp) @@ -210,4 +209,4 @@ GO(sem_wait, iFp) // system // __vfork -GOM(pthread_mutexattr_setkind_np, iFEpi) // deprecated \ No newline at end of file +GOM(pthread_mutexattr_setkind_np, iFEpi) // deprecated diff --git a/src/wrapped/wrappedlibssl_private.h b/src/wrapped/wrappedlibssl_private.h index a329a1568d..3e9ed64e59 100755 --- a/src/wrapped/wrappedlibssl_private.h +++ b/src/wrapped/wrappedlibssl_private.h @@ -295,7 +295,7 @@ GOM(SSL_CTX_sess_set_new_cb, vFEpp) //GO(SSL_CTX_set_alpn_protos, //GO(SSL_CTX_set_alpn_select_cb, //GO(SSL_CTX_set_cert_cb, -//GO(SSL_CTX_set_cert_store, +GO(SSL_CTX_set_cert_store, vFpp) //GO(SSL_CTX_set_cert_verify_callback, GO(SSL_CTX_set_cipher_list, iFpp) GO(SSL_CTX_set_client_CA_list, vFpp) @@ -471,7 +471,6 @@ GO(SSL_set_accept_state, vFp) GO(SSL_set_bio, vFppp) //GO(SSL_set_cert_cb, //GO(ssl_set_cert_masks, -GO(SSL_CTX_set_cert_store, vFpp) GO(SSL_set_cipher_list, iFpp) GO(SSL_set_client_CA_list, vFpp) //GO(ssl_set_client_disabled, @@ -590,4 +589,4 @@ GO(TLSv1_client_method, pFv) GO(TLSv1_method, pFv) GO(verify_callback, iFip) -GO(TLSv1_server_method, pFv) // not always present in lib \ No newline at end of file +GO(TLSv1_server_method, pFv) // not always present in lib diff --git a/src/wrapped/wrappedlibtiff_private.h b/src/wrapped/wrappedlibtiff_private.h index 1f636770e4..242df71f3b 100755 --- a/src/wrapped/wrappedlibtiff_private.h +++ b/src/wrapped/wrappedlibtiff_private.h @@ -22,7 +22,7 @@ //GO(TIFFCIELabToXYZ, //GO(TIFFCleanup, //GO(TIFFClientdata, -GOM(TIFFClientOpen, pFpppppppppp) // No emu parameter +GOM(TIFFClientOpen, pFpppppppppp) //%noE GO(TIFFClose, vFp) //GO(TIFFComputeStrip, //GO(TIFFComputeTile, diff --git a/src/wrapped/wrappedlibvorbis_private.h b/src/wrapped/wrappedlibvorbis_private.h index a1b615eea6..4ad5cd298a 100755 --- a/src/wrapped/wrappedlibvorbis_private.h +++ b/src/wrapped/wrappedlibvorbis_private.h @@ -137,7 +137,7 @@ GOM(vorbis_synthesis_lapout, iFEpp) GOM(vorbis_synthesis_pcmout, iFEpp) GOM(vorbis_synthesis_read, iFEpi) GOM(vorbis_synthesis_restart, iFEp) -GOM(vorbis_synthesis_trackonly, iFpp) +GOM(vorbis_synthesis_trackonly, iFEpp) #endif GO(vorbis_version_string, pFv) #ifdef NOALIGN diff --git a/src/wrapped/wrappedlibx11_private.h b/src/wrapped/wrappedlibx11_private.h index 1ba79aa8f2..59ff0812fc 100755 --- a/src/wrapped/wrappedlibx11_private.h +++ b/src/wrapped/wrappedlibx11_private.h @@ -263,7 +263,7 @@ GO(XDeleteContext, iFpui) //GO(XDeleteModifiermapEntry GO(XDeleteProperty, iFppp) // _XDeq -GO(_XDeqAsyncHandler, vFEpp) +GOM(_XDeqAsyncHandler, vFEpp) GO(XDestroyIC, vFu) GOM(XDestroyImage, iFEp) //need to unbridge //GO(XDestroyOC diff --git a/src/wrapped/wrappedlibxcb_private.h b/src/wrapped/wrappedlibxcb_private.h index 5b14333230..3ec4ced089 100755 --- a/src/wrapped/wrappedlibxcb_private.h +++ b/src/wrapped/wrappedlibxcb_private.h @@ -2,10 +2,10 @@ #error meh! #endif -//%S x my_xcb_cookie_t -//%S X my_xcb_XXX_iterator_t +//%S x my_xcb_cookie_t u +//%S X my_xcb_XXX_iterator_t pii -GOS(xcb_alloc_color, pFEppuWWW) //%x +GOS(xcb_alloc_color, xFEpuWWW) //GO(xcb_alloc_color_cells, //GO(xcb_alloc_color_cells_masks, //GO(xcb_alloc_color_cells_masks_end, @@ -35,7 +35,7 @@ GO(xcb_alloc_color_reply, pFpup) //GO(xcb_arc_next, //GO(xcb_atom_end, //GO(xcb_atom_next, -GOS(xcb_bell, pFEppC) //%x +GOS(xcb_bell, xFEpC) //GO(xcb_bell_checked, //GO(xcb_big_requests_enable, //GO(xcb_big_requests_enable_reply, @@ -47,10 +47,10 @@ DATA(xcb_big_requests_id, 4) //GO(xcb_button_next, //GO(xcb_change_active_pointer_grab, //GO(xcb_change_active_pointer_grab_checked, -GOS(xcb_change_gc, pFEppuup) //%x +GOS(xcb_change_gc, xFEpuup) //GO(xcb_change_gc_aux, //GO(xcb_change_gc_aux_checked, -GOS(xcb_change_gc_checked, pFEppuup) //%x +GOS(xcb_change_gc_checked, xFEpuup) //GO(xcb_change_gc_sizeof, //GO(xcb_change_gc_value_list, //GO(xcb_change_gc_value_list_serialize, @@ -62,7 +62,7 @@ GOS(xcb_change_gc_checked, pFEppuup) //%x //GO(xcb_change_hosts_address_length, //GO(xcb_change_hosts_checked, //GO(xcb_change_hosts_sizeof, -GOS(xcb_change_keyboard_control, pFEppup) //%x +GOS(xcb_change_keyboard_control, xFEpup) //GO(xcb_change_keyboard_control_aux, //GO(xcb_change_keyboard_control_aux_checked, //GO(xcb_change_keyboard_control_checked, @@ -79,18 +79,18 @@ GOS(xcb_change_keyboard_control, pFEppup) //%x //GO(xcb_change_keyboard_mapping_sizeof, //GO(xcb_change_pointer_control, //GO(xcb_change_pointer_control_checked, -GOS(xcb_change_property, pFEppCuuuCup) //%x -GOS(xcb_change_property_checked, pFEppCuuuCup) //%x +GOS(xcb_change_property, xFEpCuuuCup) +GOS(xcb_change_property_checked, xFEpCuuuCup) //GO(xcb_change_property_data, //GO(xcb_change_property_data_end, //GO(xcb_change_property_data_length, //GO(xcb_change_property_sizeof, //GO(xcb_change_save_set, //GO(xcb_change_save_set_checked, -GOS(xcb_change_window_attributes, pFEppuup) //%x +GOS(xcb_change_window_attributes, xFEpuup) //GO(xcb_change_window_attributes_aux, //GO(xcb_change_window_attributes_aux_checked, -GOS(xcb_change_window_attributes_checked, pFEppuup) //%x +GOS(xcb_change_window_attributes_checked, xFEpuup) //GO(xcb_change_window_attributes_sizeof, //GO(xcb_change_window_attributes_value_list, //GO(xcb_change_window_attributes_value_list_serialize, @@ -102,17 +102,17 @@ GOS(xcb_change_window_attributes_checked, pFEppuup) //%x //GO(xcb_charinfo_next, //GO(xcb_circulate_window, //GO(xcb_circulate_window_checked, -GOS(xcb_clear_area, pFEppCuwwWW) //%x +GOS(xcb_clear_area, xFEpCuwwWW) //GO(xcb_clear_area_checked, //GO(xcb_client_message_data_end, //GO(xcb_client_message_data_next, -GOS(xcb_close_font, pFEppu) //%x -GOS(xcb_close_font_checked, pFEppu) //%x +GOS(xcb_close_font, xFEpu) +GOS(xcb_close_font_checked, xFEpu) //GO(xcb_coloritem_end, //GO(xcb_coloritem_next, //GO(xcb_colormap_end, //GO(xcb_colormap_next, -GOS(xcb_configure_window, pFEppuWp) //%x +GOS(xcb_configure_window, xFEpuWp) //GO(xcb_configure_window_aux, //GO(xcb_configure_window_aux_checked, //GO(xcb_configure_window_checked, @@ -125,9 +125,9 @@ GO(xcb_connect, pFpp) GO(xcb_connection_has_error, iFp) //GO(xcb_connect_to_display_with_auth_info, //GO(xcb_connect_to_fd, -GOS(xcb_convert_selection, pFEppuuuuu) //%x +GOS(xcb_convert_selection, xFEpuuuuu) //GO(xcb_convert_selection_checked, -GOS(xcb_copy_area, pFEppuuuwwwwWW) //%x +GOS(xcb_copy_area, xFEpuuuwwwwWW) //GO(xcb_copy_area_checked, //GO(xcb_copy_colormap_and_free, //GO(xcb_copy_colormap_and_free_checked, @@ -135,27 +135,27 @@ GOS(xcb_copy_area, pFEppuuuwwwwWW) //%x //GO(xcb_copy_gc_checked, //GO(xcb_copy_plane, //GO(xcb_copy_plane_checked, -GOS(xcb_create_colormap, pFEppCppp) //%x +GOS(xcb_create_colormap, xFEpCppp) //GO(xcb_create_colormap_checked, -GOS(xcb_create_cursor, pFEppuuuWWWWWWWW) //%x +GOS(xcb_create_cursor, xFEpuuuWWWWWWWW) //GO(xcb_create_cursor_checked, -GOS(xcb_create_gc, pFEppuuup) //%x +GOS(xcb_create_gc, xFEpuuup) //GO(xcb_create_gc_aux, //GO(xcb_create_gc_aux_checked, -GOS(xcb_create_gc_checked, pFEppuuup) //%x +GOS(xcb_create_gc_checked, xFEpuuup) //GO(xcb_create_gc_sizeof, //GO(xcb_create_gc_value_list, //GO(xcb_create_gc_value_list_serialize, //GO(xcb_create_gc_value_list_sizeof, //GO(xcb_create_gc_value_list_unpack, -GOS(xcb_create_glyph_cursor, pFEppuuuWWWWWWWW) //%x +GOS(xcb_create_glyph_cursor, xFEpuuuWWWWWWWW) //GO(xcb_create_glyph_cursor_checked, -GOS(xcb_create_pixmap, pFEppCuuWW) //%x +GOS(xcb_create_pixmap, xFEpCuuWW) //GO(xcb_create_pixmap_checked, -GOS(xcb_create_window, pFEppCuuwwWWWWuup) //%x +GOS(xcb_create_window, xFEpCuuwwWWWWuup) //GO(xcb_create_window_aux, //GO(xcb_create_window_aux_checked, -GOS(xcb_create_window_checked, pFEppCuuwwWWWWuup) //%x +GOS(xcb_create_window_checked, xFEpCuuwwWWWWuup) //GO(xcb_create_window_sizeof, //GO(xcb_create_window_value_list, //GO(xcb_create_window_value_list_serialize, @@ -163,17 +163,17 @@ GOS(xcb_create_window_checked, pFEppCuuwwWWWWuup) //%x //GO(xcb_create_window_value_list_unpack, //GO(xcb_cursor_end, //GO(xcb_cursor_next, -GOS(xcb_delete_property, pFEpppp) //%x +GOS(xcb_delete_property, xFEppp) //GO(xcb_delete_property_checked, //GO(xcb_depth_end, GO(xcb_depth_next, vFp) GO(xcb_depth_sizeof, iFp) GO(xcb_depth_visuals, pFp) -GOS(xcb_depth_visuals_iterator, pFEpp) //%X xcb_visualtype_iterator_t is a structure +GOS(xcb_depth_visuals_iterator, XFEp) //GO(xcb_depth_visuals_length, //GO(xcb_destroy_subwindows, //GO(xcb_destroy_subwindows_checked, -GOS(xcb_destroy_window, pFEppu) //%x +GOS(xcb_destroy_window, xFEpu) //GO(xcb_destroy_window_checked, //GO(xcb_discard_reply, //GO(xcb_discard_reply64, @@ -197,24 +197,24 @@ GO(xcb_flush, iFp) //GO(xcb_force_screen_saver_checked, //GO(xcb_format_end, GO(xcb_format_next, vFp) -GOS(xcb_free_colormap, pFEppu) //%x -GOS(xcb_free_colormap_checked, pFEppu) //%x +GOS(xcb_free_colormap, xFEpu) +GOS(xcb_free_colormap_checked, xFEpu) //GO(xcb_free_colors, //GO(xcb_free_colors_checked, //GO(xcb_free_colors_pixels, //GO(xcb_free_colors_pixels_end, //GO(xcb_free_colors_pixels_length, //GO(xcb_free_colors_sizeof, -GOS(xcb_free_cursor, pFEppp) //%x +GOS(xcb_free_cursor, xFEpp) //GO(xcb_free_cursor_checked, -GOS(xcb_free_gc, pFEppu) //%x +GOS(xcb_free_gc, xFEpu) //GO(xcb_free_gc_checked, -GOS(xcb_free_pixmap, pFEppu) //%x +GOS(xcb_free_pixmap, xFEpu) //GO(xcb_free_pixmap_checked, //GO(xcb_gcontext_end, //GO(xcb_gcontext_next, GO(xcb_generate_id, uFp) -GOS(xcb_get_atom_name, pFEppu) //%x +GOS(xcb_get_atom_name, xFEpu) GO(xcb_get_atom_name_name, pFp) //GO(xcb_get_atom_name_name_end, GO(xcb_get_atom_name_name_length, iFp) @@ -229,23 +229,23 @@ GO(xcb_get_file_descriptor, iFp) //GO(xcb_get_font_path_reply, //GO(xcb_get_font_path_sizeof, //GO(xcb_get_font_path_unchecked, -GOS(xcb_get_geometry, pFEppu) //%x +GOS(xcb_get_geometry, xFEpu) GO(xcb_get_geometry_reply, pFpup) -GOS(xcb_get_geometry_unchecked, pFEppu) //%x -GOS(xcb_get_image, pFEppCuwwWWu) //%x +GOS(xcb_get_geometry_unchecked, xFEpu) +GOS(xcb_get_image, xFEpCuwwWWu) GO(xcb_get_image_data, pFp) //GO(xcb_get_image_data_end, GO(xcb_get_image_data_length, iFp) GO(xcb_get_image_reply, pFpup) //GO(xcb_get_image_sizeof, -GOS(xcb_get_image_unchecked, pFEppCuwwWWu) //%x -GOS(xcb_get_input_focus, pFEpp) //%x +GOS(xcb_get_image_unchecked, xFEpCuwwWWu) +GOS(xcb_get_input_focus, xFEp) GO(xcb_get_input_focus_reply, pFpup) //GO(xcb_get_input_focus_unchecked, //GO(xcb_get_keyboard_control, //GO(xcb_get_keyboard_control_reply, //GO(xcb_get_keyboard_control_unchecked, -GOS(xcb_get_keyboard_mapping, pFEppCC) //%x +GOS(xcb_get_keyboard_mapping, xFEpCC) GO(xcb_get_keyboard_mapping_keysyms, pFp) //GO(xcb_get_keyboard_mapping_keysyms_end, GO(xcb_get_keyboard_mapping_keysyms_length, iFp) @@ -253,12 +253,12 @@ GO(xcb_get_keyboard_mapping_reply, pFpup) //GO(xcb_get_keyboard_mapping_sizeof, //GO(xcb_get_keyboard_mapping_unchecked, GO(xcb_get_maximum_request_length, uFp) -GOS(xcb_get_modifier_mapping, pFEpp) //%x +GOS(xcb_get_modifier_mapping, xFEp) GO(xcb_get_modifier_mapping_keycodes, pFp) //GO(xcb_get_modifier_mapping_keycodes_end, GO(xcb_get_modifier_mapping_keycodes_length, iFp) GO(xcb_get_modifier_mapping_reply, pFpup) -//GOS(xcb_get_modifier_mapping_sizeof, pFEpp) //%x +//GOS(xcb_get_modifier_mapping_sizeof, xFEp) //GO(xcb_get_modifier_mapping_unchecked, //GO(xcb_get_motion_events, //GO(xcb_get_motion_events_events, @@ -277,10 +277,10 @@ GO(xcb_get_modifier_mapping_reply, pFpup) //GO(xcb_get_pointer_mapping_reply, //GO(xcb_get_pointer_mapping_sizeof, //GO(xcb_get_pointer_mapping_unchecked, -GOS(xcb_get_property, pFEppCuuuuu) //%x +GOS(xcb_get_property, xFEpCuuuuu) GO(xcb_get_property_reply, pFpup) //GO(xcb_get_property_sizeof, -GOS(xcb_get_property_unchecked, pFEppCuuuuu) //%x +GOS(xcb_get_property_unchecked, xFEpCuuuuu) GO(xcb_get_property_value, pFp) //GO(xcb_get_property_value_end, GO(xcb_get_property_value_length, iFp) @@ -288,24 +288,24 @@ GO(xcb_get_reply_fds, pFppu) //GO(xcb_get_screen_saver, //GO(xcb_get_screen_saver_reply, //GO(xcb_get_screen_saver_unchecked, -GOS(xcb_get_selection_owner, pFEppu) //%x +GOS(xcb_get_selection_owner, xFEpu) GO(xcb_get_selection_owner_reply, pFpup) -GOS(xcb_get_selection_owner_unchecked, pFEppu) //%x +GOS(xcb_get_selection_owner_unchecked, xFEpu) GO(xcb_get_setup, pFp) -GOS(xcb_get_window_attributes, pFEppu) //%x +GOS(xcb_get_window_attributes, xFEpu) GO(xcb_get_window_attributes_reply, pFpup) -GOS(xcb_get_window_attributes_unchecked, pFEppu) //%x -GOS(xcb_grab_button, pFEppCuWCCuuCW) //%x -GOS(xcb_grab_button_checked, pFEppCuWCCuuCW) //%x -GOS(xcb_grab_key, pFEppCuWCCC) //%x -GOS(xcb_grab_keyboard, pFEppCuuCC) //%x +GOS(xcb_get_window_attributes_unchecked, xFEpu) +GOS(xcb_grab_button, xFEpCuWCCuuCW) +GOS(xcb_grab_button_checked, xFEpCuWCCuuCW) +GOS(xcb_grab_key, xFEpCuWCCC) +GOS(xcb_grab_keyboard, xFEpCuuCC) GO(xcb_grab_keyboard_reply, pFpup) //GO(xcb_grab_keyboard_unchecked, -GOS(xcb_grab_key_checked, pFEppCuWCCC) //%x -GOS(xcb_grab_pointer, pFEppCuWCCuuu) //%x +GOS(xcb_grab_key_checked, xFEpCuWCCC) +GOS(xcb_grab_pointer, xFEpCuWCCuuu) GO(xcb_grab_pointer_reply, pFpup) //GO(xcb_grab_pointer_unchecked, -GOS(xcb_grab_server, pFEpp) //%x +GOS(xcb_grab_server, xFEp) //GO(xcb_grab_server_checked, //GO(xcb_host_address, //GO(xcb_host_address_end, @@ -319,18 +319,18 @@ GOS(xcb_grab_server, pFEpp) //%x //GO(xcb_image_text_16_string, //GO(xcb_image_text_16_string_iterator, //GO(xcb_image_text_16_string_length, -GOS(xcb_image_text_8, pFEppCuuwwp) //%x -GOS(xcb_image_text_8_checked, pFEppCuuwwp) //%x +GOS(xcb_image_text_8, xFEpCuuwwp) +GOS(xcb_image_text_8_checked, xFEpCuuwwp) //GO(xcb_image_text_8_sizeof, //GO(xcb_image_text_8_string, //GO(xcb_image_text_8_string_end, //GO(xcb_image_text_8_string_length, //GO(xcb_install_colormap, //GO(xcb_install_colormap_checked, -GOS(xcb_intern_atom, pFEppCWp) //%x +GOS(xcb_intern_atom, xFEpCWp) GO(xcb_intern_atom_reply, pFpup) //GO(xcb_intern_atom_sizeof, -GOS(xcb_intern_atom_unchecked, pFEppCWp) //%x +GOS(xcb_intern_atom_unchecked, xFEpCWp) //GO(xcb_keycode32_end, //GO(xcb_keycode32_next, //GO(xcb_keycode_end, @@ -385,14 +385,14 @@ GOS(xcb_intern_atom_unchecked, pFEppCWp) //%x //GO(xcb_lookup_color_reply, //GO(xcb_lookup_color_sizeof, //GO(xcb_lookup_color_unchecked, -GOS(xcb_map_subwindows, pFEppu) //%x +GOS(xcb_map_subwindows, xFEpu) //GO(xcb_map_subwindows_checked, -GOS(xcb_map_window, pFEppu) //%x -GOS(xcb_map_window_checked, pFEppu) //%x +GOS(xcb_map_window, xFEpu) +GOS(xcb_map_window_checked, xFEpu) //GO(xcb_no_operation, //GO(xcb_no_operation_checked, -GOS(xcb_open_font, pFEppuWp) //%x -GOS(xcb_open_font_checked, pFEppuWp) //%x +GOS(xcb_open_font, xFEpuWp) +GOS(xcb_open_font_checked, xFEpuWp) //GO(xcb_open_font_name, //GO(xcb_open_font_name_end, //GO(xcb_open_font_name_length, @@ -407,7 +407,7 @@ GO(xcb_poll_for_queued_event, pFp) //GO(xcb_poll_for_reply, //GO(xcb_poll_for_reply64, GO(xcb_poll_for_special_event, pFpp) -GOS(xcb_poly_arc, pFEppuuup) //%x +GOS(xcb_poly_arc, xFEpuuup) //GO(xcb_poly_arc_arcs, //GO(xcb_poly_arc_arcs_iterator, //GO(xcb_poly_arc_arcs_length, @@ -419,31 +419,31 @@ GOS(xcb_poly_arc, pFEppuuup) //%x //GO(xcb_poly_fill_arc_arcs_length, //GO(xcb_poly_fill_arc_checked, //GO(xcb_poly_fill_arc_sizeof, -GOS(xcb_poly_fill_rectangle, pFEppuuup) //%x +GOS(xcb_poly_fill_rectangle, xFEpuuup) //GO(xcb_poly_fill_rectangle_checked, //GO(xcb_poly_fill_rectangle_rectangles, //GO(xcb_poly_fill_rectangle_rectangles_iterator, //GO(xcb_poly_fill_rectangle_rectangles_length, //GO(xcb_poly_fill_rectangle_sizeof, -GOS(xcb_poly_line, pFEppCuuup) //%x -GOS(xcb_poly_line_checked, pFEppCuuup) //%x +GOS(xcb_poly_line, xFEpCuuup) +GOS(xcb_poly_line_checked, xFEpCuuup) //GO(xcb_poly_line_points, //GO(xcb_poly_line_points_iterator, //GO(xcb_poly_line_points_length, //GO(xcb_poly_line_sizeof, -GOS(xcb_poly_point, pFEppCuuup) //%x +GOS(xcb_poly_point, xFEpCuuup) //GO(xcb_poly_point_checked, //GO(xcb_poly_point_points, //GO(xcb_poly_point_points_iterator, //GO(xcb_poly_point_points_length, //GO(xcb_poly_point_sizeof, -GOS(xcb_poly_rectangle, pFEppuuup) //%x +GOS(xcb_poly_rectangle, xFEpuuup) //GO(xcb_poly_rectangle_checked, //GO(xcb_poly_rectangle_rectangles, //GO(xcb_poly_rectangle_rectangles_iterator, //GO(xcb_poly_rectangle_rectangles_length, //GO(xcb_poly_rectangle_sizeof, -GOS(xcb_poly_segment, pFEppuuup) //%x +GOS(xcb_poly_segment, xFEpuuup) //GO(xcb_poly_segment_checked, //GO(xcb_poly_segment_segments, //GO(xcb_poly_segment_segments_iterator, @@ -464,7 +464,7 @@ GOS(xcb_poly_segment, pFEppuuup) //%x GO(xcb_popcount, iFu) GO(xcb_prefetch_extension_data, vFpp) //GO(xcb_prefetch_maximum_request_length, -GOS(xcb_put_image, pFEppCuuWWwwCCup) //%x +GOS(xcb_put_image, xFEpCuuWWwwCCup) //GO(xcb_put_image_checked, //GO(xcb_put_image_data, //GO(xcb_put_image_data_end, @@ -497,26 +497,26 @@ GOS(xcb_put_image, pFEppCuuWWwwCCup) //%x //GO(xcb_query_keymap, //GO(xcb_query_keymap_reply, //GO(xcb_query_keymap_unchecked, -GOS(xcb_query_pointer, pFEppu) //%x +GOS(xcb_query_pointer, xFEpu) GO(xcb_query_pointer_reply, pFpup) //GO(xcb_query_pointer_unchecked, -GOS(xcb_query_text_extents, pFEppuup) //%x +GOS(xcb_query_text_extents, xFEpuup) GO(xcb_query_text_extents_reply, pFpup) //GO(xcb_query_text_extents_sizeof, //GO(xcb_query_text_extents_unchecked, -GOS(xcb_query_tree, pFEppu) //%x +GOS(xcb_query_tree, xFEpu) GO(xcb_query_tree_children, pFp) //GO(xcb_query_tree_children_end, GO(xcb_query_tree_children_length, iFp) GO(xcb_query_tree_reply, pFpup) //GO(xcb_query_tree_sizeof, -GOS(xcb_query_tree_unchecked, pFEppu) //%x +GOS(xcb_query_tree_unchecked, xFEpu) //GO(xcb_recolor_cursor, //GO(xcb_recolor_cursor_checked, //GO(xcb_rectangle_end, //GO(xcb_rectangle_next, GO(xcb_register_for_special_xge, pFppup) -GOS(xcb_reparent_window, pFEppuuWW) //%x +GOS(xcb_reparent_window, xFEpuuWW) //GO(xcb_reparent_window_checked, GO(xcb_request_check, pFpu) //GO(xcb_rgb_end, @@ -527,14 +527,14 @@ GO(xcb_request_check, pFpu) //GO(xcb_rotate_properties_atoms_length, //GO(xcb_rotate_properties_checked, //GO(xcb_rotate_properties_sizeof, -GOS(xcb_screen_allowed_depths_iterator, pFEpp) //%X xcb_depth_iterator_t is a structure +GOS(xcb_screen_allowed_depths_iterator, XFEp) //GO(xcb_screen_allowed_depths_length, //GO(xcb_screen_end, GO(xcb_screen_next, vFp) //GO(xcb_screen_sizeof, //GO(xcb_segment_end, //GO(xcb_segment_next, -GOS(xcb_send_event, pFEppCuup) //%x +GOS(xcb_send_event, xFEpCuup) //GO(xcb_send_event_checked, //GO(xcb_send_fd, GO(xcb_send_request, uFpipp) @@ -562,7 +562,7 @@ GO(xcb_send_request_with_fds64, UFpippup) //GO(xcb_set_font_path_font_iterator, //GO(xcb_set_font_path_font_length, //GO(xcb_set_font_path_sizeof, -GOS(xcb_set_input_focus, pFEppCuu) // xcb_void_cookie_t is a struct with only 1 uint inside //%x +GOS(xcb_set_input_focus, xFEpCuu) //GO(xcb_set_input_focus_checked, //GO(xcb_set_modifier_mapping, //GO(xcb_set_modifier_mapping_reply, @@ -574,7 +574,7 @@ GOS(xcb_set_input_focus, pFEppCuu) // xcb_void_cookie_t is a struct with only 1 //GO(xcb_set_pointer_mapping_unchecked, //GO(xcb_set_screen_saver, //GO(xcb_set_screen_saver_checked, -GOS(xcb_set_selection_owner, pFEppuuu) //%x +GOS(xcb_set_selection_owner, xFEpuuu) //GO(xcb_set_selection_owner_checked, //GO(xcb_setup_authenticate_end, //GO(xcb_setup_authenticate_next, @@ -591,7 +591,7 @@ GOS(xcb_set_selection_owner, pFEppuuu) //%x //GO(xcb_setup_failed_sizeof, //GO(xcb_setup_next, GO(xcb_setup_pixmap_formats, pFp) -GOS(xcb_setup_pixmap_formats_iterator, pFEpp) //%X +GOS(xcb_setup_pixmap_formats_iterator, XFEp) GO(xcb_setup_pixmap_formats_length, iFp) //GO(xcb_setup_request_authorization_protocol_data, //GO(xcb_setup_request_authorization_protocol_data_end, @@ -602,7 +602,7 @@ GO(xcb_setup_pixmap_formats_length, iFp) //GO(xcb_setup_request_end, //GO(xcb_setup_request_next, //GO(xcb_setup_request_sizeof, -GOS(xcb_setup_roots_iterator, pFEpp) //%X +GOS(xcb_setup_roots_iterator, XFEp) GO(xcb_setup_roots_length, iFp) //GO(xcb_setup_sizeof, //GO(xcb_setup_vendor, @@ -632,24 +632,24 @@ GO(xcb_setup_roots_length, iFp) //GO(xcb_timecoord_next, //GO(xcb_timestamp_end, //GO(xcb_timestamp_next, -GOS(xcb_translate_coordinates, pFEppuuWW) //%x +GOS(xcb_translate_coordinates, xFEpuuWW) GO(xcb_translate_coordinates_reply, pFpup) -GOS(xcb_translate_coordinates_unchecked, pFEppuuWW) //%x -GOS(xcb_ungrab_button, pFEppCuW) //%x -GOS(xcb_ungrab_button_checked, pFEppCuW) //%x -GOS(xcb_ungrab_key, pFEppCuW) //%x -GOS(xcb_ungrab_keyboard, pFEppu) //%x -GOS(xcb_ungrab_keyboard_checked, pFEppu) //%x -GOS(xcb_ungrab_key_checked, pFEppCuW) //%x -GOS(xcb_ungrab_pointer, pFEppu) //%x +GOS(xcb_translate_coordinates_unchecked, xFEpuuWW) +GOS(xcb_ungrab_button, xFEpCuW) +GOS(xcb_ungrab_button_checked, xFEpCuW) +GOS(xcb_ungrab_key, xFEpCuW) +GOS(xcb_ungrab_keyboard, xFEpu) +GOS(xcb_ungrab_keyboard_checked, xFEpu) +GOS(xcb_ungrab_key_checked, xFEpCuW) +GOS(xcb_ungrab_pointer, xFEpu) //GO(xcb_ungrab_pointer_checked, -GOS(xcb_ungrab_server, pFEpp) //%x +GOS(xcb_ungrab_server, xFEp) //GO(xcb_ungrab_server_checked, //GO(xcb_uninstall_colormap, //GO(xcb_uninstall_colormap_checked, //GO(xcb_unmap_subwindows, //GO(xcb_unmap_subwindows_checked, -GOS(xcb_unmap_window, pFEppu) //%x +GOS(xcb_unmap_window, xFEpu) //GO(xcb_unmap_window_checked, GO(xcb_unregister_for_special_event, vFpp) //GO(xcb_visualid_end, @@ -660,7 +660,7 @@ GO(xcb_wait_for_event, pFp) GO(xcb_wait_for_reply, pFpup) GO(xcb_wait_for_reply64, pFpUp) //GO(xcb_wait_for_special_event, -GOS(xcb_warp_pointer, pFEppuuwwWWww) //%x +GOS(xcb_warp_pointer, xFEpuuwwWWww) //GO(xcb_warp_pointer_checked, //GO(xcb_window_end, //GO(xcb_window_next, diff --git a/src/wrapped/wrappedlibxcbdri2_private.h b/src/wrapped/wrappedlibxcbdri2_private.h index 245ee99355..a996d282cb 100755 --- a/src/wrapped/wrappedlibxcbdri2_private.h +++ b/src/wrapped/wrappedlibxcbdri2_private.h @@ -2,14 +2,14 @@ #error meh! #endif -//%S X my_xcb_cookie_t +//%S x my_xcb_cookie_t u //GO(xcb_dri2_attach_format_end, //GO(xcb_dri2_attach_format_next, -GOS(xcb_dri2_authenticate, pFEppuu) //%X +GOS(xcb_dri2_authenticate, xFEpuu) GO(xcb_dri2_authenticate_reply, pFpup) //GO(xcb_dri2_authenticate_unchecked, -GOS(xcb_dri2_connect, pFEppuu) //%X +GOS(xcb_dri2_connect, xFEpuu) //GO(xcb_dri2_connect_alignment_pad, //GO(xcb_dri2_connect_alignment_pad_end, //GO(xcb_dri2_connect_alignment_pad_length, @@ -52,7 +52,7 @@ GO(xcb_dri2_connect_reply, pFpup) //GO(xcb_dri2_get_param_reply, //GO(xcb_dri2_get_param_unchecked, DATA(xcb_dri2_id, 8) -GOS(xcb_dri2_query_version, pFEppuu) //%X +GOS(xcb_dri2_query_version, xFEpuu) GO(xcb_dri2_query_version_reply, pFpup) //GO(xcb_dri2_query_version_unchecked, //GO(xcb_dri2_swap_buffers, diff --git a/src/wrapped/wrappedlibxcbdri3_private.h b/src/wrapped/wrappedlibxcbdri3_private.h index 7baa4df45f..e9d6435540 100755 --- a/src/wrapped/wrappedlibxcbdri3_private.h +++ b/src/wrapped/wrappedlibxcbdri3_private.h @@ -2,7 +2,7 @@ #error meh! #endif -//%S X my_xcb_cookie_t +//%S x my_xcb_cookie_t u //GO(xcb_dri3_buffer_from_pixmap, //GO(xcb_dri3_buffer_from_pixmap_reply, @@ -39,14 +39,14 @@ //GO(xcb_dri3_get_supported_modifiers_window_modifiers_end, //GO(xcb_dri3_get_supported_modifiers_window_modifiers_length, DATA(xcb_dri3_id, 8) -GOS(xcb_dri3_open, pFEppuu) //%X +GOS(xcb_dri3_open, xFEpuu) GO(xcb_dri3_open_reply, pFpup) GO(xcb_dri3_open_reply_fds, pFpp) //GO(xcb_dri3_open_unchecked, //GO(xcb_dri3_pixmap_from_buffer, -GOS(xcb_dri3_pixmap_from_buffer_checked, pFEppuuuWWWCCi) //%X +GOS(xcb_dri3_pixmap_from_buffer_checked, xFEpuuuWWWCCi) //GO(xcb_dri3_pixmap_from_buffers, //GO(xcb_dri3_pixmap_from_buffers_checked, -GOS(xcb_dri3_query_version, pFEppuu) //%X +GOS(xcb_dri3_query_version, xFEpuu) GO(xcb_dri3_query_version_reply, pFpup) //GO(xcb_dri3_query_version_unchecked, diff --git a/src/wrapped/wrappedlibxcbimage_private.h b/src/wrapped/wrappedlibxcbimage_private.h index e86641ffc5..d8460eb437 100755 --- a/src/wrapped/wrappedlibxcbimage_private.h +++ b/src/wrapped/wrappedlibxcbimage_private.h @@ -2,7 +2,7 @@ #error meh! #endif -//%S X my_xcb_cookie_t +//%S x my_xcb_cookie_t u GO(xcb_create_pixmap_from_bitmap_data, pFpupuuuuup) GO(xcb_image_annotate, vFp) @@ -14,8 +14,8 @@ GO(xcb_image_destroy, vFp) GO(xcb_image_get, pFpdwwWWui) GO(xcb_image_get_pixel, uFpuu) GO(xcb_image_native, pFppi) -GOS(xcb_image_put, pFEppuupwwC) //%X +GOS(xcb_image_put, xFEpuupwwC) GO(xcb_image_put_pixel, vFpuuu) -GO(xcb_image_shm_get, iFpupuupWWu) //xcb_shm_segment_info_t is a struct with "u u p" +GO(xcb_image_shm_get, iFpupuupWWu) // xcb_shm_segment_info_t is a struct with "u u p" (TODO: add a structure?) GO(xcb_image_shm_put, pFpuupuupwwwwWWC) GO(xcb_image_subimage, pFpuuuupup) diff --git a/src/wrapped/wrappedlibxcbpresent_private.h b/src/wrapped/wrappedlibxcbpresent_private.h index d695092174..a961d9df6b 100755 --- a/src/wrapped/wrappedlibxcbpresent_private.h +++ b/src/wrapped/wrappedlibxcbpresent_private.h @@ -2,17 +2,17 @@ #error meh! #endif -//%S X my_xcb_cookie_t +//%S x my_xcb_cookie_t u //GO(xcb_present_event_end, //GO(xcb_present_event_next, DATA(xcb_present_id, 8) //GO(xcb_present_notify_end, -GOS(xcb_present_notify_msc, pFEppuuUUU) //%X +GOS(xcb_present_notify_msc, xFEpuuUUU) //GO(xcb_present_notify_msc_checked, //GO(xcb_present_notify_next, -GOS(xcb_present_pixmap, pFEppuuuuuwwuuuuUUUup) //%X -GOS(xcb_present_pixmap_checked, pFEppuuuuuwwuuuuUUUup) //%X +GOS(xcb_present_pixmap, xFEpuuuuuwwuuuuUUUup) +GOS(xcb_present_pixmap_checked, xFEpuuuuuwwuuuuUUUup) //GO(xcb_present_pixmap_notifies, //GO(xcb_present_pixmap_notifies_iterator, //GO(xcb_present_pixmap_notifies_length, @@ -20,7 +20,7 @@ GOS(xcb_present_pixmap_checked, pFEppuuuuuwwuuuuUUUup) //%X //GO(xcb_present_query_capabilities, //GO(xcb_present_query_capabilities_reply, //GO(xcb_present_query_capabilities_unchecked, -GOS(xcb_present_query_version, pFEppuu) //%X +GOS(xcb_present_query_version, xFEpuu) GO(xcb_present_query_version_reply, pFpup) //GO(xcb_present_query_version_unchecked, //GO(xcb_present_redirect_notify_notifies, @@ -28,4 +28,4 @@ GO(xcb_present_query_version_reply, pFpup) //GO(xcb_present_redirect_notify_notifies_length, //GO(xcb_present_redirect_notify_sizeof, //GO(xcb_present_select_input, -GOS(xcb_present_select_input_checked, pFEppuuu) //%X +GOS(xcb_present_select_input_checked, xFEpuuu) diff --git a/src/wrapped/wrappedlibxcbrandr_private.h b/src/wrapped/wrappedlibxcbrandr_private.h index fb3baf7812..16e4e43e99 100755 --- a/src/wrapped/wrappedlibxcbrandr_private.h +++ b/src/wrapped/wrappedlibxcbrandr_private.h @@ -2,8 +2,8 @@ #error meh! #endif -//%S X my_xcb_cookie_t -//%S T my_xcb_iterator_t +//%S x my_xcb_cookie_t u +//%S X my_xcb_iterator_t pii //GOS(xcb_randr_add_output_mode, //GOS(xcb_randr_add_output_mode_checked, @@ -65,7 +65,7 @@ //GOS(xcb_randr_get_crtc_gamma_size_reply, //GOS(xcb_randr_get_crtc_gamma_size_unchecked, //GOS(xcb_randr_get_crtc_gamma_unchecked, -GOS(xcb_randr_get_crtc_info, pFEpppu) //%X +GOS(xcb_randr_get_crtc_info, xFEppu) //GOS(xcb_randr_get_crtc_info_outputs, //GOS(xcb_randr_get_crtc_info_outputs_end, //GOS(xcb_randr_get_crtc_info_outputs_length, @@ -74,7 +74,7 @@ GOS(xcb_randr_get_crtc_info, pFEpppu) //%X //GOS(xcb_randr_get_crtc_info_possible_length, GO(xcb_randr_get_crtc_info_reply, pFpup) //GOS(xcb_randr_get_crtc_info_sizeof, -GOS(xcb_randr_get_crtc_info_unchecked, pFEpppu) //%X +GOS(xcb_randr_get_crtc_info_unchecked, xFEppu) //GOS(xcb_randr_get_crtc_transform, //GOS(xcb_randr_get_crtc_transform_current_filter_name, //GOS(xcb_randr_get_crtc_transform_current_filter_name_end, @@ -97,7 +97,7 @@ GOS(xcb_randr_get_crtc_info_unchecked, pFEpppu) //%X //GOS(xcb_randr_get_monitors_reply, //GOS(xcb_randr_get_monitors_sizeof, //GOS(xcb_randr_get_monitors_unchecked, -GOS(xcb_randr_get_output_info, pFEpppu) //%X +GOS(xcb_randr_get_output_info, xFEppu) //GOS(xcb_randr_get_output_info_clones, //GOS(xcb_randr_get_output_info_clones_end, //GOS(xcb_randr_get_output_info_clones_length, @@ -112,10 +112,10 @@ GOS(xcb_randr_get_output_info, pFEpppu) //%X //GOS(xcb_randr_get_output_info_name_length, GO(xcb_randr_get_output_info_reply, pFpup) //GOS(xcb_randr_get_output_info_sizeof, -GOS(xcb_randr_get_output_info_unchecked, pFEpppu) //%X -GOS(xcb_randr_get_output_primary, pFEppu) //%X +GOS(xcb_randr_get_output_info_unchecked, xFEppu) +GOS(xcb_randr_get_output_primary, xFEpu) GO(xcb_randr_get_output_primary_reply, pFpup) -GOS(xcb_randr_get_output_primary_unchecked, pFEppu) //%X +GOS(xcb_randr_get_output_primary_unchecked, xFEpu) //GOS(xcb_randr_get_output_property, //GOS(xcb_randr_get_output_property_data, //GOS(xcb_randr_get_output_property_data_end, @@ -168,11 +168,11 @@ GOS(xcb_randr_get_output_primary_unchecked, pFEppu) //%X //GOS(xcb_randr_get_screen_info_sizes_iterator, //GOS(xcb_randr_get_screen_info_sizes_length, //GOS(xcb_randr_get_screen_info_unchecked, -GOS(xcb_randr_get_screen_resources, pFEppu) //%X +GOS(xcb_randr_get_screen_resources, xFEpu) //GOS(xcb_randr_get_screen_resources_crtcs, //GOS(xcb_randr_get_screen_resources_crtcs_end, //GOS(xcb_randr_get_screen_resources_crtcs_length, -GOS(xcb_randr_get_screen_resources_current, pFEppu) //%X +GOS(xcb_randr_get_screen_resources_current, xFEpu) //GOS(xcb_randr_get_screen_resources_current_crtcs, //GOS(xcb_randr_get_screen_resources_current_crtcs_end, //GOS(xcb_randr_get_screen_resources_current_crtcs_length, @@ -183,7 +183,7 @@ GOS(xcb_randr_get_screen_resources_current, pFEppu) //%X //GOS(xcb_randr_get_screen_resources_current_names_end, //GOS(xcb_randr_get_screen_resources_current_names_length, GO(xcb_randr_get_screen_resources_current_outputs, pFp) -GOS(xcb_randr_get_screen_resources_current_outputs_end, pFEpp) //%T +GOS(xcb_randr_get_screen_resources_current_outputs_end, XFEp) GO(xcb_randr_get_screen_resources_current_outputs_length, iFp) GO(xcb_randr_get_screen_resources_current_reply, pFpup) //GOS(xcb_randr_get_screen_resources_current_sizeof, @@ -194,12 +194,12 @@ GO(xcb_randr_get_screen_resources_current_reply, pFpup) //GOS(xcb_randr_get_screen_resources_names, //GOS(xcb_randr_get_screen_resources_names_end, //GOS(xcb_randr_get_screen_resources_names_length, -GOS(xcb_randr_get_screen_resources_outputs, pFEppu) //%X +GOS(xcb_randr_get_screen_resources_outputs, xFEpu) //GOS(xcb_randr_get_screen_resources_outputs_end, GO(xcb_randr_get_screen_resources_outputs_length, iFp) GO(xcb_randr_get_screen_resources_reply, pFpup) //GOS(xcb_randr_get_screen_resources_sizeof, -GOS(xcb_randr_get_screen_resources_unchecked, pFEppu) //%X +GOS(xcb_randr_get_screen_resources_unchecked, xFEpu) //GOS(xcb_randr_get_screen_size_range, //GOS(xcb_randr_get_screen_size_range_reply, //GOS(xcb_randr_get_screen_size_range_unchecked, @@ -256,9 +256,9 @@ DATA(xcb_randr_id, 8) //GOS(xcb_randr_query_provider_property_valid_values, //GOS(xcb_randr_query_provider_property_valid_values_end, //GOS(xcb_randr_query_provider_property_valid_values_length, -GOS(xcb_randr_query_version, pFEppuu) //%X +GOS(xcb_randr_query_version, xFEpuu) GO(xcb_randr_query_version_reply, pFpup) -GOS(xcb_randr_query_version_unchecked, pFEppuu) //%X +GOS(xcb_randr_query_version_unchecked, xFEpuu) //GOS(xcb_randr_refresh_rates_end, //GOS(xcb_randr_refresh_rates_next, //GOS(xcb_randr_refresh_rates_rates, @@ -269,8 +269,8 @@ GOS(xcb_randr_query_version_unchecked, pFEppuu) //%X //GOS(xcb_randr_resource_change_next, //GOS(xcb_randr_screen_size_end, //GOS(xcb_randr_screen_size_next, -GOS(xcb_randr_select_input, pFEppuW) //%X -GOS(xcb_randr_select_input_checked, pFEppuW) //%X +GOS(xcb_randr_select_input, xFEpuW) +GOS(xcb_randr_select_input_checked, xFEpuW) //GOS(xcb_randr_set_crtc_config, //GOS(xcb_randr_set_crtc_config_reply, //GOS(xcb_randr_set_crtc_config_sizeof, diff --git a/src/wrapped/wrappedlibxcbshape_private.h b/src/wrapped/wrappedlibxcbshape_private.h index 4a667e758b..daf0fa9a45 100755 --- a/src/wrapped/wrappedlibxcbshape_private.h +++ b/src/wrapped/wrappedlibxcbshape_private.h @@ -2,7 +2,7 @@ #error meh! #endif -//%S X my_xcb_cookie_t +//%S x my_xcb_cookie_t u //GOS(xcb_shape_combine, //GOS(xcb_shape_combine_checked, @@ -19,8 +19,8 @@ DATA(xcb_shape_id, 8) //GOS(xcb_shape_input_selected_unchecked, //GOS(xcb_shape_kind_end, //GOS(xcb_shape_kind_next, -GOS(xcb_shape_mask, pFEppuuuwwu) //%X -GOS(xcb_shape_mask_checked, pFEppuuuwwu) //%X +GOS(xcb_shape_mask, xFEpuuuwwu) +GOS(xcb_shape_mask_checked, xFEpuuuwwu) //GOS(xcb_shape_offset, //GOS(xcb_shape_offset_checked, //GOS(xcb_shape_op_end, diff --git a/src/wrapped/wrappedlibxcbshm_private.h b/src/wrapped/wrappedlibxcbshm_private.h index 320df26e34..67f98a6ae6 100755 --- a/src/wrapped/wrappedlibxcbshm_private.h +++ b/src/wrapped/wrappedlibxcbshm_private.h @@ -2,29 +2,29 @@ #error meh! #endif -//%S X my_xcb_cookie_t -//%S T my_xcb_iterator_t +//%S x my_xcb_cookie_t u +//%S X my_xcb_iterator_t pii -GOS(xcb_shm_attach, pFEppuuC) //%X -GOS(xcb_shm_attach_checked, pFEppuuC) //%X -GOS(xcb_shm_attach_fd, pFEppuuC) //%X -GOS(xcb_shm_attach_fd_checked, pFEppuuC) //%X -GOS(xcb_shm_create_pixmap, pFEppuuWWCuu) //%X -GOS(xcb_shm_create_pixmap_checked, pFEppuuWWCuu) //%X -GOS(xcb_shm_create_segment, pFEppuuC) //%X +GOS(xcb_shm_attach, xFEpuuC) +GOS(xcb_shm_attach_checked, xFEpuuC) +GOS(xcb_shm_attach_fd, xFEpuuC) +GOS(xcb_shm_attach_fd_checked, xFEpuuC) +GOS(xcb_shm_create_pixmap, xFEpuuWWCuu) +GOS(xcb_shm_create_pixmap_checked, xFEpuuWWCuu) +GOS(xcb_shm_create_segment, xFEpuuC) GO(xcb_shm_create_segment_reply, pFpup) GO(xcb_shm_create_segment_reply_fds, pFpp) -GOS(xcb_shm_create_segment_unchecked, pFEppuuC) //%X -GOS(xcb_shm_detach, pFEppu) //%X -GOS(xcb_shm_detach_checked, pFEppu) //%X -GOS(xcb_shm_get_image, pFEppuwwWWuCuu) //%X +GOS(xcb_shm_create_segment_unchecked, xFEpuuC) +GOS(xcb_shm_detach, xFEpu) +GOS(xcb_shm_detach_checked, xFEpu) +GOS(xcb_shm_get_image, xFEpuwwWWuCuu) GO(xcb_shm_get_image_reply, pFpup) -GOS(xcb_shm_get_image_unchecked, pFEppuwwWWuCuu) //%X +GOS(xcb_shm_get_image_unchecked, xFEpuwwWWuCuu) DATA(xcb_shm_id, 8) -GOS(xcb_shm_put_image, pFEppuuWWWWWWwwCCCuu) //%X -GOS(xcb_shm_put_image_checked, pFEppuuWWWWWWwwCCCuu) //%X -GOS(xcb_shm_query_version, pFEpp) //%X +GOS(xcb_shm_put_image, xFEpuuWWWWWWwwCCCuu) +GOS(xcb_shm_put_image_checked, xFEpuuWWWWWWwwCCCuu) +GOS(xcb_shm_query_version, xFEp) GO(xcb_shm_query_version_reply, pFpup) -GOS(xcb_shm_query_version_unchecked, pFEpp) //%X -GOS(xcb_shm_seg_end, pFEppii) //%{TFT} xcb_generic_iterator_t by value, so "pii" +GOS(xcb_shm_query_version_unchecked, xFEp) +GOS(xcb_shm_seg_end, XFEX) GO(xcb_shm_seg_next, vFp) diff --git a/src/wrapped/wrappedlibxcbxfixes_private.h b/src/wrapped/wrappedlibxcbxfixes_private.h index 9b83203f62..854d15b791 100755 --- a/src/wrapped/wrappedlibxcbxfixes_private.h +++ b/src/wrapped/wrappedlibxcbxfixes_private.h @@ -2,7 +2,7 @@ #error meh! #endif -//%S X my_xcb_cookie_t +//%S x my_xcb_cookie_t u //GOS(xcb_xfixes_barrier_end, //GOS(xcb_xfixes_barrier_next, @@ -24,7 +24,7 @@ //GOS(xcb_xfixes_create_pointer_barrier_devices_end, //GOS(xcb_xfixes_create_pointer_barrier_devices_length, //GOS(xcb_xfixes_create_pointer_barrier_sizeof, -GOS(xcb_xfixes_create_region, pFEppuup) //%X +GOS(xcb_xfixes_create_region, xFEpuup) //GOS(xcb_xfixes_create_region_checked, //GOS(xcb_xfixes_create_region_from_bitmap, //GOS(xcb_xfixes_create_region_from_bitmap_checked, @@ -40,7 +40,7 @@ GOS(xcb_xfixes_create_region, pFEppuup) //%X //GOS(xcb_xfixes_create_region_sizeof, //GOS(xcb_xfixes_delete_pointer_barrier, //GOS(xcb_xfixes_delete_pointer_barrier_checked, -GOS(xcb_xfixes_destroy_region, pFEppu) //%X +GOS(xcb_xfixes_destroy_region, xFEpu) //GOS(xcb_xfixes_destroy_region_checked, //GOS(xcb_xfixes_expand_region, //GOS(xcb_xfixes_expand_region_checked, @@ -84,7 +84,7 @@ DATA(xcb_xfixes_id, 8) //GOS(xcb_xfixes_invert_region_checked, //GOS(xcb_xfixes_query_version, GO(xcb_xfixes_query_version_reply, pFpup) -GOS(xcb_xfixes_query_version_unchecked, pFEppuu) //%X +GOS(xcb_xfixes_query_version_unchecked, xFEpuu) //GOS(xcb_xfixes_region_end, //GOS(xcb_xfixes_region_extents, //GOS(xcb_xfixes_region_extents_checked, @@ -109,8 +109,8 @@ GOS(xcb_xfixes_query_version_unchecked, pFEppuu) //%X //GOS(xcb_xfixes_set_region_rectangles_iterator, //GOS(xcb_xfixes_set_region_rectangles_length, //GOS(xcb_xfixes_set_region_sizeof, -GOS(xcb_xfixes_set_window_shape_region, pFEppuuwwu) //%X -GOS(xcb_xfixes_set_window_shape_region_checked, pFEppuuwwu) //%X +GOS(xcb_xfixes_set_window_shape_region, xFEpuuwwu) +GOS(xcb_xfixes_set_window_shape_region_checked, xFEpuuwwu) //GOS(xcb_xfixes_show_cursor, //GOS(xcb_xfixes_show_cursor_checked, //GOS(xcb_xfixes_subtract_region, diff --git a/src/wrapped/wrappedlibxcbxtest_private.h b/src/wrapped/wrappedlibxcbxtest_private.h index 39c01c83f2..88733811f1 100755 --- a/src/wrapped/wrappedlibxcbxtest_private.h +++ b/src/wrapped/wrappedlibxcbxtest_private.h @@ -2,13 +2,13 @@ #error meh! #endif -//%S X my_xcb_cookie_t +//%S x my_xcb_cookie_t u //GOS(xcb_test_compare_cursor, //GOS(xcb_test_compare_cursor_reply, //GOS(xcb_test_compare_cursor_unchecked, -GOS(xcb_test_fake_input, pFEppCCuuwwC) //%X -GOS(xcb_test_fake_input_checked, pFEppCCuuwwC) //%X +GOS(xcb_test_fake_input, xFEpCCuuwwC) +GOS(xcb_test_fake_input_checked, xFEpCCuuwwC) //GOS(xcb_test_get_version, //GOS(xcb_test_get_version_reply, //GOS(xcb_test_get_version_unchecked, diff --git a/src/wrapped/wrappedlibxt_private.h b/src/wrapped/wrappedlibxt_private.h index 20feb4e32f..904c6645ee 100755 --- a/src/wrapped/wrappedlibxt_private.h +++ b/src/wrapped/wrappedlibxt_private.h @@ -240,7 +240,7 @@ GO(XtGrabPointer, iFpiuiipp) //GO(_XtHeapFree, //GO(_XtHeapInit, //GO(XtHooksOfDisplay, -//GO(_XtInherit, +GO(_XtInherit, vFv) //GO(XtInitialize, //GO(_XtInitializeActionData, //GO(XtInitializeWidgetClass, @@ -439,6 +439,4 @@ GO(XtWindow, pFp) //GO(XtWindowOfObject, GO(XtWindowToWidget, pFpp) -GO(_XtInherit, vFv) - -DATA(overrideShellClassRec, 96) // real size? this is full of Callback function, so maybe wrap at some point? \ No newline at end of file +DATA(overrideShellClassRec, 96) // real size? this is full of Callback function, so maybe wrap at some point? diff --git a/src/wrapped/wrappedlibxxf86vm_private.h b/src/wrapped/wrappedlibxxf86vm_private.h index 05904e4016..2b023ca31e 100755 --- a/src/wrapped/wrappedlibxxf86vm_private.h +++ b/src/wrapped/wrappedlibxxf86vm_private.h @@ -5,8 +5,8 @@ GO(XF86VidModeGetViewPort, iFpipp) GO(XF86VidModeValidateModeLine, iFpip) #ifdef PANDORA -GOM(XF86VidModeGetGamma, iFpip) -GOM(XF86VidModeSetGamma, iFpip) +GOM(XF86VidModeGetGamma, iFpip) //%noE +GOM(XF86VidModeSetGamma, iFpip) //%noE #else GO(XF86VidModeGetGamma, iFpip) GO(XF86VidModeSetGamma, iFpip) diff --git a/src/wrapped/wrappedlibz.c b/src/wrapped/wrappedlibz.c index 210dd6cb76..7cfc2e5cde 100755 --- a/src/wrapped/wrappedlibz.c +++ b/src/wrapped/wrappedlibz.c @@ -18,34 +18,7 @@ const char* libzName = "libz.so.1"; #define LIBNAME libz -// TODO: put the wrapper type in a dedicate include -typedef void* (*pFpi_t)(void*, int32_t); -typedef void* (*pFp_t)(void*); -typedef void* (*pFpp_t)(void*, void*); -typedef int32_t (*iFp_t)(void*); -typedef int32_t (*iFppi_t)(void*, void*, int32_t); -typedef int32_t (*iFpipi_t)(void*, int, void*, int); -typedef void* (*pFpippp_t)(void*, int32_t, void*, void*, void*); -typedef void (*vFp_t)(void*); -typedef void* (*pFpp_t)(void*, void*); -typedef uint32_t (*uFp_t)(void*); -typedef uint64_t (*UFp_t)(void*); -typedef uint32_t (*uFu_t)(uint32_t); -typedef int32_t (*iFpp_t)(void*, void*); -typedef uint32_t (*uFpW_t)(void*, uint16_t); -typedef uint32_t (*uFpu_t)(void*, uint32_t); -typedef uint32_t (*uFpU_t)(void*, uint64_t); -typedef uint32_t (*uFupp_t)(uint32_t, void*, void*); -typedef int (*iFpiiiiipi_t)(void*, int, int, int, int, int, void*, int); - -#define SUPER() \ - GO(inflateInit_, iFppi_t) \ - GO(inflateInit, iFp_t) \ - GO(inflateEnd, iFp_t) \ - GO(deflateEnd, iFp_t) \ - GO(inflateInit2_, iFpipi_t) \ - GO(deflateInit_, iFpipi_t) \ - GO(deflateInit2_, iFpiiiiipi_t) +#include "generated/wrappedlibztypes.h" typedef struct libz_my_s { // functions @@ -147,55 +120,41 @@ static void wrapper_stream_z(x86emu_t* emu, void* str) stream->zfree = find_free_Fct(stream->zfree); } -EXPORT int32_t my_inflateInit_(x86emu_t* emu, void* str, void* version, int32_t size) +EXPORT int my_inflateInit_(x86emu_t* emu, void* str, void* version, int size) { libz_my_t *my = (libz_my_t *)emu->context->zlib->priv.w.p2; wrapper_stream_z(emu, str); return my->inflateInit_(str, version, size); } -EXPORT int32_t my_inflateInit(x86emu_t* emu, void* str) -{ - libz_my_t *my = (libz_my_t *)emu->context->zlib->priv.w.p2; - wrapper_stream_z(emu, str); - return my->inflateInit(str); -} - -EXPORT int32_t my_inflateInit2_(x86emu_t* emu, void* str, int windowBits, void* version, int stream_size) +EXPORT int my_inflateInit2_(x86emu_t* emu, void* str, int windowBits, void* version, int stream_size) { libz_my_t *my = (libz_my_t *)emu->context->zlib->priv.w.p2; wrapper_stream_z(emu, str); return my->inflateInit2_(str, windowBits, version, stream_size); } -EXPORT int32_t my_inflateEnd(x86emu_t* emu, void* str) +EXPORT int my_inflateBackInit_(x86emu_t* emu, void* strm, int windowBits, void *window, void* version, int size) { libz_my_t *my = (libz_my_t *)emu->context->zlib->priv.w.p2; - int32_t r = my->inflateEnd(str); - return r; + wrapper_stream_z(emu, strm); + return my->inflateBackInit_(strm, windowBits, window, version, size); } -EXPORT int32_t my_deflateInit_(x86emu_t* emu, void* str, int level, void* version, int stream_size) +EXPORT int my_deflateInit_(x86emu_t* emu, void* str, int level, void* version, int stream_size) { libz_my_t *my = (libz_my_t *)emu->context->zlib->priv.w.p2; wrapper_stream_z(emu, str); return my->deflateInit_(str, level, version, stream_size); } -EXPORT int32_t my_deflateInit2_(x86emu_t* emu, void* str, int level, int method, int windowBits, int memLevel, int strategy, void* version, int stream_size) +EXPORT int my_deflateInit2_(x86emu_t* emu, void* str, int level, int method, int windowBits, int memLevel, int strategy, void* version, int stream_size) { libz_my_t *my = (libz_my_t *)emu->context->zlib->priv.w.p2; wrapper_stream_z(emu, str); return my->deflateInit2_(str, level, method, windowBits, memLevel, strategy, version, stream_size); } -EXPORT int32_t my_deflateEnd(x86emu_t* emu, void* str) -{ - libz_my_t *my = (libz_my_t *)emu->context->zlib->priv.w.p2; - int32_t r = my->deflateEnd(str); - return r; -} - #define CUSTOM_INIT \ box86->zlib = lib; \ @@ -207,4 +166,3 @@ EXPORT int32_t my_deflateEnd(x86emu_t* emu, void* str) ((box86context_t*)(lib->context))->zlib = NULL; #include "wrappedlib_init.h" - diff --git a/src/wrapped/wrappedlibz_private.h b/src/wrapped/wrappedlibz_private.h index c412071a12..1b017d02bf 100644 --- a/src/wrapped/wrappedlibz_private.h +++ b/src/wrapped/wrappedlibz_private.h @@ -2,108 +2,88 @@ #error Meh #endif -GO(zlibVersion, pFv) -GO(deflateInit, iFpi) +GO(adler32, LFLpu) +GO(adler32_combine, LFLLl) +GO(adler32_combine64, LFLLl) +GO(adler32_z, LFLpL) +GO(compress, iFpppL) +GO(compress2, iFpppLi) +GO(compressBound, LFL) +GO(crc32, LFLpu) +GO(crc32_combine, LFLLl) +GO(crc32_combine64, LFLLl) +GO(crc32_z, LFLpL) GO(deflate, iFpi) -GOM(deflateEnd, iFEp) -GOM(inflateInit, iFEp) -GO(inflate, iFpi) -GOM(inflateEnd, iFEp) -GO(deflateInit2, iFpiiiiipi) -GO(deflateSetDictionary, iFppu) -GO(deflateGetDictionary, iFppp) +GO(deflateBound, LFpL) GO(deflateCopy, iFpp) -GO(deflateReset, iFp) +GO(deflateEnd, iFp) +GO(deflateGetDictionary, iFppp) +GOM(deflateInit_, iFEpipi) +GOM(deflateInit2_, iFEpiiiiipi) GO(deflateParams, iFpii) -GO(deflateTune, iFpiiii) -GO(deflateBound, uFpu) GO(deflatePending, iFppp) GO(deflatePrime, iFpii) +GO(deflateReset, iFp) +GO(deflateResetKeep, iFp) +GO(deflateSetDictionary, iFppu) GO(deflateSetHeader, iFpp) -GO(inflateInit2, iFpi) -GO(inflateSetDictionary, iFppu) -GO(inflateGetDictionary, iFppp) -GO(inflateSync, iFp) -GO(inflateCopy, iFpp) -GO(inflateReset, iFp) -GO(inflateReset2, iFpi) -GO(inflatePrime, iFpii) -GO(inflateMark, iFp) -GO(inflateGetHeader, iFpp) -GO(inflateBackInit, iFpip) -//GOM(inflateBack, iFpBpBp) // callbacks... -GO(inflateBackEnd, iFp) -GO(zlibCompileFlags, iFv) -GO(compress, iFpppu) -GO(compress2, iFpppui) -GO(compressBound, uFu) -GO(uncompress, iFpppu) -GO(uncompress2, iFpppp) -GO(gzopen, pFpp) -GO(gzdopen, pFip) +GO(deflateTune, iFpiiii) +GO(get_crc_table, pFv) GO(gzbuffer, iFpu) -GO(gzsetparams, iFpii) -GO(gzread, iFppu) -GO(gzfread, uFpuup) -GO(gzwrite, iFppu) -GO(gzfwrite, uFpuup) -//GOM(gzprintf, iFEppVV) -GO(gzputs, iFpp) -GO(gzgets, pFppi) -GO(gzputc, iFpi) -GO(gzgetc, iFp) -GO(gzungetc, iFip) -GO(gzflush, iFpi) -GO(gzseek, iFpii) -GO(gzrewind, iFp) -GO(gztell, iFp) -GO(gzoffset, iFp) -GO(gzeof, iFp) -GO(gzdirect, iFp) +GO(gzclearerr, vFp) GO(gzclose, iFp) GO(gzclose_r, iFp) GO(gzclose_w, iFp) +GO(gzdirect, iFp) +GO(gzdopen, pFip) +GO(gzeof, iFp) GO(gzerror, pFpp) -GO(gzclearerr, vFp) -GO(adler32, uFupu) -GO(adler32_z, uFupi) -GO(adler32_combine, uFuui) -GO(crc32, uFupu) -GO(crc32_z, uFupu) -GO(crc32_combine, uFuui) -GOM(deflateInit_, iFEpipi) -GOM(inflateInit_, iFEppi) -GOM(deflateInit2_, iFEpiiiiipi) -GOM(inflateInit2_, iFEpipi) -GO(inflateBackInit_, iFpippi) +GO(gzflush, iFpi) +GO(gzfread, LFpLLp) +GO(gzfwrite, LFpLLp) +GO(gzgetc, iFp) GO(gzgetc_, iFp) -GO(gzopen64, pFpp) -GO(gzseek64, IFpIi) -GO(gztell64, IFp) -GO(gzoffset64, IFp) -GO(adler32_combine64, uFuuI) -GO(crc32_combine64, uFuuI) -GO(gzopen64, pFpp) -GO(gzseek64, iFpii) -GO(gztell64, iFp) -GO(gzoffset64, iFp) -GO(adler32_combine64, uFuui) -GO(crc32_combine64, uFuui) +GO(gzgets, pFppi) +GO(gzoffset, lFp) +GO(gzoffset64, lFp) GO(gzopen, pFpp) -GO(gzseek, iFpii) -GO(gztell, iFp) -GO(gzoffset, iFp) -GO(adler32_combine, uFuui) -GO(crc32_combine, uFuui) -GO(adler32_combine, uFuui) -GO(crc32_combine, uFuui) -GO(zError, pFi) +GO(gzopen64, pFpp) +//GO(gzprintf, iFppV) +GO(gzputc, iFpi) +GO(gzputs, iFpp) +GO(gzread, iFppu) +GO(gzrewind, iFp) +GO(gzseek, lFpli) +GO(gzseek64, lFpli) +GO(gzsetparams, iFpii) +GO(gztell, lFp) +GO(gztell64, lFp) +GO(gzungetc, iFip) +//GO(gzvprintf, iFppA) +GO(gzwrite, iFppu) +GO(inflate, iFpi) +//GO(inflateBack, iFp@p@p) +GO(inflateBackEnd, iFp) +GOM(inflateBackInit_, iFEpippi) +GO(inflateCodesUsed, LFp) +GO(inflateCopy, iFpp) +GO(inflateEnd, iFp) +GO(inflateGetDictionary, iFppp) +GO(inflateGetHeader, iFpp) +GOM(inflateInit_, iFEppi) +GOM(inflateInit2_, iFEpipi) +GO(inflateMark, lFp) +GO(inflatePrime, iFpii) +GO(inflateReset, iFp) +GO(inflateReset2, iFpi) +GO(inflateResetKeep, iFp) +GO(inflateSetDictionary, iFppu) +GO(inflateSync, iFp) GO(inflateSyncPoint, iFp) -GO(get_crc_table, pFv) GO(inflateUndermine, iFpi) GO(inflateValidate, iFpi) -GO(inflateCodesUsed, uFp) -GO(inflateResetKeep, iFp) -GO(deflateResetKeep, iFp) -GO(gzopen_w, pFpp) // Win32 only? -//GOM(gzvprintf iFEppVV) +GO(uncompress, iFpppL) +GO(uncompress2, iFpppp) +GO(zError, pFi) +GO(zlibCompileFlags, LFv) +GO(zlibVersion, pFv) diff --git a/src/wrapped/wrappedpng12_private.h b/src/wrapped/wrappedpng12_private.h index 3c83153525..748f0f9f44 100755 --- a/src/wrapped/wrappedpng12_private.h +++ b/src/wrapped/wrappedpng12_private.h @@ -2,95 +2,94 @@ #error meh! #endif -GO(png_create_write_struct, pFpppp) -GO(png_destroy_write_struct, vFpp) -GO(png_write_row, vFpp) -GO(png_set_compression_level, vFpi) -GO(png_set_tIME, vFppp) -GO(png_set_IHDR, vFppuuiiiii) -GO(png_write_end, vFpp) -GO(png_write_chunk, vFpppu) GO(png_convert_from_time_t, vFpu) +GO(png_check_sig, iFpi) GO(png_create_info_struct, pFp) -GO(png_init_io, vFpp) -GO(png_set_PLTE, vFpppi) -GO(png_write_info, vFpp) +GOM(png_create_read_struct, pFEpppp) +GOM(png_create_read_struct_2, pFEppppppp) +GO(png_create_write_struct, pFpppp) +GOM(png_create_write_struct_2, pFEppppppp) GO(png_destroy_read_struct, vFppp) -GO(png_get_IHDR, vFppppppppp) +GO(png_destroy_write_struct, vFpp) +GO(png_error, vFpp) GO(png_free, vFpp) +GO(png_get_bit_depth, CFpp) +GO(png_get_channels, CFpp) +GO(png_get_cHRM, uFpppppppppp) +GO(png_get_color_type, CFpp) +GO(png_get_error_ptr, pFp) +GO(png_get_gAMA, uFppp) +GO(png_get_header_ver, pFp) +GO(png_get_iCCP, uFpppppp) +GO(png_get_IHDR, vFppppppppp) +GO(png_get_image_height, uFpp) +GO(png_get_image_width, uFpp) +GO(png_get_interlace_type, CFpp) +GO(png_get_io_ptr, pFp) +GO(png_get_libpng_ver, pFp) +GO(png_get_pHYs, uFppppp) +GO(png_get_PLTE, uFpppp) +GO(png_get_progressive_ptr, pFp) +GO(png_get_rowbytes, uFpp) +GO(png_get_sRGB, uFppp) +GO(png_get_text, uFpppp) +GO(png_get_tRNS, uFppppp) +GO(png_get_valid, uFppu) +GO(png_get_x_offset_pixels, iFpp) +GO(png_get_y_offset_pixels, iFpp) +GO(png_init_io, vFpp) GO(png_malloc, pFpp) +GO(png_permit_mng_features, uFpu) +GO(png_process_data, vFpppL) +GO(png_progressive_combine_row, vFppp) GO(png_read_end, vFpp) GO(png_read_image, vFpp) -GOM(png_create_read_struct, pFEpppp) GO(png_read_info, vFpp) -GO(png_get_rowbytes, uFpp) -GO(png_set_rows, vFppp) -GO(png_write_png, vFppip) -GO(png_get_io_ptr, pFp) -GOM(png_set_write_fn, vFEpppp) -GO(png_set_packing, vFp) -GO(png_set_gray_to_rgb, vFp) -GO(png_set_palette_to_rgb, vFp) -GO(png_set_expand_gray_1_2_4_to_8, vFp) -GO(png_set_add_alpha, vFpui) -GO(png_set_tRNS_to_alpha, vFp) -GO(png_set_strip_16, vFp) -GO(png_get_valid, uFppu) -GO(png_get_sRGB, uFppp) -GO(png_set_interlace_handling, iFp) -GO(png_error, vFpp) -GO(png_set_gamma, vFpdd) -GO(png_sig_cmp, iFpuu) -GO(png_get_tRNS, uFppppp) -GO(png_get_gAMA, uFppp) -GO(png_read_update_info, vFpp) -GO(png_set_expand, vFp) GO(png_read_row, vFppp) -GO(png_set_sig_bytes, vFpi) -GO(png_get_PLTE, uFpppp) -GO(png_get_error_ptr, pFp) -GOM(png_set_error_fn, vFEpppp) -GOM(png_set_read_fn, vFEppp) +GO(png_read_update_info, vFpp) +GO(png_set_add_alpha, vFpui) GO(png_set_bgr, vFp) -GO(png_get_channels, CFpp) -GO(png_set_iCCP, vFpppipu) -GO(png_set_sRGB, vFppi) +GO(png_set_bKGD, vFppp) +GO(png_set_cHRM, vFppdddddddd) +GO(png_set_compression_buffer_size, vFpu) +GO(png_set_compression_level, vFpi) GO(png_set_compression_mem_level, vFpi) -GO(png_set_text, vFpppi) -GO(png_get_cHRM, uFpppppppppp) GO(png_set_compression_strategy, vFpi) -GO(png_set_gAMA, vFppd) -GOM(png_create_read_struct_2, pFEppppppp) -GO(png_get_header_ver, pFp) -GO(png_get_pHYs, uFppppp) -GO(png_set_pHYs, vFppuui) -GO(png_set_compression_buffer_size, vFpu) -GOM(png_create_write_struct_2, pFEppppppp) +GOM(png_set_error_fn, vFEpppp) +GO(png_set_expand, vFp) +GO(png_set_expand_gray_1_2_4_to_8, vFp) GO(png_set_filter, vFpii) -GO(png_set_cHRM, vFppdddddddd) -GO(png_get_iCCP, uFpppppp) -GO(png_permit_mng_features, uFpu) +GO(png_set_gAMA, vFppd) +GO(png_set_gamma, vFpdd) +GO(png_set_gray_to_rgb, vFp) +GO(png_set_gray_1_2_4_to_8, vFp) +GO(png_set_iCCP, vFpppipu) +GO(png_set_interlace_handling, iFp) GO(png_set_keep_unknown_chunks, vFpipi) GO(png_set_oFFs, vFppiii) -GO(png_get_libpng_ver, pFp) -GO(png_get_text, uFpppp) +GO(png_set_packing, vFp) +GO(png_set_palette_to_rgb, vFp) +GO(png_set_pHYs, vFppuui) +GO(png_set_PLTE, vFpppi) +GOM(png_set_progressive_read_fn, vFEppppp) GO(png_set_sBIT, vFppp) +GO(png_set_sig_bytes, vFpi) +GO(png_set_sRGB, vFppi) +GO(png_set_strip_16, vFp) +GO(png_set_swap, vFp) +GO(png_set_text, vFpppi) +GO(png_set_tIME, vFppp) GO(png_set_tRNS, vFpppip) +GO(png_set_tRNS_to_alpha, vFp) +GO(png_set_IHDR, vFppuuiiiii) +GOM(png_set_read_fn, vFEppp) +GO(png_set_rows, vFppp) +GOM(png_set_write_fn, vFEpppp) +GO(png_sig_cmp, iFpuu) GO(png_warning, vFpp) -GO(png_set_bKGD, vFppp) -GO(png_get_x_offset_pixels, iFpp) -GO(png_get_y_offset_pixels, iFpp) +GO(png_write_end, vFpp) +GO(png_write_chunk, vFpppu) GO(png_write_image, vFpp) -GO(png_get_color_type, CFpp) -GO(png_check_sig, iFpi) -GO(png_set_gray_1_2_4_to_8, vFp) -GO(png_set_swap, vFp) -GO(png_process_data, vFpppL) -GO(png_get_image_height, uFpp) -GO(png_get_image_width, uFpp) -GO(png_progressive_combine_row, vFppp) -GO(png_get_progressive_ptr, pFp) -GO(png_get_interlace_type, CFpp) -GOM(png_set_progressive_read_fn, vFEppppp) -GO(png_get_bit_depth, CFpp) -GO(png_set_bgr, vFp) \ No newline at end of file +GO(png_write_info, vFpp) +GO(png_write_png, vFppip) +GO(png_write_row, vFpp) diff --git a/src/wrapped/wrappedsdl1_private.h b/src/wrapped/wrappedsdl1_private.h index 35e0e78aad..23435fa4c7 100755 --- a/src/wrapped/wrappedsdl1_private.h +++ b/src/wrapped/wrappedsdl1_private.h @@ -73,14 +73,14 @@ GO(SDL_GetTicks, uFv) GO(SDL_GetVideoInfo, pFv) GO(SDL_GetVideoSurface, pFv) GOM(SDL_GetWMInfo, iFEp) -GOM(SDL_Has3DNow, iFv) -GOM(SDL_Has3DNowExt, iFv) -GOM(SDL_HasAltiVec, iFv) -GOM(SDL_HasMMX, iFv) -GOM(SDL_HasMMXExt, iFv) -GOM(SDL_HasRDTSC, iFv) -GOM(SDL_HasSSE, iFv) -GOM(SDL_HasSSE2, iFv) +GOM(SDL_Has3DNow, iFv) //%noE +GOM(SDL_Has3DNowExt, iFv) //%noE +GOM(SDL_HasAltiVec, iFv) //%noE +GOM(SDL_HasMMX, iFv) //%noE +GOM(SDL_HasMMXExt, iFv) //%noE +GOM(SDL_HasRDTSC, iFv) //%noE +GOM(SDL_HasSSE, iFv) //%noE +GOM(SDL_HasSSE2, iFv) //%noE GO(SDL_Init, iFu) GO(SDL_InitQuickDraw, vFp) GO(SDL_InitSubSystem, iFu) @@ -235,4 +235,4 @@ GO(SDL_MixAudio, vFppui) GO(SDL_CloseAudio, vFv) // should free callback GO(SDL_AudioDriverName, pFpi) -#endif \ No newline at end of file +#endif diff --git a/src/wrapped/wrappedsdl2.c b/src/wrapped/wrappedsdl2.c index 516c3a4ac3..64afc3b597 100755 --- a/src/wrapped/wrappedsdl2.c +++ b/src/wrapped/wrappedsdl2.c @@ -63,7 +63,7 @@ typedef union { typedef struct { - int32_t bindType; // enum + uint32_t bindType; // enum union { int button; @@ -555,19 +555,14 @@ EXPORT void my2_SDL_LogSetOutputFunction(x86emu_t* emu, void* f, void* arg) my->SDL_LogSetOutputFunction(find_LogOutput_Fct(f), arg); } -EXPORT int my2_SDL_vsnprintf(x86emu_t* emu, void* buff, uint32_t s, void * fmt, void * b, va_list V) -{ +EXPORT int my2_SDL_vsnprintf(x86emu_t* emu, void* buff, uint32_t s, void * fmt, void * b) { #ifndef NOALIGN // need to align on arm - myStackAlign((const char*)fmt, *(uint32_t**)b, emu->scratch); + myStackAlign((const char*)fmt, b, emu->scratch); PREPARE_VALIST; - void* f = vsnprintf; - int r = ((iFpupp_t)f)(buff, s, fmt, VARARGS); - return r; + return vsnprintf(buff, s, fmt, VARARGS); #else - void* f = vsnprintf; - int r = ((iFpupp_t)f)(buff, s, fmt, *(uint32_t**)b); - return r; + return vsnprintf(buff, s, fmt, b); #endif } @@ -579,15 +574,14 @@ EXPORT void* my2_SDL_CreateThread(x86emu_t* emu, void* f, void* n, void* p) return my->SDL_CreateThread(my_prepare_thread(emu, f, p, 0, &et), n, et); } -EXPORT int my2_SDL_snprintf(x86emu_t* emu, void* buff, uint32_t s, void * fmt, void * b, va_list V) { +EXPORT int my2_SDL_snprintf(x86emu_t* emu, void* buff, uint32_t s, void * fmt, void * b) { #ifndef NOALIGN // need to align on arm myStackAlign((const char*)fmt, b, emu->scratch); PREPARE_VALIST; - void* f = vsnprintf; - return ((iFpupp_t)f)(buff, s, fmt, VARARGS); + return vsnprintf(buff, s, fmt, VARARGS); #else - return vsnprintf((char*)buff, s, (char*)fmt, V); + return vsnprintf((char*)buff, s, (char*)fmt, b); #endif } @@ -844,12 +838,6 @@ EXPORT void* my2_SDL_GameControllerGetBindForButton(x86emu_t* emu, void* p, void return p; } -EXPORT void* my2_SDL_GameControllerMappingForGUID(x86emu_t* emu, void* p) -{ - sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2; - return my->SDL_GameControllerMappingForGUID(*(SDL_JoystickGUID*)p); -} - EXPORT void my2_SDL_AddEventWatch(x86emu_t* emu, void* p, void* userdata) { sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2; @@ -938,21 +926,21 @@ EXPORT int32_t my2_SDL_IsJoystickXboxOne(x86emu_t* emu, uint16_t vendor, uint16_ // fallback return 0; } -EXPORT int32_t my2_SDL_IsJoystickXInput(x86emu_t* emu, void *p) +EXPORT int32_t my2_SDL_IsJoystickXInput(x86emu_t* emu, SDL_JoystickGUID p) { sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2; if(my->SDL_IsJoystickXInput) - return my->SDL_IsJoystickXInput(*(SDL_JoystickGUID*)p); + return my->SDL_IsJoystickXInput(p); // fallback return 0; } -EXPORT int32_t my2_SDL_IsJoystickHIDAPI(x86emu_t* emu, void *p) +EXPORT int32_t my2_SDL_IsJoystickHIDAPI(x86emu_t* emu, SDL_JoystickGUID p) { sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2; if(my->SDL_IsJoystickHIDAPI) - return my->SDL_IsJoystickHIDAPI(*(SDL_JoystickGUID*)p); + return my->SDL_IsJoystickHIDAPI(p); // fallback return 0; } diff --git a/src/wrapped/wrappedsdl2_private.h b/src/wrapped/wrappedsdl2_private.h index 944381ef45..096d41f29f 100755 --- a/src/wrapped/wrappedsdl2_private.h +++ b/src/wrapped/wrappedsdl2_private.h @@ -2,8 +2,8 @@ #error Meh! #endif -//%S J SDL_JoystickGUID -//%S g SDL_GameControllerButtonBind +//%S J SDL_JoystickGUID uuuu +//%S g SDL_GameControllerButtonBind uii // _fini // _init @@ -132,8 +132,8 @@ GO(SDL_GameControllerFromInstanceID, pFi) GO(SDL_GameControllerGetAttached, iFp) GO(SDL_GameControllerGetAxis, iFpi) GO(SDL_GameControllerGetAxisFromString, uFp) -GOS(SDL_GameControllerGetBindForAxis, pFEppi) //%g -GOS(SDL_GameControllerGetBindForButton, pFEppi) //%g +GOS(SDL_GameControllerGetBindForAxis, gFEpi) +GOS(SDL_GameControllerGetBindForButton, gFEpi) GO(SDL_GameControllerGetButton, uFpi) GO(SDL_GameControllerGetButtonFromString, uFp) GO(SDL_GameControllerGetJoystick, pFp) @@ -149,7 +149,7 @@ GO(SDL_GameControllerHasLED, iFp) GO(SDL_GameControllerHasSensor, iFpi) GO(SDL_GameControllerMapping, pFp) GO(SDL_GameControllerMappingForDeviceIndex, pFi) -GOM(SDL_GameControllerMappingForGUID, pFEV) //%{pFJ} +GO(SDL_GameControllerMappingForGUID, pFJ) GO(SDL_GameControllerMappingForIndex, pFi) GO(SDL_GameControllerName, pFp) GO(SDL_GameControllerNameForIndex, pFi) @@ -195,7 +195,7 @@ GO(SDL_GetGlobalMouseState, uFpp) GO(SDL_GetGrabbedWindow, pFv) GO(SDL_GetHint, pFp) GO(SDL_GetHintBoolean, iFpi) -GOM(SDL_GetJoystickGUIDInfo, vFEuuuuppp) //%{vFJppp} +GOM(SDL_GetJoystickGUIDInfo, vFEJppp) GO(SDL_GetKeyboardFocus, pFv) GO(SDL_GetKeyboardState, pFp) GO(SDL_GetKeyFromName, pFp) @@ -319,25 +319,25 @@ GO(SDL_HapticStopAll, iFp) GO(SDL_HapticStopEffect, iFpi) GO(SDL_HapticUnpause, iFp) GO(SDL_HapticUpdateEffect, iFpip) -GOM(SDL_Has3DNow, iFv) -GOM(SDL_HasAltiVec, iFv) -GOM(SDL_HasAVX, iFv) -GOM(SDL_HasAVX2, iFv) -GOM(SDL_HasAVX512F, iFv) +GOM(SDL_Has3DNow, iFv) //%%,noE +GOM(SDL_HasAltiVec, iFv) //%%,noE +GOM(SDL_HasAVX, iFv) //%%,noE +GOM(SDL_HasAVX2, iFv) //%%,noE +GOM(SDL_HasAVX512F, iFv) //%%,noE GO(SDL_HasClipboardText, iFv) GO(SDL_HasColorKey, iFv) GO(SDL_HasEvent, iFv) GO(SDL_HasEvents, iFv) GO(SDL_HasIntersection, iFpp) -GOM(SDL_HasMMX, iFv) -GOM(SDL_HasNEON, iFv) -GOM(SDL_HasRDTSC, iFv) +GOM(SDL_HasMMX, iFv) //%%,noE +GOM(SDL_HasNEON, iFv) //%%,noE +GOM(SDL_HasRDTSC, iFv) //%%,noE GO(SDL_HasScreenKeyboardSupport, iFv) -GOM(SDL_HasSSE, iFv) -GOM(SDL_HasSSE2, iFv) -GOM(SDL_HasSSE3, iFv) -GOM(SDL_HasSSE41, iFv) -GOM(SDL_HasSSE42, iFv) +GOM(SDL_HasSSE, iFv) //%%,noE +GOM(SDL_HasSSE2, iFv) //%%,noE +GOM(SDL_HasSSE3, iFv) //%%,noE +GOM(SDL_HasSSE41, iFv) //%%,noE +GOM(SDL_HasSSE42, iFv) //%%,noE GO(SDL_HideWindow, vFp) GO(SDL_iconv, LFppppp) GO(SDL_iconv_close, iFp) @@ -365,15 +365,15 @@ GO(SDL_JoystickGetAxis, iFpi) GO(SDL_JoystickGetAxisInitialState, iFpip) GO(SDL_JoystickGetBall, iFpipp) GO(SDL_JoystickGetButton, CFpi) -GOS(SDL_JoystickGetDeviceGUID, pFEpi) //%J +GOS(SDL_JoystickGetDeviceGUID, JFEi) GO(SDL_JoystickGetDeviceInstanceID, iFi) GO(SDL_JoystickGetDevicePlayerIndex, iFi) GO(SDL_JoystickGetDeviceProduct, WFi) GO(SDL_JoystickGetDeviceProductVersion, WFi) GO(SDL_JoystickGetDeviceType, iFi) GO(SDL_JoystickGetDeviceVendor, WFi) -GOS(SDL_JoystickGetGUID, pFEpp) //%J -GOS(SDL_JoystickGetGUIDFromString, pFEpp) //%J +GOS(SDL_JoystickGetGUID, JFEp) +GOS(SDL_JoystickGetGUIDFromString, JFEp) GO(SDL_JoystickGetGUIDString, vFUUpi) //uint8_t data[16] passed as 1st argument... GO(SDL_JoystickGetHat, CFpi) GO(SDL_JoystickGetPlayerIndex, iFp) @@ -549,7 +549,7 @@ GO(SDL_SetClipRect, iFpp) GO(SDL_SetColorKey, iFpiu) GO(SDL_SetCursor, vFp) GO(SDL_setenv, iFppi) -GO(SDL_SetError, iFppppp) // it use ..., so putarbitrary 4 args +GO(SDL_SetError, iFppppp) // it use ..., so put arbitrary 4 args GOM(SDL_SetEventFilter, vFEpp) GO(SDL_SetHint, iFpp) GO(SDL_SetHintWithPriority, iFppi) @@ -598,7 +598,7 @@ GO(SDL_ShowSimpleMessageBox, iFuppp) GO(SDL_ShowWindow, vFp) GO(SDL_sin, dFd) GO(SDL_sinf, fFf) -GOM(SDL_snprintf, iFEpupVV) +GOM(SDL_snprintf, iFEpupV) GO(SDL_SoftStretch, iFpppp) GO(SDL_sqrt, dFd) GO(SDL_sqrtf, fFf) @@ -654,7 +654,7 @@ GO(SDL_utf8strlcpy, uFppu) // SDL_utf8strlen GO(SDL_VideoInit, iFp) GO(SDL_VideoQuit, vFv) -GOM(SDL_vsnprintf, iFEpupVV) +GOM(SDL_vsnprintf, iFEpupV) // SDL_vsscanf GO(SDL_Vulkan_CreateSurface, iFppp) GO(SDL_Vulkan_GetDrawableSize, vFppp) @@ -697,5 +697,5 @@ GOM(SDL_IsJoystickNintendoSwitchPro, iFEWW) GOM(SDL_IsJoystickSteamController, iFEWW) GOM(SDL_IsJoystickXbox360, iFEWW) GOM(SDL_IsJoystickXboxOne, iFEWW) -GOM(SDL_IsJoystickXInput, iFEV) //%{iFJ} -GOM(SDL_IsJoystickHIDAPI, iFEV) //%{iFJ} +GOM(SDL_IsJoystickXInput, iFEJ) +GOM(SDL_IsJoystickHIDAPI, iFEJ) diff --git a/src/wrapped/wrappedsdl2mixer_private.h b/src/wrapped/wrappedsdl2mixer_private.h index 58d8e371fa..db332fe76d 100755 --- a/src/wrapped/wrappedsdl2mixer_private.h +++ b/src/wrapped/wrappedsdl2mixer_private.h @@ -62,7 +62,6 @@ GO(Mix_QuerySpec,iFppp) GO(Mix_QuickLoad_RAW,pFpu) GO(Mix_QuickLoad_WAV,pFp) GO(Mix_Quit,vFv) -GO(Mix_Pause, vFi) GOM(Mix_RegisterEffect, iFEippp) GO(Mix_ReserveChannels,iFi) GO(Mix_Resume,vFi) @@ -83,4 +82,3 @@ GOM(Mix_UnregisterEffect, iFEip) GO(Mix_Volume,iFii) GO(Mix_VolumeChunk,iFpi) GO(Mix_VolumeMusic,iFi) - diff --git a/src/wrapped/wrappedtcmallocminimal_private.h b/src/wrapped/wrappedtcmallocminimal_private.h index 4bc2f317ea..d7fc06da86 100755 --- a/src/wrapped/wrappedtcmallocminimal_private.h +++ b/src/wrapped/wrappedtcmallocminimal_private.h @@ -76,8 +76,6 @@ GOM(munmap, iFEpL) GO(nallocx, LFLi) GO(__posix_memalign, iFpuu) GO(posix_memalign, iFpuu) -GO(__libc_pvalloc, pFL) -GO(__libc_realloc, pFpL) //GO(RunningOnValgrind, GO(sbrk, pFl) //GO(tc_calloc, diff --git a/src/wrapped/wrappedxml2_private.h b/src/wrapped/wrappedxml2_private.h index 933c04b523..cb0c143ad0 100755 --- a/src/wrapped/wrappedxml2_private.h +++ b/src/wrapped/wrappedxml2_private.h @@ -407,7 +407,7 @@ GO(xmlGetUTF8Char, iFpp) //GO(__xmlGlobalInitMutexLock, //GO(__xmlGlobalInitMutexUnlock, GO(xmlHandleEntity, vFpp) // obsolete, might be removed -//GO(xmlHasFeature, +GO(xmlHasFeature, iFi) GO(xmlHasNsProp, pFppp) GO(xmlHasProp, pFpp) GO(xmlHashAddEntry, iFppp) @@ -416,7 +416,6 @@ GO(xmlHashAddEntry3, iFppppp) GOM(xmlHashCopy, pFEpp) GO(xmlHashCreate, pFi) GO(xmlHashCreateDict, pFip) -GO(xmlHasFeature, iFi) GOM(xmlHashFree, vFEpp) GO(xmlHashLookup, pFpp) GO(xmlHashLookup2, pFppp) @@ -435,8 +434,6 @@ GO(xmlHashSize, iFp) GOM(xmlHashUpdateEntry, iFEpppp) GOM(xmlHashUpdateEntry2, iFEppppp) GOM(xmlHashUpdateEntry3, iFEpppppp) -GO(xmlHasNsProp, pFppp) -GO(xmlHasProp, pFpp) //GO(__xmlIndentTreeOutput, GO(xmlInitCharEncodingHandlers, vFv) GO(xmlInitializeDict, iFv) @@ -1608,4 +1605,4 @@ GO(xmlXPathWrapString, pFp) DATAM(xmlFree, 4) DATAM(xmlMalloc, 4) DATAM(xmlRealloc, 4) -DATAM(xmlMemStrdup, 4) \ No newline at end of file +DATAM(xmlMemStrdup, 4)