Ros-diffs

ros-diffs@reactos.org

81390 discussions

05/06: [ZIPFLDR] Initial implementation. Icon by Jared Smudde CORE-7684
by Mark Jansen 07 Apr '18

07 Apr '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=c7e6a9d04b08131fd1bc6… commit c7e6a9d04b08131fd1bc6b5ed70d1b9e4bf8140a Author: Mark Jansen <mark.jansen(a)reactos.org> AuthorDate: Fri Dec 29 23:45:02 2017 +0100 Commit: Mark Jansen <mark.jansen(a)reactos.org> CommitDate: Sat Apr 7 15:29:59 2018 +0200 [ZIPFLDR] Initial implementation. Icon by Jared Smudde CORE-7684 --- dll/shellext/CMakeLists.txt | 1 + dll/shellext/zipfldr/CEnumZipContents.cpp | 95 +++++ dll/shellext/zipfldr/CExplorerCommand.cpp | 189 +++++++++ dll/shellext/zipfldr/CFolderViewCB.cpp | 54 +++ dll/shellext/zipfldr/CMakeLists.txt | 50 +++ dll/shellext/zipfldr/CZipEnumerator.hpp | 94 +++++ dll/shellext/zipfldr/CZipExtract.cpp | 481 +++++++++++++++++++++++ dll/shellext/zipfldr/CZipFolder.hpp | 625 ++++++++++++++++++++++++++++++ dll/shellext/zipfldr/Debug.cpp | 44 +++ dll/shellext/zipfldr/IZip.hpp | 12 + dll/shellext/zipfldr/precomp.h | 62 +++ dll/shellext/zipfldr/res/zipfldr.ico | Bin 0 -> 26070 bytes dll/shellext/zipfldr/res/zipfldr.rgs | 54 +++ dll/shellext/zipfldr/resource.h | 58 +++ dll/shellext/zipfldr/zipfldr.cpp | 117 ++++++ dll/shellext/zipfldr/zipfldr.rc | 88 +++++ dll/shellext/zipfldr/zipfldr.spec | 5 + dll/shellext/zipfldr/zippidl.cpp | 42 ++ dll/shellext/zipfldr/zippidl.hpp | 34 ++ 19 files changed, 2105 insertions(+) diff --git a/dll/shellext/CMakeLists.txt b/dll/shellext/CMakeLists.txt index 56fabe1299..e11df36001 100644 --- a/dll/shellext/CMakeLists.txt +++ b/dll/shellext/CMakeLists.txt @@ -8,3 +8,4 @@ add_subdirectory(netshell) add_subdirectory(ntobjshex) add_subdirectory(shellbtrfs) add_subdirectory(stobject) +add_subdirectory(zipfldr) diff --git a/dll/shellext/zipfldr/CEnumZipContents.cpp b/dll/shellext/zipfldr/CEnumZipContents.cpp new file mode 100644 index 0000000000..f135fe756f --- /dev/null +++ b/dll/shellext/zipfldr/CEnumZipContents.cpp @@ -0,0 +1,95 @@ +/* + * PROJECT: ReactOS Zip Shell Extension + * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * PURPOSE: CEnumZipContents + * COPYRIGHT: Copyright 2017 Mark Jansen (mark.jansen(a)reactos.org) + */ + +#include "precomp.h" + +class CEnumZipContents : + public CComObjectRootEx<CComMultiThreadModelNoCS>, + public IEnumIDList +{ +private: + CZipEnumerator mEnumerator; + DWORD dwFlags; + CStringA m_Prefix; +public: + CEnumZipContents() + :dwFlags(0) + { + } + + STDMETHODIMP Initialize(IZip* zip, DWORD flags, const char* prefix) + { + dwFlags = flags; + m_Prefix = prefix; + if (mEnumerator.initialize(zip)) + return S_OK; + return E_FAIL; + } + + // *** IEnumIDList methods *** + STDMETHODIMP Next(ULONG celt, LPITEMIDLIST *rgelt, ULONG *pceltFetched) + { + if (!pceltFetched || !rgelt) + return E_POINTER; + + *pceltFetched = 0; + + if (celt != 1) + return E_FAIL; + + CStringA name; + bool dir; + unz_file_info64 info; + if (mEnumerator.next_unique(m_Prefix, name, dir, info)) + { + *pceltFetched = 1; + *rgelt = _ILCreate(dir ? ZIP_PIDL_DIRECTORY : ZIP_PIDL_FILE, name, info); + return S_OK; + } + + return S_FALSE; + } + STDMETHODIMP Skip(ULONG celt) + { + CStringA name; + bool dir; + unz_file_info64 info; + while (celt--) + { + if (!mEnumerator.next_unique(m_Prefix, name, dir, info)) + return E_FAIL; + ; + } + return S_OK; + } + STDMETHODIMP Reset() + { + if (mEnumerator.reset()) + return S_OK; + return E_FAIL; + } + STDMETHODIMP Clone(IEnumIDList **ppenum) + { + return E_NOTIMPL; + } + + +public: + DECLARE_NOT_AGGREGATABLE(CEnumZipContents) + DECLARE_PROTECT_FINAL_CONSTRUCT() + + BEGIN_COM_MAP(CEnumZipContents) + COM_INTERFACE_ENTRY_IID(IID_IEnumIDList, IEnumIDList) + END_COM_MAP() +}; + + +HRESULT _CEnumZipContents_CreateInstance(IZip* zip, DWORD flags, const char* prefix, REFIID riid, LPVOID * ppvOut) +{ + return ShellObjectCreatorInit<CEnumZipContents>(zip, flags, prefix, riid, ppvOut); +} + diff --git a/dll/shellext/zipfldr/CExplorerCommand.cpp b/dll/shellext/zipfldr/CExplorerCommand.cpp new file mode 100644 index 0000000000..1e634f81c8 --- /dev/null +++ b/dll/shellext/zipfldr/CExplorerCommand.cpp @@ -0,0 +1,189 @@ +/* + * PROJECT: ReactOS Zip Shell Extension + * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * PURPOSE: IExplorerCommand implementation + * COPYRIGHT: Copyright 2017 Mark Jansen (mark.jansen(a)reactos.org) + */ + +#include "precomp.h" + +class CExplorerCommand : + public CComObjectRootEx<CComMultiThreadModelNoCS>, + public IExplorerCommand +{ +private: + CComPtr<IContextMenu> m_pZipObject; + +public: + + STDMETHODIMP Initialize(IContextMenu* zipObject) + { + m_pZipObject = zipObject; + return S_OK; + } + + // *** IExplorerCommand methods *** + STDMETHODIMP GetTitle(IShellItemArray *psiItemArray, LPWSTR *ppszName) + { + CStringW Title(MAKEINTRESOURCEW(IDS_MENUITEM)); + return SHStrDup(Title, ppszName); + } + STDMETHODIMP GetIcon(IShellItemArray *psiItemArray, LPWSTR *ppszIcon) + { + CStringW IconName = L"zipfldr.dll,-1"; + return SHStrDup(IconName, ppszIcon); + } + STDMETHODIMP GetToolTip(IShellItemArray *psiItemArray, LPWSTR *ppszInfotip) + { + CStringW HelpText(MAKEINTRESOURCEW(IDS_HELPTEXT)); + return SHStrDup(HelpText, ppszInfotip); + } + STDMETHODIMP GetCanonicalName(GUID *pguidCommandName) + { + *pguidCommandName = CLSID_ZipFolderExtractAllCommand; + return S_OK; + } + STDMETHODIMP GetState(IShellItemArray *psiItemArray, BOOL fOkToBeSlow, EXPCMDSTATE *pCmdState) + { + *pCmdState = ECS_ENABLED; + return S_OK; + } + STDMETHODIMP Invoke(IShellItemArray *psiItemArray, IBindCtx *pbc) + { + CMINVOKECOMMANDINFO cm = { sizeof(cm), 0 }; + cm.lpVerb = EXTRACT_VERBA; + cm.nShow = SW_SHOW; + return m_pZipObject->InvokeCommand(&cm); + } + STDMETHODIMP GetFlags(EXPCMDFLAGS *pFlags) + { + *pFlags = ECF_DEFAULT; + return S_OK; + } + STDMETHODIMP EnumSubCommands(IEnumExplorerCommand **ppEnum) + { + DbgPrint("%s\n", __FUNCTION__); + return E_NOTIMPL; + } + +public: + DECLARE_NOT_AGGREGATABLE(CExplorerCommand) + DECLARE_PROTECT_FINAL_CONSTRUCT() + + BEGIN_COM_MAP(CExplorerCommand) + COM_INTERFACE_ENTRY_IID(IID_IExplorerCommand, IExplorerCommand) + END_COM_MAP() +}; + + +class CEnumExplorerCommand : + public CComObjectRootEx<CComMultiThreadModelNoCS>, + public IEnumExplorerCommand +{ +private: + bool m_bFirst; + CComPtr<IContextMenu> m_pZipObject; + +public: + + CEnumExplorerCommand() + :m_bFirst(true) + { + } + + STDMETHODIMP Initialize(IContextMenu* zipObject) + { + m_pZipObject = zipObject; + return S_OK; + } + + // *** IEnumExplorerCommand methods *** + STDMETHODIMP Next(ULONG celt, IExplorerCommand **pUICommand, ULONG *pceltFetched) + { + if (!pUICommand) + return E_POINTER; + + if (pceltFetched) + *pceltFetched = 0; + if (m_bFirst && celt) + { + m_bFirst = false; + celt--; + HRESULT hr = ShellObjectCreatorInit<CExplorerCommand>(m_pZipObject, IID_PPV_ARG(IExplorerCommand, pUICommand)); + if (SUCCEEDED(hr)) + { + if (pceltFetched) + *pceltFetched = 1; + } + return hr; + } + return S_FALSE; + } + STDMETHODIMP Skip(ULONG celt) + { + if (m_bFirst) + { + m_bFirst = false; + return S_OK; + } + return S_FALSE; + } + STDMETHODIMP Reset() + { + m_bFirst = true; + return S_OK; + } + STDMETHODIMP Clone(IEnumExplorerCommand **ppenum) + { + return E_NOTIMPL; + } + +public: + DECLARE_NOT_AGGREGATABLE(CEnumExplorerCommand) + DECLARE_PROTECT_FINAL_CONSTRUCT() + + BEGIN_COM_MAP(CEnumExplorerCommand) + COM_INTERFACE_ENTRY_IID(IID_IEnumExplorerCommand, IEnumExplorerCommand) + END_COM_MAP() +}; + +class CExplorerCommandProvider : + public CComObjectRootEx<CComMultiThreadModelNoCS>, + public IExplorerCommandProvider +{ +private: + CComPtr<IContextMenu> m_pZipObject; + +public: + STDMETHODIMP Initialize(IContextMenu* zipObject) + { + m_pZipObject = zipObject; + return S_OK; + } + + // *** IExplorerCommandProvider methods *** + STDMETHODIMP GetCommands(IUnknown *punkSite, REFIID riid, void **ppv) + { + return ShellObjectCreatorInit<CEnumExplorerCommand>(m_pZipObject, riid, ppv); + } + STDMETHODIMP GetCommand(REFGUID rguidCommandId, REFIID riid, void **ppv) + { + UNIMPLEMENTED; + *ppv = NULL; + return E_NOTIMPL; + } + +public: + DECLARE_NOT_AGGREGATABLE(CExplorerCommandProvider) + DECLARE_PROTECT_FINAL_CONSTRUCT() + + BEGIN_COM_MAP(CExplorerCommandProvider) + COM_INTERFACE_ENTRY_IID(IID_IExplorerCommandProvider, IExplorerCommandProvider) + END_COM_MAP() +}; + + +HRESULT _CExplorerCommandProvider_CreateInstance(IContextMenu* zipObject, REFIID riid, LPVOID * ppvOut) +{ + return ShellObjectCreatorInit<CExplorerCommandProvider>(zipObject, riid, ppvOut); +} diff --git a/dll/shellext/zipfldr/CFolderViewCB.cpp b/dll/shellext/zipfldr/CFolderViewCB.cpp new file mode 100644 index 0000000000..2a46f6576a --- /dev/null +++ b/dll/shellext/zipfldr/CFolderViewCB.cpp @@ -0,0 +1,54 @@ +/* + * PROJECT: ReactOS Zip Shell Extension + * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * PURPOSE: IShellFolderViewCB implementation + * COPYRIGHT: Copyright 2017 David Quintana (gigaherz(a)gmail.com) + * Copyright 2017 Mark Jansen (mark.jansen(a)reactos.org) + */ + +#include "precomp.h" + +class CFolderViewCB : + public CComObjectRootEx<CComMultiThreadModelNoCS>, + public IShellFolderViewCB +{ +public: + + virtual ~CFolderViewCB() + { + } + + // *** IShellFolderViewCB methods *** + STDMETHODIMP MessageSFVCB(UINT uMsg, WPARAM wParam, LPARAM lParam) + { + /* TODO: Handle SFVM_GET_WEBVIEW_CONTENT to add tasks */ + switch (uMsg) + { + case SFVM_DEFVIEWMODE: + { + FOLDERVIEWMODE* pViewMode = (FOLDERVIEWMODE*)lParam; + *pViewMode = FVM_DETAILS; + return S_OK; + } + case SFVM_COLUMNCLICK: + return S_FALSE; + case SFVM_BACKGROUNDENUM: + return S_OK; + } + + return E_NOTIMPL; + } + +public: + DECLARE_NOT_AGGREGATABLE(CFolderViewCB) + DECLARE_PROTECT_FINAL_CONSTRUCT() + + BEGIN_COM_MAP(CFolderViewCB) + COM_INTERFACE_ENTRY_IID(IID_IShellFolderViewCB, IShellFolderViewCB) + END_COM_MAP() +}; + +HRESULT _CFolderViewCB_CreateInstance(REFIID riid, LPVOID * ppvOut) +{ + return ShellObjectCreator<CFolderViewCB>(riid, ppvOut); +} diff --git a/dll/shellext/zipfldr/CMakeLists.txt b/dll/shellext/zipfldr/CMakeLists.txt new file mode 100644 index 0000000000..d491f1d7c2 --- /dev/null +++ b/dll/shellext/zipfldr/CMakeLists.txt @@ -0,0 +1,50 @@ + +set_cpp(WITH_RUNTIME WITH_EXCEPTIONS) +if(NOT MSVC) + # HACK: this should be enabled globally! + add_compile_flags_language("-std=c++11" "CXX") +endif() + +remove_definitions(-D_WIN32_WINNT=0x502) +add_definitions(-D_WIN32_WINNT=0x600) + +add_definitions( + -D_ATL_NO_EXCEPTIONS) + +include_directories( + ${REACTOS_SOURCE_DIR}/sdk/include/reactos/libs/zlib + ${REACTOS_SOURCE_DIR}/sdk/lib/atl + ${REACTOS_SOURCE_DIR}/sdk/lib/3rdparty/zlib/contrib) + +spec2def(zipfldr.dll zipfldr.spec ADD_IMPORTLIB) + + +list(APPEND SOURCE + zipfldr.cpp + zippidl.cpp + zippidl.hpp + IZip.hpp + CExplorerCommand.cpp + CEnumZipContents.cpp + CFolderViewCB.cpp + CZipEnumerator.hpp + CZipExtract.cpp + CZipFolder.hpp + Debug.cpp + zipfldr.spec + precomp.h + resource.h) + +add_library(zipfldr SHARED + ${SOURCE} + ${ZLIB_SOURCE} + zipfldr.rc + ${CMAKE_CURRENT_BINARY_DIR}/zipfldr.def) + + +set_module_type(zipfldr win32dll UNICODE) +target_link_libraries(zipfldr minizip zlib atlnew uuid) +add_importlibs(zipfldr oleaut32 ole32 shlwapi comctl32 shell32 user32 advapi32 msvcrt kernel32 ntdll) +add_pch(zipfldr precomp.h SOURCE) +add_cd_file(TARGET zipfldr DESTINATION reactos/system32 FOR all) + diff --git a/dll/shellext/zipfldr/CZipEnumerator.hpp b/dll/shellext/zipfldr/CZipEnumerator.hpp new file mode 100644 index 0000000000..2c36aac2ea --- /dev/null +++ b/dll/shellext/zipfldr/CZipEnumerator.hpp @@ -0,0 +1,94 @@ +/* + * PROJECT: ReactOS Zip Shell Extension + * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * PURPOSE: CZipEnumerator + * COPYRIGHT: Copyright 2017 Mark Jansen (mark.jansen(a)reactos.org) + */ + +struct CZipEnumerator +{ +private: + CComPtr<IZip> m_Zip; + bool m_First; + CAtlList<CStringA> m_Returned; +public: + CZipEnumerator() + :m_First(true) + { + } + + bool initialize(IZip* zip) + { + m_Zip = zip; + return reset(); + } + + bool reset() + { + unzFile uf = m_Zip->getZip(); + m_First = true; + if (unzGoToFirstFile(uf) != UNZ_OK) + return false; + m_Returned.RemoveAll(); + return true; + } + + bool next_unique(const char* prefix, CStringA& name, bool& folder, unz_file_info64& info) + { + size_t len = strlen(prefix); + CStringA tmp; + while (next(tmp, info)) + { + if (!_strnicmp(tmp, prefix, len)) + { + int pos = tmp.Find('/', len); + if (pos < 0) + { + name = tmp.Mid(len); + folder = false; + } + else + { + name = tmp.Mid(len, pos - len); + folder = true; + } + tmp = name.MakeLower(); + + POSITION it = m_Returned.Find(tmp); + if (!name.IsEmpty() && !it) + { + m_Returned.AddTail(tmp); + return true; + } + } + } + return false; + } + + bool next(CStringA& name, unz_file_info64& info) + { + int err; + + unzFile uf = m_Zip->getZip(); + if (!m_First) + { + err = unzGoToNextFile(uf); + if (err == UNZ_END_OF_LIST_OF_FILE) + { + return false; + } + } + m_First = false; + + err = unzGetCurrentFileInfo64(uf, &info, NULL, 0, NULL, 0, NULL, 0); + if (err == UNZ_OK) + { + PSTR buf = name.GetBuffer(info.size_filename); + err = unzGetCurrentFileInfo64(uf, NULL, buf, name.GetAllocLength(), NULL, 0, NULL, 0); + name.ReleaseBuffer(info.size_filename); + name.Replace('\\', '/'); + } + return err == UNZ_OK; + } +}; + diff --git a/dll/shellext/zipfldr/CZipExtract.cpp b/dll/shellext/zipfldr/CZipExtract.cpp new file mode 100644 index 0000000000..5fbebefbb7 --- /dev/null +++ b/dll/shellext/zipfldr/CZipExtract.cpp @@ -0,0 +1,481 @@ +/* + * PROJECT: ReactOS Zip Shell Extension + * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * PURPOSE: Zip extraction + * COPYRIGHT: Copyright 2017 Mark Jansen (mark.jansen(a)reactos.org) + */ + +#include "precomp.h" + +class CZipExtract : + public IZip +{ + CStringW m_Filename; + CStringW m_Directory; + unzFile uf; +public: + CZipExtract(PCWSTR Filename) + :uf(NULL) + { + m_Filename = Filename; + m_Directory = m_Filename; + PWSTR Dir = m_Directory.GetBuffer(); + PathRemoveExtensionW(Dir); + m_Directory.ReleaseBuffer(); + } + + ~CZipExtract() + { + if (uf) + { + DPRINT1("WARNING: uf not closed!\n"); + Close(); + } + } + + void Close() + { + if (uf) + unzClose(uf); + uf = NULL; + } + + // *** IZip methods *** + STDMETHODIMP QueryInterface(REFIID riid, void **ppvObject) + { + if (riid == IID_IUnknown) + { + *ppvObject = this; + AddRef(); + return S_OK; + } + return E_NOINTERFACE; + } + STDMETHODIMP_(ULONG) AddRef(void) + { + return 2; + } + STDMETHODIMP_(ULONG) Release(void) + { + return 1; + } + STDMETHODIMP_(unzFile) getZip() + { + return uf; + } + + class CConfirmReplace : public CDialogImpl<CConfirmReplace> + { + private: + CStringA m_Filename; + public: + enum DialogResult + { + Yes, + YesToAll, + No, + Cancel + }; + + static DialogResult ShowDlg(HWND hDlg, PCSTR FullPath) + { + PCSTR Filename = PathFindFileNameA(FullPath); + CConfirmReplace confirm(Filename); + INT_PTR Result = confirm.DoModal(hDlg); + switch (Result) + { + case IDYES: return Yes; + case IDYESALL: return YesToAll; + default: + case IDNO: return No; + case IDCANCEL: return Cancel; + } + } + + CConfirmReplace(const char* filename) + { + m_Filename = filename; + } + + LRESULT OnInitDialog(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) + { + CenterWindow(GetParent()); + + HICON hIcon = LoadIcon(NULL, IDI_EXCLAMATION); + SendDlgItemMessage(IDC_EXCLAMATION_ICON, STM_SETICON, (WPARAM)hIcon); + + /* Our CString does not support FormatMessage yet */ + CStringA message(MAKEINTRESOURCE(IDS_OVERWRITEFILE_TEXT)); + CHeapPtr<CHAR, CLocalAllocator> formatted; + + DWORD_PTR args[2] = + { + (DWORD_PTR)m_Filename.GetString(), + NULL + }; + + ::FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_ARGUMENT_ARRAY, + message, 0, 0, (LPSTR)&formatted, 0, (va_list*)args); + + ::SetDlgItemTextA(m_hWnd, IDC_MESSAGE, formatted); + return 0; + } + + LRESULT OnButton(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) + { + EndDialog(wID); + return 0; + } + + public: + enum { IDD = IDD_CONFIRM_FILE_REPLACE }; + + BEGIN_MSG_MAP(CConfirmReplace) + MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) + COMMAND_ID_HANDLER(IDYES, OnButton) + COMMAND_ID_HANDLER(IDYESALL, OnButton) + COMMAND_ID_HANDLER(IDNO, OnButton) + COMMAND_ID_HANDLER(IDCANCEL, OnButton) + END_MSG_MAP() + }; + + + class CExtractSettingsPage : public CPropertyPageImpl<CExtractSettingsPage> + { + private: + CZipExtract* m_pExtract; + + public: + CExtractSettingsPage(CZipExtract* extract) + :CPropertyPageImpl<CExtractSettingsPage>(MAKEINTRESOURCE(IDS_WIZ_TITLE)) + ,m_pExtract(extract) + { + m_psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_WIZ_DEST_TITLE); + m_psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_WIZ_DEST_SUBTITLE); + m_psp.dwFlags |= PSP_USETITLE | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE; + } + + int OnSetActive() + { + SetDlgItemTextW(IDC_DIRECTORY, m_pExtract->m_Directory); + ::EnableWindow(GetDlgItem(IDC_PASSWORD), FALSE); /* Not supported for now */ + GetParent().CenterWindow(::GetDesktopWindow()); + return 0; + } + + int OnWizardNext() + { + ::EnableWindow(GetDlgItem(IDC_BROWSE), FALSE); + ::EnableWindow(GetDlgItem(IDC_DIRECTORY), FALSE); + ::EnableWindow(GetDlgItem(IDC_PASSWORD), FALSE); + + if (!m_pExtract->Extract(m_hWnd, GetDlgItem(IDC_PROGRESS))) + { + /* Extraction failed, do not go to the next page */ + SetWindowLongPtr(DWLP_MSGRESULT, -1); + + ::EnableWindow(GetDlgItem(IDC_BROWSE), TRUE); + ::EnableWindow(GetDlgItem(IDC_DIRECTORY), TRUE); + ::EnableWindow(GetDlgItem(IDC_PASSWORD), FALSE); /* Not supported for now */ + + return TRUE; + } + return 0; + } + + struct browse_info + { + HWND hWnd; + LPCWSTR Directory; + }; + + static INT CALLBACK s_BrowseCallbackProc(HWND hWnd, UINT uMsg, LPARAM lp, LPARAM pData) + { + if (uMsg == BFFM_INITIALIZED) + { + browse_info* info = (browse_info*)pData; + CWindow dlg(hWnd); + dlg.SendMessage(BFFM_SETSELECTION, TRUE, (LPARAM)info->Directory); + dlg.CenterWindow(info->hWnd); + } + return 0; + } + + LRESULT OnBrowse(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) + { + BROWSEINFOW bi = { m_hWnd }; + WCHAR path[MAX_PATH]; + bi.pszDisplayName = path; + bi.lpfn = s_BrowseCallbackProc; + bi.ulFlags = BIF_NEWDIALOGSTYLE | BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS; + CStringW title(MAKEINTRESOURCEW(IDS_WIZ_BROWSE_TITLE)); + bi.lpszTitle = title; + + browse_info info = { m_hWnd, m_pExtract->m_Directory.GetString() }; + bi.lParam = (LPARAM)&info; + + CComHeapPtr<ITEMIDLIST> pidl; + pidl.Attach(SHBrowseForFolderW(&bi)); + + WCHAR tmpPath[MAX_PATH]; + if (pidl && SHGetPathFromIDListW(pidl, tmpPath)) + { + m_pExtract->m_Directory = tmpPath; + SetDlgItemTextW(IDC_DIRECTORY, m_pExtract->m_Directory); + } + return 0; + } + + LRESULT OnPassword(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) + { + return 0; + } + + public: + enum { IDD = IDD_PROPPAGEDESTIONATION }; + + BEGIN_MSG_MAP(CCompleteSettingsPage) + COMMAND_ID_HANDLER(IDC_BROWSE, OnBrowse) + COMMAND_ID_HANDLER(IDC_PASSWORD, OnPassword) + CHAIN_MSG_MAP(CPropertyPageImpl<CExtractSettingsPage>) + END_MSG_MAP() + }; + + + class CCompleteSettingsPage : public CPropertyPageImpl<CCompleteSettingsPage> + { + private: + CZipExtract* m_pExtract; + + public: + CCompleteSettingsPage(CZipExtract* extract) + :CPropertyPageImpl<CCompleteSettingsPage>(MAKEINTRESOURCE(IDS_WIZ_TITLE)) + , m_pExtract(extract) + { + m_psp.pszHeaderTitle = MAKEINTRESOURCE(IDS_WIZ_COMPL_TITLE); + m_psp.pszHeaderSubTitle = MAKEINTRESOURCE(IDS_WIZ_COMPL_SUBTITLE); + m_psp.dwFlags |= PSP_USETITLE | PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE; + } + + + int OnSetActive() + { + SetWizardButtons(PSWIZB_FINISH); + CStringW Path = m_pExtract->m_Directory; + PWSTR Ptr = Path.GetBuffer(); + RECT rc; + ::GetWindowRect(GetDlgItem(IDC_DESTDIR), &rc); + HDC dc = GetDC(); + PathCompactPathW(dc, Ptr, rc.right - rc.left); + ReleaseDC(dc); + Path.ReleaseBuffer(); + SetDlgItemTextW(IDC_DESTDIR, Path); + CheckDlgButton(IDC_SHOW_EXTRACTED, BST_CHECKED); + return 0; + } + BOOL OnWizardFinish() + { + if (IsDlgButtonChecked(IDC_SHOW_EXTRACTED) == BST_CHECKED) + { + ShellExecuteW(NULL, L"explore", m_pExtract->m_Directory, NULL, NULL, SW_SHOW); + } + return FALSE; + } + + public: + enum { IDD = IDD_PROPPAGECOMPLETE }; + + BEGIN_MSG_MAP(CCompleteSettingsPage) + CHAIN_MSG_MAP(CPropertyPageImpl<CCompleteSettingsPage>) + END_MSG_MAP() + }; + + + void runWizard() + { + PROPSHEETHEADERW psh = { sizeof(psh), 0 }; + psh.dwFlags = PSH_WIZARD97 | PSH_HEADER; + psh.hInstance = _AtlBaseModule.GetResourceInstance(); + + CExtractSettingsPage extractPage(this); + CCompleteSettingsPage completePage(this); + HPROPSHEETPAGE hpsp[] = + { + extractPage.Create(), + completePage.Create() + }; + + psh.phpage = hpsp; + psh.nPages = _countof(hpsp); + + PropertySheetW(&psh); + } + + bool Extract(HWND hDlg, HWND hProgress) + { + unz_global_info64 gi; + uf = unzOpen2_64(m_Filename.GetString(), &g_FFunc); + int err = unzGetGlobalInfo64(uf, &gi); + if (err != UNZ_OK) + { + DPRINT1("ERROR, unzGetGlobalInfo64: 0x%x\n", err); + return false; + } + + CZipEnumerator zipEnum; + if (!zipEnum.initialize(this)) + { + DPRINT1("ERROR, zipEnum.initialize\n"); + return false; + } + + CWindow Progress(hProgress); + Progress.SendMessage(PBM_SETRANGE32, 0, gi.number_entry); + Progress.SendMessage(PBM_SETPOS, 0, 0); + + BYTE Buffer[2048]; + CStringA BaseDirectory = m_Directory; + CStringA Name; + unz_file_info64 Info; + int CurrentFile = 0; + bool bOverwriteAll = false; + while (zipEnum.next(Name, Info)) + { + bool is_dir = Name.GetLength() > 0 && Name[Name.GetLength()-1] == '/'; + + char CombinedPath[MAX_PATH * 2] = { 0 }; + PathCombineA(CombinedPath, BaseDirectory, Name); + CStringA FullPath = CombinedPath; + FullPath.Replace('/', '\\'); /* SHPathPrepareForWriteA does not handle '/' */ + DWORD dwFlags = SHPPFW_DIRCREATE | (is_dir ? SHPPFW_NONE : SHPPFW_IGNOREFILENAME); + HRESULT hr = SHPathPrepareForWriteA(hDlg, NULL, FullPath, dwFlags); + if (FAILED_UNEXPECTEDLY(hr)) + { + return false; + } + CurrentFile++; + if (is_dir) + continue; + + const char* password = NULL; + /* FIXME: Process password, if required and not specified, prompt the user */ + err = unzOpenCurrentFilePassword(uf, password); + if (err != UNZ_OK) + { + DPRINT1("ERROR, unzOpenCurrentFilePassword: 0x%x\n", err); + return false; + } + + HANDLE hFile = CreateFileA(FullPath, GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL); + if (hFile == INVALID_HANDLE_VALUE) + { + DWORD dwErr = GetLastError(); + if (dwErr == ERROR_FILE_EXISTS) + { + bool bOverwrite = bOverwriteAll; + if (!bOverwriteAll) + { + CConfirmReplace::DialogResult Result = CConfirmReplace::ShowDlg(hDlg, FullPath); + switch (Result) + { + case CConfirmReplace::YesToAll: + bOverwriteAll = true; + case CConfirmReplace::Yes: + bOverwrite = true; + break; + case CConfirmReplace::No: + break; + case CConfirmReplace::Cancel: + return false; + } + } + + if (bOverwrite) + { + hFile = CreateFileA(FullPath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); + if (hFile == INVALID_HANDLE_VALUE) + { + dwErr = GetLastError(); + } + } + else + { + unzCloseCurrentFile(uf); + continue; + } + } + if (hFile == INVALID_HANDLE_VALUE) + { + unzCloseCurrentFile(uf); + DPRINT1("ERROR, CreateFileA: 0x%x (%s)\n", dwErr, bOverwriteAll ? "Y" : "N"); + return false; + } + } + + do + { + err = unzReadCurrentFile(uf, Buffer, sizeof(Buffer)); + + if (err < 0) + { + DPRINT1("ERROR, unzReadCurrentFile: 0x%x\n", err); + break; + } + else if (err > 0) + { + DWORD dwWritten; + if (!WriteFile(hFile, Buffer, err, &dwWritten, NULL)) + { + DPRINT1("ERROR, WriteFile: 0x%x\n", GetLastError()); + break; + } + if (dwWritten != (DWORD)err) + { + DPRINT1("ERROR, WriteFile: dwWritten:%d err:%d\n", dwWritten, err); + break; + } + } + + } while (err > 0); + + /* Update Filetime */ + FILETIME LastAccessTime; + GetFileTime(hFile, NULL, &LastAccessTime, NULL); + FILETIME LocalFileTime; + DosDateTimeToFileTime((WORD)(Info.dosDate >> 16), (WORD)Info.dosDate, &LocalFileTime); + FILETIME FileTime; + LocalFileTimeToFileTime(&LocalFileTime, &FileTime); + SetFileTime(hFile, &FileTime, &LastAccessTime, &FileTime); + + /* Done.. */ + CloseHandle(hFile); + + if (err) + { + unzCloseCurrentFile(uf); + DPRINT1("ERROR, unzReadCurrentFile2: 0x%x\n", err); + return false; + } + else + { + err = unzCloseCurrentFile(uf); + if (err != UNZ_OK) + { + DPRINT1("ERROR(non-fatal), unzCloseCurrentFile: 0x%x\n", err); + } + } + Progress.SendMessage(PBM_SETPOS, CurrentFile, 0); + } + + Close(); + return true; + } +}; + + +void _CZipExtract_runWizard(PCWSTR Filename) +{ + CZipExtract extractor(Filename); + extractor.runWizard(); +} + diff --git a/dll/shellext/zipfldr/CZipFolder.hpp b/dll/shellext/zipfldr/CZipFolder.hpp new file mode 100644 index 0000000000..fa98673ff2 --- /dev/null +++ b/dll/shellext/zipfldr/CZipFolder.hpp @@ -0,0 +1,625 @@ +/* + * PROJECT: ReactOS Zip Shell Extension + * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * PURPOSE: Main class + * COPYRIGHT: Copyright 2017 Mark Jansen (mark.jansen(a)reactos.org) + */ + + +EXTERN_C HRESULT WINAPI SHCreateFileExtractIconW(LPCWSTR pszPath, DWORD dwFileAttributes, REFIID riid, void **ppv); + + +struct FolderViewColumns +{ + int iResource; + DWORD dwDefaultState; + int cxChar; + int fmt; +}; + +static FolderViewColumns g_ColumnDefs[] = +{ + { IDS_COL_NAME, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, 25, LVCFMT_LEFT }, + { IDS_COL_TYPE, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, 20, LVCFMT_LEFT }, + { IDS_COL_COMPRSIZE, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, 10, LVCFMT_RIGHT }, + { IDS_COL_PASSWORD, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, 10, LVCFMT_LEFT }, + { IDS_COL_SIZE, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, 10, LVCFMT_RIGHT }, + { IDS_COL_RATIO, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, 10, LVCFMT_LEFT }, + { IDS_COL_DATE_MOD, SHCOLSTATE_TYPE_DATE | SHCOLSTATE_ONBYDEFAULT, 15, LVCFMT_LEFT }, +}; + + +class CZipFolder : + public CComCoClass<CZipFolder, &CLSID_ZipFolderStorageHandler>, + public CComObjectRootEx<CComMultiThreadModelNoCS>, + public IShellFolder2, + //public IStorage, + public IContextMenu, + public IShellExtInit, + //public IPersistFile, + public IPersistFolder2, + public IZip +{ + CStringW m_ZipFile; + CStringA m_ZipDir; + CComHeapPtr<ITEMIDLIST> m_CurDir; + unzFile m_UnzipFile; + +public: + CZipFolder() + :m_UnzipFile(NULL) + { + } + + ~CZipFolder() + { + Close(); + } + + void Close() + { + if (m_UnzipFile) + unzClose(m_UnzipFile); + m_UnzipFile = NULL; + } + + // *** IZip methods *** + STDMETHODIMP_(unzFile) getZip() + { + if (!m_UnzipFile) + { + m_UnzipFile = unzOpen2_64(m_ZipFile, &g_FFunc); + } + + return m_UnzipFile; + } + + // *** IShellFolder2 methods *** + STDMETHODIMP GetDefaultSearchGUID(GUID *pguid) + { + UNIMPLEMENTED; + return E_NOTIMPL; + } + STDMETHODIMP EnumSearches(IEnumExtraSearch **ppenum) + { + UNIMPLEMENTED; + return E_NOTIMPL; + } + STDMETHODIMP GetDefaultColumn(DWORD dwRes, ULONG *pSort, ULONG *pDisplay) + { + UNIMPLEMENTED; + return E_NOTIMPL; + } + STDMETHODIMP GetDefaultColumnState(UINT iColumn, DWORD *pcsFlags) + { + if (!pcsFlags || iColumn >= _countof(g_ColumnDefs)) + return E_INVALIDARG; + *pcsFlags = g_ColumnDefs[iColumn].dwDefaultState; + return S_OK; + } + STDMETHODIMP GetDetailsEx(PCUITEMID_CHILD pidl, const SHCOLUMNID *pscid, VARIANT *pv) + { + UNIMPLEMENTED; + return E_NOTIMPL; + } + // Adapted from CFileDefExt::GetFileTimeString + BOOL _GetFileTimeString(LPFILETIME lpFileTime, LPWSTR pwszResult, UINT cchResult) + { + SYSTEMTIME st; + + if (!FileTimeToSystemTime(lpFileTime, &st)) + return FALSE; + + size_t cchRemaining = cchResult; + LPWSTR pwszEnd = pwszResult; + int cchWritten = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, NULL, pwszEnd, cchRemaining); + if (cchWritten) + --cchWritten; // GetDateFormatW returns count with terminating zero + else + return FALSE; + cchRemaining -= cchWritten; + pwszEnd += cchWritten; + + StringCchCopyExW(pwszEnd, cchRemaining, L" ", &pwszEnd, &cchRemaining, 0); + + cchWritten = GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, NULL, pwszEnd, cchRemaining); + if (cchWritten) + --cchWritten; // GetTimeFormatW returns count with terminating zero + else + return FALSE; + + return TRUE; + } + STDMETHODIMP GetDetailsOf(PCUITEMID_CHILD pidl, UINT iColumn, SHELLDETAILS *psd) + { + if (iColumn >= _countof(g_ColumnDefs)) + return E_FAIL; + + psd->cxChar = g_ColumnDefs[iColumn].cxChar; + psd->fmt = g_ColumnDefs[iColumn].fmt; + + if (pidl == NULL) + { + return SHSetStrRet(&psd->str, _AtlBaseModule.GetResourceInstance(), g_ColumnDefs[iColumn].iResource); + } + + PCUIDLIST_RELATIVE curpidl = ILGetNext(pidl); + if (curpidl->mkid.cb != 0) + { + DPRINT1("ERROR, unhandled PIDL!\n"); + return E_FAIL; + } + + const ZipPidlEntry* zipEntry = _ZipFromIL(pidl); + if (!zipEntry) + return E_INVALIDARG; + + WCHAR Buffer[100]; + bool isDir = zipEntry->ZipType == ZIP_PIDL_DIRECTORY; + switch (iColumn) + { + case 0: /* Name, ReactOS specific? */ + return GetDisplayNameOf(pidl, 0, &psd->str); + case 1: /* Type */ + { + SHFILEINFOA shfi; + DWORD dwAttributes = isDir ? FILE_ATTRIBUTE_DIRECTORY : FILE_ATTRIBUTE_NORMAL; + ULONG_PTR firet = SHGetFileInfoA(zipEntry->Name, dwAttributes, &shfi, sizeof(shfi), SHGFI_USEFILEATTRIBUTES | SHGFI_TYPENAME); + if (!firet) + return E_FAIL; + return SHSetStrRet(&psd->str, shfi.szTypeName); + } + case 2: /* Compressed size */ + case 4: /* Size */ + { + ULONG64 Size = iColumn == 2 ? zipEntry->CompressedSize : zipEntry->UncompressedSize; + if (!StrFormatByteSizeW(Size, Buffer, _countof(Buffer))) + return E_FAIL; + return SHSetStrRet(&psd->str, Buffer); + } + case 3: /* Password */ + if (isDir) + return SHSetStrRet(&psd->str, L""); + return SHSetStrRet(&psd->str, _AtlBaseModule.GetResourceInstance(), zipEntry->Password ? IDS_YES : IDS_NO); + case 5: /* Ratio */ + { + int ratio = 0; + if (zipEntry->UncompressedSize && !isDir) + ratio = 100 - (int)((zipEntry->CompressedSize*100)/zipEntry->UncompressedSize); + StringCchPrintfW(Buffer, _countof(Buffer), L"%d%%", ratio); + return SHSetStrRet(&psd->str, Buffer); + } + case 6: /* Date */ + { + if (isDir) + return SHSetStrRet(&psd->str, L""); + FILETIME ftLocal; + DosDateTimeToFileTime((WORD)(zipEntry->DosDate>>16), (WORD)zipEntry->DosDate, &ftLocal); + if (!_GetFileTimeString(&ftLocal, Buffer, _countof(Buffer))) + return E_FAIL; + return SHSetStrRet(&psd->str, Buffer); + } + } + + UNIMPLEMENTED; + return E_NOTIMPL; + } + STDMETHODIMP MapColumnToSCID(UINT column, SHCOLUMNID *pscid) + { + UNIMPLEMENTED; + return E_NOTIMPL; + } + + // *** IShellFolder methods *** + STDMETHODIMP ParseDisplayName(HWND hwndOwner, LPBC pbc, LPOLESTR lpszDisplayName, ULONG *pchEaten, PIDLIST_RELATIVE *ppidl, ULONG *pdwAttributes) + { + UNIMPLEMENTED; + return E_NOTIMPL; + } + STDMETHODIMP EnumObjects(HWND hwndOwner, DWORD dwFlags, LPENUMIDLIST *ppEnumIDList) + { + return _CEnumZipContents_CreateInstance(this, dwFlags, m_ZipDir, IID_PPV_ARG(IEnumIDList, ppEnumIDList)); + } + STDMETHODIMP BindToObject(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut) + { + if (riid == IID_IShellFolder) + { + CStringA newZipDir = m_ZipDir; + PCUIDLIST_RELATIVE curpidl = pidl; + while (curpidl->mkid.cb) + { + const ZipPidlEntry* zipEntry = _ZipFromIL(curpidl); + if (!zipEntry) + { + return E_FAIL; + } + newZipDir += zipEntry->Name; + newZipDir += '/'; + + curpidl = ILGetNext(curpidl); + } + return ShellObjectCreatorInit<CZipFolder>(m_ZipFile, newZipDir, m_CurDir, pidl, riid, ppvOut); + } + DbgPrint("%s(%S) UNHANDLED\n", __FUNCTION__, guid2string(riid)); + return E_NOTIMPL; + } + STDMETHODIMP BindToStorage(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut) + { + UNIMPLEMENTED; + return E_NOTIMPL; + } + STDMETHODIMP CompareIDs(LPARAM lParam, PCUIDLIST_RELATIVE pidl1, PCUIDLIST_RELATIVE pidl2) + { + const ZipPidlEntry* zipEntry1 = _ZipFromIL(pidl1); + const ZipPidlEntry* zipEntry2 = _ZipFromIL(pidl2); + + if (!zipEntry1 || !zipEntry2) + return E_INVALIDARG; + + int result = 0; + if (zipEntry1->ZipType != zipEntry2->ZipType) + result = zipEntry1->ZipType - zipEntry2->ZipType; + else + result = stricmp(zipEntry1->Name, zipEntry2->Name); + + if (!result && zipEntry1->ZipType == ZIP_PIDL_DIRECTORY) + { + PCUIDLIST_RELATIVE child1 = ILGetNext(pidl1); + PCUIDLIST_RELATIVE child2 = ILGetNext(pidl2); + + if (child1->mkid.cb && child2->mkid.cb) + return CompareIDs(lParam, child1, child2); + else if (child1->mkid.cb) + result = 1; + else if (child2->mkid.cb) + result = -1; + } + + return MAKE_COMPARE_HRESULT(result); + } + STDMETHODIMP CreateViewObject(HWND hwndOwner, REFIID riid, LPVOID *ppvOut) + { + static const GUID UnknownIID = // {93F81976-6A0D-42C3-94DD-AA258A155470} + {0x93F81976, 0x6A0D, 0x42C3, {0x94, 0xDD, 0xAA, 0x25, 0x8A, 0x15, 0x54, 0x70}}; + if (riid == IID_IShellView) + { + SFV_CREATE sfvparams = {sizeof(SFV_CREATE), this}; + CComPtr<IShellFolderViewCB> pcb; + + HRESULT hr = _CFolderViewCB_CreateInstance(IID_PPV_ARG(IShellFolderViewCB, &pcb)); + if (FAILED_UNEXPECTEDLY(hr)) + return hr; + + sfvparams.psfvcb = pcb; + hr = SHCreateShellFolderView(&sfvparams, (IShellView**)ppvOut); + + return hr; + } + if (riid == IID_IExplorerCommandProvider) + { + return _CExplorerCommandProvider_CreateInstance(this, riid, ppvOut); + } + if (UnknownIID != riid) + DbgPrint("%s(%S) UNHANDLED\n", __FUNCTION__, guid2string(riid)); + return E_NOTIMPL; + } + STDMETHODIMP GetAttributesOf(UINT cidl, PCUITEMID_CHILD_ARRAY apidl, DWORD *rgfInOut) + { + if (!rgfInOut || !cidl || !apidl) + return E_INVALIDARG; + + *rgfInOut = 0; + + //static DWORD dwFileAttrs = SFGAO_STREAM | SFGAO_HASPROPSHEET | SFGAO_CANDELETE | SFGAO_CANCOPY | SFGAO_CANMOVE; + //static DWORD dwFolderAttrs = SFGAO_FOLDER | SFGAO_DROPTARGET | SFGAO_HASPROPSHEET | SFGAO_CANDELETE | SFGAO_STORAGE | SFGAO_CANCOPY | SFGAO_CANMOVE; + static DWORD dwFileAttrs = SFGAO_STREAM; + static DWORD dwFolderAttrs = SFGAO_FOLDER | SFGAO_HASSUBFOLDER | SFGAO_BROWSABLE; + + + while (cidl > 0 && *apidl) + { + const ZipPidlEntry* zipEntry = _ZipFromIL(*apidl); + + if (zipEntry) + { + if (zipEntry->ZipType == ZIP_PIDL_FILE) + *rgfInOut |= dwFileAttrs; + else + *rgfInOut |= dwFolderAttrs; + } + else + { + *rgfInOut = 0; + } + + apidl++; + cidl--; + } + + *rgfInOut &= ~SFGAO_VALIDATE; + return S_OK; + } + static HRESULT CALLBACK ZipFolderMenuCallback(IShellFolder *psf, HWND hwnd, IDataObject *pdtobj, + UINT uMsg, WPARAM wParam, LPARAM lParam) + { + switch (uMsg) + { + case DFM_MERGECONTEXTMENU: + DPRINT1("FIXME: Add menu items for DFM_MERGECONTEXTMENU\n"); + return S_OK; + case DFM_INVOKECOMMAND: + case DFM_INVOKECOMMANDEX: + case DFM_GETDEFSTATICID: // Required for Windows 7 to pick a default + return S_FALSE; + } + return E_NOTIMPL; + } + STDMETHODIMP GetUIObjectOf(HWND hwndOwner, UINT cidl, PCUITEMID_CHILD_ARRAY apidl, REFIID riid, UINT * prgfInOut, LPVOID * ppvOut) + { + if ((riid == IID_IExtractIconA || riid == IID_IExtractIconW) && cidl == 1) + { + const ZipPidlEntry* zipEntry = _ZipFromIL(*apidl); + if (zipEntry) + { + CComHeapPtr<WCHAR> pathW; + + int len = MultiByteToWideChar(CP_ACP, 0, zipEntry->Name, -1, NULL, 0); + pathW.Allocate(len); + MultiByteToWideChar(CP_ACP, 0, zipEntry->Name, -1, pathW, len); + + DWORD dwAttributes = (zipEntry->ZipType == ZIP_PIDL_DIRECTORY) ? FILE_ATTRIBUTE_DIRECTORY : FILE_ATTRIBUTE_NORMAL; + return SHCreateFileExtractIconW(pathW, dwAttributes, riid, ppvOut); + } + } + else if (riid == IID_IContextMenu && cidl >= 0) + { + const ZipPidlEntry* zipEntry = _ZipFromIL(*apidl); + if (zipEntry) + { + HKEY keys[1] = {0}; + int nkeys = 0; + if (zipEntry->ZipType == ZIP_PIDL_DIRECTORY) + { + LSTATUS res = RegOpenKeyExW(HKEY_CLASSES_ROOT, L"Folder", 0, KEY_READ | KEY_QUERY_VALUE, keys); + if (res != ERROR_SUCCESS) + return E_FAIL; + nkeys++; + } + return CDefFolderMenu_Create2(NULL, hwndOwner, cidl, apidl, this, ZipFolderMenuCallback, nkeys, keys, (IContextMenu**)ppvOut); + } + } + else if (riid == IID_IDataObject && cidl >= 1) + { + return CIDLData_CreateFromIDArray(m_CurDir, cidl, apidl, (IDataObject**)ppvOut); + } + + DbgPrint("%s(%S) UNHANDLED\n", __FUNCTION__ , guid2string(riid)); + return E_NOINTERFACE; + } + STDMETHODIMP GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet) + { + if (!pidl) + return S_FALSE; + + PCUIDLIST_RELATIVE curpidl = ILGetNext(pidl); + if (curpidl->mkid.cb != 0) + { + DPRINT1("ERROR, unhandled PIDL!\n"); + return E_FAIL; + } + + const ZipPidlEntry* zipEntry = _ZipFromIL(pidl); + if (!zipEntry) + return E_FAIL; + + return SHSetStrRet(strRet, (LPCSTR)zipEntry->Name); + } + STDMETHODIMP SetNameOf(HWND hwndOwner, PCUITEMID_CHILD pidl, LPCOLESTR lpName, DWORD dwFlags, PITEMID_CHILD *pPidlOut) + { + UNIMPLEMENTED; + return E_NOTIMPL; + } + //// IStorage + //STDMETHODIMP CreateStream(LPCOLESTR pwcsName, DWORD grfMode, DWORD reserved1, DWORD reserved2, IStream **ppstm); + //STDMETHODIMP OpenStream(LPCOLESTR pwcsName, void *reserved1, DWORD grfMode, DWORD reserved2, IStream **ppstm); + //STDMETHODIMP CreateStorage(LPCOLESTR pwcsName, DWORD grfMode, DWORD dwStgFmt, DWORD reserved2, IStorage **ppstg); + //STDMETHODIMP OpenStorage(LPCOLESTR pwcsName, IStorage *pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, IStorage **ppstg); + //STDMETHODIMP CopyTo(DWORD ciidExclude, const IID *rgiidExclude, SNB snbExclude, IStorage *pstgDest); + //STDMETHODIMP MoveElementTo(LPCOLESTR pwcsName, IStorage *pstgDest, LPCOLESTR pwcsNewName, DWORD grfFlags); + //STDMETHODIMP Commit(DWORD grfCommitFlags); + //STDMETHODIMP Revert(); + //STDMETHODIMP EnumElements(DWORD reserved1, void *reserved2, DWORD reserved3, IEnumSTATSTG **ppenum); + //STDMETHODIMP DestroyElement(LPCOLESTR pwcsName); + //STDMETHODIMP RenameElement(LPCOLESTR pwcsOldName, LPCOLESTR pwcsNewName); + //STDMETHODIMP SetElementTimes(LPCOLESTR pwcsName, const FILETIME *pctime, const FILETIME *patime, const FILETIME *pmtime); + //STDMETHODIMP SetClass(REFCLSID clsid); + //STDMETHODIMP SetStateBits(DWORD grfStateBits, DWORD grfMask); + //STDMETHODIMP Stat(STATSTG *pstatstg, DWORD grfStatFlag); + + // *** IContextMenu methods *** + STDMETHODIMP GetCommandString(UINT_PTR idCmd, UINT uFlags, UINT *pwReserved, LPSTR pszName, UINT cchMax) + { + if (idCmd != 0) + return E_INVALIDARG; + + switch (uFlags) + { + case GCS_VERBA: + return StringCchCopyA(pszName, cchMax, EXTRACT_VERBA); + case GCS_VERBW: + return StringCchCopyW((LPWSTR)pszName, cchMax, EXTRACT_VERBW); + case GCS_HELPTEXTA: + { + CStringA helpText(MAKEINTRESOURCEA(IDS_HELPTEXT)); + return StringCchCopyA(pszName, cchMax, helpText); + } + case GCS_HELPTEXTW: + { + CStringW helpText(MAKEINTRESOURCEA(IDS_HELPTEXT)); + return StringCchCopyW((LPWSTR)pszName, cchMax, helpText); + } + case GCS_VALIDATEA: + case GCS_VALIDATEW: + return S_OK; + } + + return E_INVALIDARG; + } + STDMETHODIMP InvokeCommand(LPCMINVOKECOMMANDINFO pici) + { + if (!pici || pici->cbSize != sizeof(*pici)) + return E_INVALIDARG; + + if (pici->lpVerb == MAKEINTRESOURCEA(0) || (HIWORD(pici->lpVerb) && !strcmp(pici->lpVerb, EXTRACT_VERBA))) + { + BSTR ZipFile = m_ZipFile.AllocSysString(); + InterlockedIncrement(&g_ModuleRefCnt); + + DWORD tid; + HANDLE hThread = CreateThread(NULL, 0, s_ExtractProc, ZipFile, NULL, &tid); + if (hThread) + { + CloseHandle(hThread); + return S_OK; + } + } + return E_INVALIDARG; + } + STDMETHODIMP QueryContextMenu(HMENU hmenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags) + { + int Entries = 0; + + CStringW menuText(MAKEINTRESOURCEW(IDS_MENUITEM)); + + InsertMenuW(hmenu, indexMenu++, MF_BYPOSITION | MF_SEPARATOR, 0, NULL); + Entries++; + InsertMenuW(hmenu, indexMenu++, MF_BYPOSITION | MF_STRING, idCmdFirst++, menuText); + Entries++; + + return MAKE_HRESULT(SEVERITY_SUCCESS, 0, Entries); + } + + // *** IShellExtInit methods *** + STDMETHODIMP Initialize(LPCITEMIDLIST pidlFolder, LPDATAOBJECT pDataObj, HKEY hkeyProgID) + { + FORMATETC etc = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }; + STGMEDIUM stg; + + HRESULT hr = pDataObj->GetData(&etc, &stg); + if (FAILED_UNEXPECTEDLY(hr)) + { + return hr; + } + hr = E_FAIL; + HDROP hdrop = (HDROP)GlobalLock(stg.hGlobal); + if (hdrop) + { + UINT uNumFiles = DragQueryFileW(hdrop, 0xFFFFFFFF, NULL, 0); + if (uNumFiles == 1) + { + WCHAR szFile[MAX_PATH * 2]; + if (DragQueryFileW(hdrop, 0, szFile, _countof(szFile))) + { + CComHeapPtr<ITEMIDLIST> pidl; + hr = SHParseDisplayName(szFile, NULL, &pidl, 0, NULL); + if (!FAILED_UNEXPECTEDLY(hr)) + { + hr = Initialize(pidl); + } + } + else + { + DbgPrint("Failed to query the file.\r\n"); + } + } + else + { + DbgPrint("Invalid number of files: %d\r\n", uNumFiles); + } + GlobalUnlock(stg.hGlobal); + } + else + { + DbgPrint("Could not lock stg.hGlobal\r\n"); + } + ReleaseStgMedium(&stg); + return hr; + + } + + //// IPersistFile + ////STDMETHODIMP GetClassID(CLSID *pclsid); + //STDMETHODIMP IsDirty(); + //STDMETHODIMP Load(LPCOLESTR pszFileName, DWORD dwMode); + //STDMETHODIMP Save(LPCOLESTR pszFileName, BOOL fRemember); + //STDMETHODIMP SaveCompleted(LPCOLESTR pszFileName); + //STDMETHODIMP GetCurFile(LPOLESTR *ppszFileName); + + //// *** IPersistFolder2 methods *** + STDMETHODIMP GetCurFolder(LPITEMIDLIST * pidl) + { + *pidl = ILClone(m_CurDir); + return S_OK; + } + + // *** IPersistFolder methods *** + STDMETHODIMP Initialize(LPCITEMIDLIST pidl) + { + WCHAR tmpPath[MAX_PATH]; + + if (SHGetPathFromIDListW(pidl, tmpPath)) + { + m_ZipFile = tmpPath; + m_CurDir.Attach(ILClone(pidl)); + return S_OK; + } + DbgPrint("%s() => Unable to parse pidl\n", __FUNCTION__); + return E_INVALIDARG; + } + + // *** IPersist methods *** + STDMETHODIMP GetClassID(CLSID *lpClassId) + { + DbgPrint("%s\n", __FUNCTION__); + return E_NOTIMPL; + } + + + STDMETHODIMP Initialize(PCWSTR zipFile, PCSTR zipDir, PCUIDLIST_ABSOLUTE curDir, PCUIDLIST_RELATIVE pidl) + { + m_ZipFile = zipFile; + m_ZipDir = zipDir; + + m_CurDir.Attach(ILCombine(curDir, pidl)); + return S_OK; + } + static DWORD WINAPI s_ExtractProc(LPVOID arg) + { + CComBSTR ZipFile; + ZipFile.Attach((BSTR)arg); + + _CZipExtract_runWizard(ZipFile); + + InterlockedDecrement(&g_ModuleRefCnt); + return 0; + } + +public: + DECLARE_NO_REGISTRY() // Handled manually because this object is exposed via multiple clsid's + DECLARE_NOT_AGGREGATABLE(CZipFolder) + + DECLARE_PROTECT_FINAL_CONSTRUCT() + + BEGIN_COM_MAP(CZipFolder) + COM_INTERFACE_ENTRY_IID(IID_IShellFolder2, IShellFolder2) + COM_INTERFACE_ENTRY_IID(IID_IShellFolder, IShellFolder) +// COM_INTERFACE_ENTRY_IID(IID_IStorage, IStorage) + COM_INTERFACE_ENTRY_IID(IID_IContextMenu, IContextMenu) + COM_INTERFACE_ENTRY_IID(IID_IShellExtInit, IShellExtInit) + //COM_INTERFACE_ENTRY_IID(IID_IPersistFile, IPersistFile) + COM_INTERFACE_ENTRY_IID(IID_IPersistFolder2, IPersistFolder2) + COM_INTERFACE_ENTRY_IID(IID_IPersistFolder, IPersistFolder) + COM_INTERFACE_ENTRY_IID(IID_IPersist, IPersist) + END_COM_MAP() +}; + diff --git a/dll/shellext/zipfldr/Debug.cpp b/dll/shellext/zipfldr/Debug.cpp new file mode 100644 index 0000000000..35580771db --- /dev/null +++ b/dll/shellext/zipfldr/Debug.cpp @@ -0,0 +1,44 @@ +/* + * PROJECT: ReactOS Zip Shell Extension + * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * PURPOSE: Zip extraction + * COPYRIGHT: Copyright 2017 Mark Jansen (mark.jansen(a)reactos.org) + */ + +#include "precomp.h" + +static bool GetInterfaceName(const WCHAR* InterfaceString, WCHAR* buf, size_t size) +{ + WCHAR LocalBuf[100]; + DWORD dwType = 0, dwDataSize = size * sizeof(WCHAR); + + if (!SUCCEEDED(StringCchPrintfW(LocalBuf, _countof(LocalBuf), L"Interface\\%s", InterfaceString))) + return false; + + return SHRegGetValueW(HKEY_CLASSES_ROOT, LocalBuf, NULL, RRF_RT_REG_SZ, &dwType, buf, &dwDataSize) == ERROR_SUCCESS; +} + +WCHAR* guid2string(REFCLSID iid) +{ + static WCHAR buf[2][300]; + static int idx = 0; + + idx ^= 1; + + LPOLESTR tmp; + HRESULT hr = ProgIDFromCLSID(iid, &tmp); + if (SUCCEEDED(hr)) + { + wcscpy(buf[idx], tmp); + CoTaskMemFree(tmp); + return buf[idx]; + } + StringFromGUID2(iid, buf[idx], _countof(buf[idx])); + if (GetInterfaceName(buf[idx], buf[idx], _countof(buf[idx]))) + { + return buf[idx]; + } + StringFromGUID2(iid, buf[idx], _countof(buf[idx])); + + return buf[idx]; +} diff --git a/dll/shellext/zipfldr/IZip.hpp b/dll/shellext/zipfldr/IZip.hpp new file mode 100644 index 0000000000..bb16e50fb4 --- /dev/null +++ b/dll/shellext/zipfldr/IZip.hpp @@ -0,0 +1,12 @@ +/* + * PROJECT: ReactOS Zip Shell Extension + * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * PURPOSE: IZip + * COPYRIGHT: Copyright 2017 Mark Jansen (mark.jansen(a)reactos.org) + */ + +struct IZip : public IUnknown +{ + virtual STDMETHODIMP_(unzFile) getZip() PURE; +}; + diff --git a/dll/shellext/zipfldr/precomp.h b/dll/shellext/zipfldr/precomp.h new file mode 100644 index 0000000000..01b92991d5 --- /dev/null +++ b/dll/shellext/zipfldr/precomp.h @@ -0,0 +1,62 @@ +#ifndef ZIPFLDR_PRECOMP_H +#define ZIPFLDR_PRECOMP_H + +#define COBJMACROS +#define COM_NO_WINDOWS_H +#define NTOS_MODE_USER + +#include <windef.h> +#include <winbase.h> +#include <shlobj.h> +#include <atlbase.h> +#include <atlcom.h> +#include <atlcoll.h> +#include <atlstr.h> +#include <rosdlgs.h> +#include <shlwapi.h> +#include <shellapi.h> +#include <strsafe.h> +// debug.h needs this: +#define NTSTATUS LONG +#include <reactos/debug.h> +#include <shellutils.h> + + + +#define EXTRACT_VERBA "extract" +#define EXTRACT_VERBW L"extract" + +EXTERN_C const GUID CLSID_ZipFolderStorageHandler; +EXTERN_C const GUID CLSID_ZipFolderSendTo; +EXTERN_C const GUID CLSID_ZipFolderContextMenu; +EXTERN_C const GUID CLSID_ZipFolderRightDragHandler; +EXTERN_C const GUID CLSID_ZipFolderDropHandler; + +EXTERN_C const GUID CLSID_ZipFolderExtractAllCommand; + +extern LONG g_ModuleRefCnt; + + +#define Win32DbgPrint(file, line, warn, func) DbgPrint("(%s:%d) " warn, file, line, func) +WCHAR* guid2string(REFCLSID iid); + + +#include "minizip/unzip.h" +#include "minizip/ioapi.h" + +extern zlib_filefunc64_def g_FFunc; + +#include "resource.h" + +#include "zippidl.hpp" +#include "IZip.hpp" + +HRESULT _CEnumZipContents_CreateInstance(IZip* zip, DWORD flags, const char* prefix, REFIID riid, LPVOID * ppvOut); +HRESULT _CExplorerCommandProvider_CreateInstance(IContextMenu* zipObject, REFIID riid, LPVOID * ppvOut); +HRESULT _CFolderViewCB_CreateInstance(REFIID riid, LPVOID * ppvOut); +void _CZipExtract_runWizard(PCWSTR Filename); + +#include "CZipEnumerator.hpp" +#include "CZipFolder.hpp" + +#endif /* ZIPFLDR_PRECOMP_H */ diff --git a/dll/shellext/zipfldr/res/zipfldr.ico b/dll/shellext/zipfldr/res/zipfldr.ico new file mode 100644 index 0000000000..04f98dcb2f Binary files /dev/null and b/dll/shellext/zipfldr/res/zipfldr.ico differ diff --git a/dll/shellext/zipfldr/res/zipfldr.rgs b/dll/shellext/zipfldr/res/zipfldr.rgs new file mode 100644 index 0000000000..82cfc8dfae --- /dev/null +++ b/dll/shellext/zipfldr/res/zipfldr.rgs @@ -0,0 +1,54 @@ +HKCR +{ + NoRemove CLSID + { + '{E88DCCE0-B7B3-11d1-A9F0-00AA0060FA31}' = s 'CompressedFolder' + { + InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Apartment' } + ProgId = s 'CompressedFolder' + ShellFolder + { + val Attributes = d '0x200001a0' + val UseDropHandler = s '' + } + } + '{b8cdcb65-b1bf-4b42-9428-1dfdb7ee92af}' = s 'Compressed (zipped) Folder Menu' + { + InprocServer32 = s '%MODULE%' { val ThreadingModel = s 'Apartment' } + } + } + NoRemove Applications + { + 'zipfldr.dll' { val NoOpenWith = s '' } + } + NoRemove CompressedFolder + { + FriendlyTypeName = s '%MODULE%,-10195' + CLSID = s '{E88DCCE0-B7B3-11d1-A9F0-00AA0060FA31}' + DefaultIcon = s '%MODULE%' + + NoRemove Shell + { + NoRemove Open + { + command = s 'rundll32.exe zipfldr.dll,RouteTheCall %%L' + val BrowserFlags = d '0x10' + val ExplorerFlags = d '0x10' + } + } + + NoRemove shellex + { + NoRemove ContextMenuHandlers + { + ForceRemove '{b8cdcb65-b1bf-4b42-9428-1dfdb7ee92af}' = s 'Compressed (zipped) Folder Menu' + { + } + } + } + } + NoRemove '.zip' = s 'CompressedFolder' + { + val 'Content Type' = s 'application/x-zip-compressed' + } +} diff --git a/dll/shellext/zipfldr/resource.h b/dll/shellext/zipfldr/resource.h new file mode 100644 index 0000000000..10cadc742a --- /dev/null +++ b/dll/shellext/zipfldr/resource.h @@ -0,0 +1,58 @@ +#pragma once + +/* registry stuff */ +#define IDR_ZIPFLDR 8000 + + +/* Dialogs */ + +#define IDD_PROPPAGEDESTIONATION 1000 +#define IDC_DIRECTORY 1001 +#define IDC_BROWSE 1002 +#define IDC_PASSWORD 1003 +#define IDC_PROGRESS 1004 + +#define IDD_PROPPAGECOMPLETE 1100 +#define IDC_DESTDIR 1101 +#define IDC_SHOW_EXTRACTED 1102 + +#define IDD_CONFIRM_FILE_REPLACE 1200 +#define IDYESALL 1202 +#define IDC_EXCLAMATION_ICON 1205 +#define IDC_MESSAGE 1206 + + +/* Strings */ +#define IDS_COL_NAME 100 +#define IDS_COL_TYPE 101 +#define IDS_COL_COMPRSIZE 102 +#define IDS_COL_PASSWORD 103 +#define IDS_COL_SIZE 104 +#define IDS_COL_RATIO 105 +#define IDS_COL_DATE_MOD 106 +#define IDS_YES 107 +#define IDS_NO 108 + + +/* Wizard titles */ +#define IDS_WIZ_TITLE 8000 +#define IDS_WIZ_DEST_TITLE 8001 +#define IDS_WIZ_DEST_SUBTITLE 8002 +#define IDS_WIZ_COMPL_TITLE 8003 +#define IDS_WIZ_COMPL_SUBTITLE 8004 + +#define IDS_WIZ_BROWSE_TITLE 8010 + +/* Questions */ +#define IDS_OVERWRITEFILE_TEXT 9000 + + +/* Context menu / ExplorerCommand strings */ +#define IDS_MENUITEM 10039 +#define IDS_HELPTEXT 10041 +#define IDS_FRIENDLYNAME 10195 + + +#ifndef IDC_STATIC +#define IDC_STATIC -1 +#endif diff --git a/dll/shellext/zipfldr/zipfldr.cpp b/dll/shellext/zipfldr/zipfldr.cpp new file mode 100644 index 0000000000..27a354e0a1 --- /dev/null +++ b/dll/shellext/zipfldr/zipfldr.cpp @@ -0,0 +1,117 @@ +/* + * PROJECT: ReactOS Zip Shell Extension + * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * PURPOSE: zipfldr entrypoint + * COPYRIGHT: Copyright 2017 Mark Jansen (mark.jansen(a)reactos.org) + */ + +#include "precomp.h" + +HMODULE g_hModule = NULL; +LONG g_ModuleRefCnt = 0; + +#include <initguid.h> + +DEFINE_GUID(CLSID_ZipFolderStorageHandler, 0xe88dcce0, 0xb7b3, 0x11d1, 0xa9, 0xf0, 0x00, 0xaa, 0x00, 0x60, 0xfa, 0x31); +DEFINE_GUID(CLSID_ZipFolderSendTo, 0x888dca60, 0xfc0a, 0x11cf, 0x8f, 0x0f, 0x00, 0xc0, 0x4f, 0xd7, 0xd0, 0x62); +DEFINE_GUID(CLSID_ZipFolderContextMenu, 0xb8cdcb65, 0xb1bf, 0x4b42, 0x94, 0x28, 0x1d, 0xfd, 0xb7, 0xee, 0x92, 0xaf); +DEFINE_GUID(CLSID_ZipFolderRightDragHandler,0xbd472f60, 0x27fa, 0x11cf, 0xb8, 0xb4, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00); +DEFINE_GUID(CLSID_ZipFolderDropHandler, 0xed9d80b9, 0xd157, 0x457b, 0x91, 0x92, 0x0e, 0x72, 0x80, 0x31, 0x3b, 0xf0); + +/* IExplorerCommand: Extract All */ +DEFINE_GUID(CLSID_ZipFolderExtractAllCommand, 0xc3d9647b, 0x8fd9, 0x4ee6, 0x8b, 0xc7, 0x82, 0x7, 0x80, 0x9, 0x10, 0x5a); + + +class CZipFldrModule : public CComModule +{ +public: +}; + + +BEGIN_OBJECT_MAP(ObjectMap) + OBJECT_ENTRY(CLSID_ZipFolderStorageHandler, CZipFolder) + OBJECT_ENTRY(CLSID_ZipFolderContextMenu, CZipFolder) +END_OBJECT_MAP() + +CZipFldrModule gModule; + + +#include "minizip/ioapi.h" +#include "minizip/iowin32.h" + +zlib_filefunc64_def g_FFunc; + +static void init_zlib() +{ + fill_win32_filefunc64W(&g_FFunc); +} + +EXTERN_C +BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved) +{ + switch (dwReason) + { + case DLL_PROCESS_ATTACH: + DisableThreadLibraryCalls(hInstance); + g_hModule = hInstance; + gModule.Init(ObjectMap, hInstance, NULL); + init_zlib(); + break; + } + + return TRUE; +} + +STDAPI DllCanUnloadNow() +{ + if (g_ModuleRefCnt) + return S_FALSE; + return gModule.DllCanUnloadNow(); +} + +STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) +{ + return gModule.DllGetClassObject(rclsid, riid, ppv); +} + +STDAPI DllRegisterServer() +{ + HRESULT hr; + + hr = gModule.DllRegisterServer(FALSE); + if (FAILED_UNEXPECTEDLY(hr)) + return hr; + + hr = gModule.UpdateRegistryFromResource(IDR_ZIPFLDR, TRUE, NULL); + if (FAILED(hr)) + return hr; + + return S_OK; +} + +STDAPI DllUnregisterServer() +{ + HRESULT hr; + + hr = gModule.DllUnregisterServer(FALSE); + if (FAILED_UNEXPECTEDLY(hr)) + return hr; + + hr = gModule.UpdateRegistryFromResource(IDR_ZIPFLDR, FALSE, NULL); + if (FAILED(hr)) + return hr; + + return S_OK; +} + +EXTERN_C +BOOL WINAPI +RouteTheCall( + IN HWND hWndOwner, + IN HINSTANCE hInstance, + IN LPWSTR lpNamedPipeName, + IN INT Show) +{ + UNIMPLEMENTED; + return FALSE; +} diff --git a/dll/shellext/zipfldr/zipfldr.rc b/dll/shellext/zipfldr/zipfldr.rc new file mode 100644 index 0000000000..0b577b5f3e --- /dev/null +++ b/dll/shellext/zipfldr/zipfldr.rc @@ -0,0 +1,88 @@ +#include <windef.h> +#include <winuser.h> + +#include "resource.h" + +LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL + +1 ICON "res/zipfldr.ico" + +#define REACTOS_VERSION_DLL +#define REACTOS_STR_FILE_DESCRIPTION "ReactOS Zip Shell Extension" +#define REACTOS_STR_INTERNAL_NAME "zipfldr" +#define REACTOS_STR_ORIGINAL_FILENAME "zipfldr.dll" +#include <reactos/version.rc> + +#include <reactos/manifest_dll.rc> + +IDR_ZIPFLDR REGISTRY "res/zipfldr.rgs" + + + +IDD_PROPPAGEDESTIONATION DIALOGEX 0, 0, 235, 156 +STYLE DS_SHELLFONT | WS_CHILD | WS_DISABLED | WS_CAPTION +CAPTION "Select a Destination" +FONT 8, "MS Shell Dlg", 400, 0, 0x0 +BEGIN + LTEXT "Select the destionation directory",IDC_STATIC,6,12,174,8 + EDITTEXT IDC_DIRECTORY,6,24,222,12,ES_AUTOHSCROLL + PUSHBUTTON "Browse...",IDC_BROWSE,174,42,54,14 + PUSHBUTTON "Password",IDC_PASSWORD,174,66,54,14 + LTEXT "Extracting...",IDC_STATIC,6,114,42,8 + CONTROL "",IDC_PROGRESS,"msctls_progress32",WS_BORDER,6,126,222,6 +END + + +IDD_PROPPAGECOMPLETE DIALOGEX 0, 0, 235, 156 +STYLE DS_SHELLFONT | WS_CHILD | WS_DISABLED | WS_CAPTION +CAPTION "Extraction Complete" +FONT 8, "MS Shell Dlg", 400, 0, 0x0 +BEGIN + LTEXT "The files have been extracted to the following directory:",IDC_STATIC,6,12,222,18 + LTEXT "Target dir",IDC_DESTDIR,6,36,222,8 + CONTROL "Show extracted files",IDC_SHOW_EXTRACTED,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,6,66,81,10 + LTEXT "Press finish to continue.",IDC_STATIC,6,84,174,8 +END + + +IDD_CONFIRM_FILE_REPLACE DIALOGEX 0, 0, 273, 56 +STYLE DS_MODALFRAME | DS_SHELLFONT | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Confirm File Replace" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + DEFPUSHBUTTON "&Yes",IDYES,6,36,62,14 + PUSHBUTTON "Cancel",IDCANCEL,204,36,62,14 + PUSHBUTTON "Yes &To All",IDYESALL,72,36,62,14 + PUSHBUTTON "&No",IDNO,138,36,62,14 + ICON "",IDC_EXCLAMATION_ICON,6,6,24,22 + LTEXT "",IDC_MESSAGE,36,6,228,24 +END + + + +STRINGTABLE +BEGIN + IDS_COL_NAME "Name" + IDS_COL_TYPE "Type" + IDS_COL_COMPRSIZE "Compressed size" + IDS_COL_PASSWORD "Password" + IDS_COL_SIZE "Size" + IDS_COL_RATIO "Ratio" + IDS_COL_DATE_MOD "Date modified" + IDS_YES "Yes" + IDS_NO "No" + + IDS_WIZ_TITLE "Extraction Wizard" + IDS_WIZ_DEST_TITLE "Select a Destination" + IDS_WIZ_DEST_SUBTITLE "The files from the zip archive will be extracted to the location specified." + IDS_WIZ_COMPL_TITLE "Extraction Complete" + IDS_WIZ_COMPL_SUBTITLE "The files from the zip archive have been extracted." + IDS_WIZ_BROWSE_TITLE "Select the place where you want to extract the selected items." + + IDS_OVERWRITEFILE_TEXT "This folder already contains a file called '%1'.\nDo you want to replace it?" + + IDS_MENUITEM "Extract &All..." + IDS_HELPTEXT "Extracts folder contents" + IDS_FRIENDLYNAME "Compressed (zipped) Folder" + +END diff --git a/dll/shellext/zipfldr/zipfldr.spec b/dll/shellext/zipfldr/zipfldr.spec new file mode 100644 index 0000000000..8b689b5e12 --- /dev/null +++ b/dll/shellext/zipfldr/zipfldr.spec @@ -0,0 +1,5 @@ +@ stdcall -private DllCanUnloadNow() +@ stdcall -private DllGetClassObject(ptr ptr ptr) +@ stdcall -private DllRegisterServer() +@ stdcall -private DllUnregisterServer() +@ stdcall RouteTheCall(ptr ptr wstr long) \ No newline at end of file diff --git a/dll/shellext/zipfldr/zippidl.cpp b/dll/shellext/zipfldr/zippidl.cpp new file mode 100644 index 0000000000..1e1eb9f57f --- /dev/null +++ b/dll/shellext/zipfldr/zippidl.cpp @@ -0,0 +1,42 @@ +/* + * PROJECT: ReactOS Zip Shell Extension + * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * PURPOSE: zip pidl handling + * COPYRIGHT: Copyright 2017 Mark Jansen (mark.jansen(a)reactos.org) + */ + +#include "precomp.h" + +LPITEMIDLIST _ILCreate(ZipPidlType Type, LPCSTR lpString, unz_file_info64& info) +{ + int cbData = sizeof(ZipPidlEntry) + strlen(lpString); + ZipPidlEntry* pidl = (ZipPidlEntry*)SHAlloc(cbData + sizeof(WORD)); + if (!pidl) + return NULL; + + pidl->cb = cbData; + pidl->MagicType = 'z'; + pidl->ZipType = Type; + + if (Type != ZIP_PIDL_DIRECTORY) + { + pidl->CompressedSize = info.compressed_size; + pidl->UncompressedSize = info.uncompressed_size; + pidl->DosDate = info.dosDate; + pidl->Password = info.flag & 1; + } + + strcpy(pidl->Name, lpString); + *(WORD*)((char*)pidl + cbData) = 0; + + return (LPITEMIDLIST)pidl; +} + + +const ZipPidlEntry* _ZipFromIL(LPCITEMIDLIST pidl) +{ + const ZipPidlEntry* zipPidl = (const ZipPidlEntry*)pidl; + if (zipPidl->MagicType == 'z') + return zipPidl; + return NULL; +} diff --git a/dll/shellext/zipfldr/zippidl.hpp b/dll/shellext/zipfldr/zippidl.hpp new file mode 100644 index 0000000000..8c81158525 --- /dev/null +++ b/dll/shellext/zipfldr/zippidl.hpp @@ -0,0 +1,34 @@ +/* + * PROJECT: ReactOS Zip Shell Extension + * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) + * PURPOSE: zip pidl handling + * COPYRIGHT: Copyright 2017 Mark Jansen (mark.jansen(a)reactos.org) + */ + + +enum ZipPidlType +{ + ZIP_PIDL_DIRECTORY, + ZIP_PIDL_FILE +}; + +#include <pshpack1.h> +struct ZipPidlEntry +{ + WORD cb; + BYTE MagicType; + ZipPidlType ZipType; + + ULONG64 CompressedSize; + ULONG64 UncompressedSize; + ULONG DosDate; + BYTE Password; + + char Name[1]; +}; +#include <poppack.h> + + +LPITEMIDLIST _ILCreate(ZipPidlType Type, LPCSTR lpString, unz_file_info64& info); +const ZipPidlEntry* _ZipFromIL(LPCITEMIDLIST pidl); +

1 0

04/06: [ZLIB] Add minizip as library. CORE-7684
by Mark Jansen 07 Apr '18

07 Apr '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=5100859e06f46c6860ee7… commit 5100859e06f46c6860ee7ac8c27772a8433633a9 Author: Mark Jansen <mark.jansen(a)reactos.org> AuthorDate: Tue Apr 3 22:15:20 2018 +0200 Commit: Mark Jansen <mark.jansen(a)reactos.org> CommitDate: Sat Apr 7 15:29:59 2018 +0200 [ZLIB] Add minizip as library. CORE-7684 --- sdk/lib/3rdparty/zlib/CMakeLists.txt | 14 + .../zlib/contrib/minizip/MiniZip64_info.txt | 74 + sdk/lib/3rdparty/zlib/contrib/minizip/crypt.h | 131 ++ sdk/lib/3rdparty/zlib/contrib/minizip/ioapi.c | 250 +++ sdk/lib/3rdparty/zlib/contrib/minizip/ioapi.h | 208 ++ sdk/lib/3rdparty/zlib/contrib/minizip/iowin32.c | 462 +++++ sdk/lib/3rdparty/zlib/contrib/minizip/iowin32.h | 28 + sdk/lib/3rdparty/zlib/contrib/minizip/unzip.c | 2128 ++++++++++++++++++++ sdk/lib/3rdparty/zlib/contrib/minizip/unzip.h | 437 ++++ sdk/lib/3rdparty/zlib/contrib/minizip/zip.c | 2012 ++++++++++++++++++ sdk/lib/3rdparty/zlib/contrib/minizip/zip.h | 362 ++++ 11 files changed, 6106 insertions(+) diff --git a/sdk/lib/3rdparty/zlib/CMakeLists.txt b/sdk/lib/3rdparty/zlib/CMakeLists.txt index b8b2061264..12b02fb3d9 100644 --- a/sdk/lib/3rdparty/zlib/CMakeLists.txt +++ b/sdk/lib/3rdparty/zlib/CMakeLists.txt @@ -21,10 +21,24 @@ list(APPEND SOURCE infback.c uncompr.c) +list(APPEND MINIZIP_SOURCE + contrib/minizip/crypt.h + contrib/minizip/ioapi.c + contrib/minizip/ioapi.h + contrib/minizip/iowin32.c + contrib/minizip/iowin32.h + contrib/minizip/unzip.c + contrib/minizip/unzip.h + contrib/minizip/zip.c + contrib/minizip/zip.h) + + if(CMAKE_CROSSCOMPILING) add_library(zlib ${SOURCE} ${SOLO_SOURCE}) add_library(zlib_solo ${SOLO_SOURCE}) add_target_compile_definitions(zlib_solo Z_SOLO) + add_library(minizip ${MINIZIP_SOURCE}) + add_dependencies(minizip xdk) else() add_library(zlibhost ${SOLO_SOURCE}) add_target_compile_definitions(zlibhost Z_SOLO) diff --git a/sdk/lib/3rdparty/zlib/contrib/minizip/MiniZip64_info.txt b/sdk/lib/3rdparty/zlib/contrib/minizip/MiniZip64_info.txt new file mode 100644 index 0000000000..57d7152420 --- /dev/null +++ b/sdk/lib/3rdparty/zlib/contrib/minizip/MiniZip64_info.txt @@ -0,0 +1,74 @@ +MiniZip - Copyright (c) 1998-2010 - by Gilles Vollant - version 1.1 64 bits from Mathias Svensson + +Introduction +--------------------- +MiniZip 1.1 is built from MiniZip 1.0 by Gilles Vollant ( http://www.winimage.com/zLibDll/minizip.html ) + +When adding ZIP64 support into minizip it would result into risk of breaking compatibility with minizip 1.0. +All possible work was done for compatibility. + + +Background +--------------------- +When adding ZIP64 support Mathias Svensson found that Even Rouault have added ZIP64 +support for unzip.c into minizip for a open source project called gdal ( http://www.gdal.org/ ) + +That was used as a starting point. And after that ZIP64 support was added to zip.c +some refactoring and code cleanup was also done. + + +Changed from MiniZip 1.0 to MiniZip 1.1 +--------------------------------------- +* Added ZIP64 support for unzip ( by Even Rouault ) +* Added ZIP64 support for zip ( by Mathias Svensson ) +* Reverted some changed that Even Rouault did. +* Bunch of patches received from Gulles Vollant that he received for MiniZip from various users. +* Added unzip patch for BZIP Compression method (patch create by Daniel Borca) +* Added BZIP Compress method for zip +* Did some refactoring and code cleanup + + +Credits + + Gilles Vollant - Original MiniZip author + Even Rouault - ZIP64 unzip Support + Daniel Borca - BZip Compression method support in unzip + Mathias Svensson - ZIP64 zip support + Mathias Svensson - BZip Compression method support in zip + + Resources + + ZipLayout http://result42.com/projects/ZipFileLayout + Command line tool for Windows that shows the layout and information of the headers in a zip archive. + Used when debugging and validating the creation of zip files using MiniZip64 + + + ZIP App Note http://www.pkware.com/documents/casestudies/APPNOTE.TXT + Zip File specification + + +Notes. + * To be able to use BZip compression method in zip64.c or unzip64.c the BZIP2 lib is needed and HAVE_BZIP2 need to be defined. + +License +---------------------------------------------------------- + Condition of use and distribution are the same than zlib : + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + +---------------------------------------------------------- + diff --git a/sdk/lib/3rdparty/zlib/contrib/minizip/crypt.h b/sdk/lib/3rdparty/zlib/contrib/minizip/crypt.h new file mode 100644 index 0000000000..1e9e8200b2 --- /dev/null +++ b/sdk/lib/3rdparty/zlib/contrib/minizip/crypt.h @@ -0,0 +1,131 @@ +/* crypt.h -- base code for crypt/uncrypt ZIPfile + + + Version 1.01e, February 12th, 2005 + + Copyright (C) 1998-2005 Gilles Vollant + + This code is a modified version of crypting code in Infozip distribution + + The encryption/decryption parts of this source code (as opposed to the + non-echoing password parts) were originally written in Europe. The + whole source package can be freely distributed, including from the USA. + (Prior to January 2000, re-export from the US was a violation of US law.) + + This encryption code is a direct transcription of the algorithm from + Roger Schlafly, described by Phil Katz in the file appnote.txt. This + file (appnote.txt) is distributed with the PKZIP program (even in the + version without encryption capabilities). + + If you don't need crypting in your application, just define symbols + NOCRYPT and NOUNCRYPT. + + This code support the "Traditional PKWARE Encryption". + + The new AES encryption added on Zip format by Winzip (see the page + http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong + Encryption is not supported. +*/ + +#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8)) + +/*********************************************************************** + * Return the next byte in the pseudo-random sequence + */ +static int decrypt_byte(unsigned long* pkeys, const z_crc_t* pcrc_32_tab) +{ + unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an + * unpredictable manner on 16-bit systems; not a problem + * with any known compiler so far, though */ + + temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2; + return (int)(((temp * (temp ^ 1)) >> 8) & 0xff); +} + +/*********************************************************************** + * Update the encryption keys with the next byte of plain text + */ +static int update_keys(unsigned long* pkeys,const z_crc_t* pcrc_32_tab,int c) +{ + (*(pkeys+0)) = CRC32((*(pkeys+0)), c); + (*(pkeys+1)) += (*(pkeys+0)) & 0xff; + (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1; + { + register int keyshift = (int)((*(pkeys+1)) >> 24); + (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift); + } + return c; +} + + +/*********************************************************************** + * Initialize the encryption keys and the random header according to + * the given password. + */ +static void init_keys(const char* passwd,unsigned long* pkeys,const z_crc_t* pcrc_32_tab) +{ + *(pkeys+0) = 305419896L; + *(pkeys+1) = 591751049L; + *(pkeys+2) = 878082192L; + while (*passwd != '\0') { + update_keys(pkeys,pcrc_32_tab,(int)*passwd); + passwd++; + } +} + +#define zdecode(pkeys,pcrc_32_tab,c) \ + (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab))) + +#define zencode(pkeys,pcrc_32_tab,c,t) \ + (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c)) + +#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED + +#define RAND_HEAD_LEN 12 + /* "last resort" source for second part of crypt seed pattern */ +# ifndef ZCR_SEED2 +# define ZCR_SEED2 3141592654UL /* use PI as default pattern */ +# endif + +static int crypthead(const char* passwd, /* password string */ + unsigned char* buf, /* where to write header */ + int bufSize, + unsigned long* pkeys, + const z_crc_t* pcrc_32_tab, + unsigned long crcForCrypting) +{ + int n; /* index in random header */ + int t; /* temporary */ + int c; /* random byte */ + unsigned char header[RAND_HEAD_LEN-2]; /* random header */ + static unsigned calls = 0; /* ensure different random header each time */ + + if (bufSize<RAND_HEAD_LEN) + return 0; + + /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the + * output of rand() to get less predictability, since rand() is + * often poorly implemented. + */ + if (++calls == 1) + { + srand((unsigned)(time(NULL) ^ ZCR_SEED2)); + } + init_keys(passwd, pkeys, pcrc_32_tab); + for (n = 0; n < RAND_HEAD_LEN-2; n++) + { + c = (rand() >> 7) & 0xff; + header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t); + } + /* Encrypt random header (last two bytes is high word of crc) */ + init_keys(passwd, pkeys, pcrc_32_tab); + for (n = 0; n < RAND_HEAD_LEN-2; n++) + { + buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t); + } + buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t); + buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t); + return n; +} + +#endif diff --git a/sdk/lib/3rdparty/zlib/contrib/minizip/ioapi.c b/sdk/lib/3rdparty/zlib/contrib/minizip/ioapi.c new file mode 100644 index 0000000000..754a98eff1 --- /dev/null +++ b/sdk/lib/3rdparty/zlib/contrib/minizip/ioapi.c @@ -0,0 +1,250 @@ +/* ioapi.h -- IO base function header for compress/uncompress .zip + part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html ) + + Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html ) + + Modifications for Zip64 support + Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) + + For more info read MiniZip_info.txt + +*/ + +#if defined(_WIN32) && (!(defined(_CRT_SECURE_NO_WARNINGS))) + #define _CRT_SECURE_NO_WARNINGS +#endif + +#if defined(__APPLE__) || defined(IOAPI_NO_64) +// In darwin and perhaps other BSD variants off_t is a 64 bit value, hence no need for specific 64 bit functions +#define FOPEN_FUNC(filename, mode) fopen(filename, mode) +#define FTELLO_FUNC(stream) ftello(stream) +#define FSEEKO_FUNC(stream, offset, origin) fseeko(stream, offset, origin) +#else +#define FOPEN_FUNC(filename, mode) fopen64(filename, mode) +#define FTELLO_FUNC(stream) ftello64(stream) +#define FSEEKO_FUNC(stream, offset, origin) fseeko64(stream, offset, origin) +#endif + + +#include "ioapi.h" + +voidpf call_zopen64 (const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode) +{ + if (pfilefunc->zfile_func64.zopen64_file != NULL) + return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque,filename,mode); + else + { + return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque,(const char*)filename,mode); + } +} + +long call_zseek64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin) +{ + if (pfilefunc->zfile_func64.zseek64_file != NULL) + return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin); + else + { + uLong offsetTruncated = (uLong)offset; + if (offsetTruncated != offset) + return -1; + else + return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream,offsetTruncated,origin); + } +} + +ZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream) +{ + if (pfilefunc->zfile_func64.zseek64_file != NULL) + return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream); + else + { + uLong tell_uLong = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream); + if ((tell_uLong) == MAXU32) + return (ZPOS64_T)-1; + else + return tell_uLong; + } +} + +#ifndef __REACTOS__ +void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32) +{ + p_filefunc64_32->zfile_func64.zopen64_file = NULL; + p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file; + p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file; + p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file; + p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file; + p_filefunc64_32->zfile_func64.ztell64_file = NULL; + p_filefunc64_32->zfile_func64.zseek64_file = NULL; + p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file; + p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file; + p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque; + p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file; + p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file; +} + + + +static voidpf ZCALLBACK fopen_file_func OF((voidpf opaque, const char* filename, int mode)); +static uLong ZCALLBACK fread_file_func OF((voidpf opaque, voidpf stream, void* buf, uLong size)); +static uLong ZCALLBACK fwrite_file_func OF((voidpf opaque, voidpf stream, const void* buf,uLong size)); +static ZPOS64_T ZCALLBACK ftell64_file_func OF((voidpf opaque, voidpf stream)); +static long ZCALLBACK fseek64_file_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin)); +static int ZCALLBACK fclose_file_func OF((voidpf opaque, voidpf stream)); +static int ZCALLBACK ferror_file_func OF((voidpf opaque, voidpf stream)); + +static voidpf ZCALLBACK fopen_file_func (voidpf opaque, const char* filename, int mode) +{ + FILE* file = NULL; + const char* mode_fopen = NULL; + if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) + mode_fopen = "rb"; + else + if (mode & ZLIB_FILEFUNC_MODE_EXISTING) + mode_fopen = "r+b"; + else + if (mode & ZLIB_FILEFUNC_MODE_CREATE) + mode_fopen = "wb"; + + if ((filename!=NULL) && (mode_fopen != NULL)) + file = fopen(filename, mode_fopen); + return file; +} + +static voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename, int mode) +{ + FILE* file = NULL; + const char* mode_fopen = NULL; + if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) + mode_fopen = "rb"; + else + if (mode & ZLIB_FILEFUNC_MODE_EXISTING) + mode_fopen = "r+b"; + else + if (mode & ZLIB_FILEFUNC_MODE_CREATE) + mode_fopen = "wb"; + + if ((filename!=NULL) && (mode_fopen != NULL)) + file = FOPEN_FUNC((const char*)filename, mode_fopen); + return file; +} + + +static uLong ZCALLBACK fread_file_func (voidpf opaque, voidpf stream, void* buf, uLong size) +{ + uLong ret; + ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream); + return ret; +} + +static uLong ZCALLBACK fwrite_file_func (voidpf opaque, voidpf stream, const void* buf, uLong size) +{ + uLong ret; + ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream); + return ret; +} + +static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream) +{ + long ret; + ret = ftell((FILE *)stream); + return ret; +} + + +static ZPOS64_T ZCALLBACK ftell64_file_func (voidpf opaque, voidpf stream) +{ + ZPOS64_T ret; + ret = FTELLO_FUNC((FILE *)stream); + return ret; +} + +static long ZCALLBACK fseek_file_func (voidpf opaque, voidpf stream, uLong offset, int origin) +{ + int fseek_origin=0; + long ret; + switch (origin) + { + case ZLIB_FILEFUNC_SEEK_CUR : + fseek_origin = SEEK_CUR; + break; + case ZLIB_FILEFUNC_SEEK_END : + fseek_origin = SEEK_END; + break; + case ZLIB_FILEFUNC_SEEK_SET : + fseek_origin = SEEK_SET; + break; + default: return -1; + } + ret = 0; + if (fseek((FILE *)stream, offset, fseek_origin) != 0) + ret = -1; + return ret; +} + +static long ZCALLBACK fseek64_file_func (voidpf opaque, voidpf stream, ZPOS64_T offset, int origin) +{ + int fseek_origin=0; + long ret; + switch (origin) + { + case ZLIB_FILEFUNC_SEEK_CUR : + fseek_origin = SEEK_CUR; + break; + case ZLIB_FILEFUNC_SEEK_END : + fseek_origin = SEEK_END; + break; + case ZLIB_FILEFUNC_SEEK_SET : + fseek_origin = SEEK_SET; + break; + default: return -1; + } + ret = 0; + + if(FSEEKO_FUNC((FILE *)stream, offset, fseek_origin) != 0) + ret = -1; + + return ret; +} + + +static int ZCALLBACK fclose_file_func (voidpf opaque, voidpf stream) +{ + int ret; + ret = fclose((FILE *)stream); + return ret; +} + +static int ZCALLBACK ferror_file_func (voidpf opaque, voidpf stream) +{ + int ret; + ret = ferror((FILE *)stream); + return ret; +} + +void fill_fopen_filefunc (pzlib_filefunc_def) + zlib_filefunc_def* pzlib_filefunc_def; +{ + pzlib_filefunc_def->zopen_file = fopen_file_func; + pzlib_filefunc_def->zread_file = fread_file_func; + pzlib_filefunc_def->zwrite_file = fwrite_file_func; + pzlib_filefunc_def->ztell_file = ftell_file_func; + pzlib_filefunc_def->zseek_file = fseek_file_func; + pzlib_filefunc_def->zclose_file = fclose_file_func; + pzlib_filefunc_def->zerror_file = ferror_file_func; + pzlib_filefunc_def->opaque = NULL; +} + +void fill_fopen64_filefunc (zlib_filefunc64_def* pzlib_filefunc_def) +{ + pzlib_filefunc_def->zopen64_file = fopen64_file_func; + pzlib_filefunc_def->zread_file = fread_file_func; + pzlib_filefunc_def->zwrite_file = fwrite_file_func; + pzlib_filefunc_def->ztell64_file = ftell64_file_func; + pzlib_filefunc_def->zseek64_file = fseek64_file_func; + pzlib_filefunc_def->zclose_file = fclose_file_func; + pzlib_filefunc_def->zerror_file = ferror_file_func; + pzlib_filefunc_def->opaque = NULL; +} + +#endif diff --git a/sdk/lib/3rdparty/zlib/contrib/minizip/ioapi.h b/sdk/lib/3rdparty/zlib/contrib/minizip/ioapi.h new file mode 100644 index 0000000000..8dcbdb06e3 --- /dev/null +++ b/sdk/lib/3rdparty/zlib/contrib/minizip/ioapi.h @@ -0,0 +1,208 @@ +/* ioapi.h -- IO base function header for compress/uncompress .zip + part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html ) + + Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html ) + + Modifications for Zip64 support + Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) + + For more info read MiniZip_info.txt + + Changes + + Oct-2009 - Defined ZPOS64_T to fpos_t on windows and u_int64_t on linux. (might need to find a better why for this) + Oct-2009 - Change to fseeko64, ftello64 and fopen64 so large files would work on linux. + More if/def section may be needed to support other platforms + Oct-2009 - Defined fxxxx64 calls to normal fopen/ftell/fseek so they would compile on windows. + (but you should use iowin32.c for windows instead) + +*/ + +#ifndef _ZLIBIOAPI64_H +#define _ZLIBIOAPI64_H + +#if (!defined(_WIN32)) && (!defined(WIN32)) && (!defined(__APPLE__)) + + // Linux needs this to support file operation on files larger then 4+GB + // But might need better if/def to select just the platforms that needs them. + + #ifndef __USE_FILE_OFFSET64 + #define __USE_FILE_OFFSET64 + #endif + #ifndef __USE_LARGEFILE64 + #define __USE_LARGEFILE64 + #endif + #ifndef _LARGEFILE64_SOURCE + #define _LARGEFILE64_SOURCE + #endif + #ifndef _FILE_OFFSET_BIT + #define _FILE_OFFSET_BIT 64 + #endif + +#endif + +#include <stdio.h> +#include <stdlib.h> +#include "zlib.h" + +#if defined(USE_FILE32API) +#define fopen64 fopen +#define ftello64 ftell +#define fseeko64 fseek +#else +#ifdef __FreeBSD__ +#define fopen64 fopen +#define ftello64 ftello +#define fseeko64 fseeko +#endif +#ifdef _MSC_VER + #define fopen64 fopen + #if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC))) + #define ftello64 _ftelli64 + #define fseeko64 _fseeki64 + #else // old MSC + #define ftello64 ftell + #define fseeko64 fseek + #endif +#endif +#endif + +/* +#ifndef ZPOS64_T + #ifdef _WIN32 + #define ZPOS64_T fpos_t + #else + #include <stdint.h> + #define ZPOS64_T uint64_t + #endif +#endif +*/ + +#ifdef HAVE_MINIZIP64_CONF_H +#include "mz64conf.h" +#endif + +/* a type choosen by DEFINE */ +#ifdef HAVE_64BIT_INT_CUSTOM +typedef 64BIT_INT_CUSTOM_TYPE ZPOS64_T; +#else +#ifdef HAS_STDINT_H +#include "stdint.h" +typedef uint64_t ZPOS64_T; +#else + +/* Maximum unsigned 32-bit value used as placeholder for zip64 */ +#define MAXU32 0xffffffff + +#if defined(_MSC_VER) || defined(__BORLANDC__) +typedef unsigned __int64 ZPOS64_T; +#else +typedef unsigned long long int ZPOS64_T; +#endif +#endif +#endif + + + +#ifdef __cplusplus +extern "C" { +#endif + + +#define ZLIB_FILEFUNC_SEEK_CUR (1) +#define ZLIB_FILEFUNC_SEEK_END (2) +#define ZLIB_FILEFUNC_SEEK_SET (0) + +#define ZLIB_FILEFUNC_MODE_READ (1) +#define ZLIB_FILEFUNC_MODE_WRITE (2) +#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3) + +#define ZLIB_FILEFUNC_MODE_EXISTING (4) +#define ZLIB_FILEFUNC_MODE_CREATE (8) + + +#ifndef ZCALLBACK + #if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK) + #define ZCALLBACK CALLBACK + #else + #define ZCALLBACK + #endif +#endif + + + + +typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode)); +typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size)); +typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size)); +typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream)); +typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream)); + +typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream)); +typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin)); + + +/* here is the "old" 32 bits structure structure */ +typedef struct zlib_filefunc_def_s +{ + open_file_func zopen_file; + read_file_func zread_file; + write_file_func zwrite_file; + tell_file_func ztell_file; + seek_file_func zseek_file; + close_file_func zclose_file; + testerror_file_func zerror_file; + voidpf opaque; +} zlib_filefunc_def; + +typedef ZPOS64_T (ZCALLBACK *tell64_file_func) OF((voidpf opaque, voidpf stream)); +typedef long (ZCALLBACK *seek64_file_func) OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin)); +typedef voidpf (ZCALLBACK *open64_file_func) OF((voidpf opaque, const void* filename, int mode)); + +typedef struct zlib_filefunc64_def_s +{ + open64_file_func zopen64_file; + read_file_func zread_file; + write_file_func zwrite_file; + tell64_file_func ztell64_file; + seek64_file_func zseek64_file; + close_file_func zclose_file; + testerror_file_func zerror_file; + voidpf opaque; +} zlib_filefunc64_def; + +void fill_fopen64_filefunc OF((zlib_filefunc64_def* pzlib_filefunc_def)); +void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); + +/* now internal definition, only for zip.c and unzip.h */ +typedef struct zlib_filefunc64_32_def_s +{ + zlib_filefunc64_def zfile_func64; + open_file_func zopen32_file; + tell_file_func ztell32_file; + seek_file_func zseek32_file; +} zlib_filefunc64_32_def; + + +#define ZREAD64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zread_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size)) +#define ZWRITE64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zwrite_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size)) +//#define ZTELL64(filefunc,filestream) ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream)) +//#define ZSEEK64(filefunc,filestream,pos,mode) ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode)) +#define ZCLOSE64(filefunc,filestream) ((*((filefunc).zfile_func64.zclose_file)) ((filefunc).zfile_func64.opaque,filestream)) +#define ZERROR64(filefunc,filestream) ((*((filefunc).zfile_func64.zerror_file)) ((filefunc).zfile_func64.opaque,filestream)) + +voidpf call_zopen64 OF((const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode)); +long call_zseek64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin)); +ZPOS64_T call_ztell64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream)); + +void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32); + +#define ZOPEN64(filefunc,filename,mode) (call_zopen64((&(filefunc)),(filename),(mode))) +#define ZTELL64(filefunc,filestream) (call_ztell64((&(filefunc)),(filestream))) +#define ZSEEK64(filefunc,filestream,pos,mode) (call_zseek64((&(filefunc)),(filestream),(pos),(mode))) + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/sdk/lib/3rdparty/zlib/contrib/minizip/iowin32.c b/sdk/lib/3rdparty/zlib/contrib/minizip/iowin32.c new file mode 100644 index 0000000000..cec9b4a046 --- /dev/null +++ b/sdk/lib/3rdparty/zlib/contrib/minizip/iowin32.c @@ -0,0 +1,462 @@ +/* iowin32.c -- IO base function header for compress/uncompress .zip + Version 1.1, February 14h, 2010 + part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html ) + + Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html ) + + Modifications for Zip64 support + Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) + + For more info read MiniZip_info.txt + +*/ + +#include <stdlib.h> + +#include "zlib.h" +#include "ioapi.h" +#include "iowin32.h" + +#ifndef INVALID_HANDLE_VALUE +#define INVALID_HANDLE_VALUE (0xFFFFFFFF) +#endif + +#ifndef INVALID_SET_FILE_POINTER +#define INVALID_SET_FILE_POINTER ((DWORD)-1) +#endif + + +// see Include/shared/winapifamily.h in the Windows Kit +#if defined(WINAPI_FAMILY_PARTITION) && (!(defined(IOWIN32_USING_WINRT_API))) +#if WINAPI_FAMILY_ONE_PARTITION(WINAPI_FAMILY, WINAPI_PARTITION_APP) +#define IOWIN32_USING_WINRT_API 1 +#endif +#endif + +voidpf ZCALLBACK win32_open_file_func OF((voidpf opaque, const char* filename, int mode)); +uLong ZCALLBACK win32_read_file_func OF((voidpf opaque, voidpf stream, void* buf, uLong size)); +uLong ZCALLBACK win32_write_file_func OF((voidpf opaque, voidpf stream, const void* buf, uLong size)); +ZPOS64_T ZCALLBACK win32_tell64_file_func OF((voidpf opaque, voidpf stream)); +long ZCALLBACK win32_seek64_file_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin)); +int ZCALLBACK win32_close_file_func OF((voidpf opaque, voidpf stream)); +int ZCALLBACK win32_error_file_func OF((voidpf opaque, voidpf stream)); + +typedef struct +{ + HANDLE hf; + int error; +} WIN32FILE_IOWIN; + + +static void win32_translate_open_mode(int mode, + DWORD* lpdwDesiredAccess, + DWORD* lpdwCreationDisposition, + DWORD* lpdwShareMode, + DWORD* lpdwFlagsAndAttributes) +{ + *lpdwDesiredAccess = *lpdwShareMode = *lpdwFlagsAndAttributes = *lpdwCreationDisposition = 0; + + if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) + { + *lpdwDesiredAccess = GENERIC_READ; + *lpdwCreationDisposition = OPEN_EXISTING; + *lpdwShareMode = FILE_SHARE_READ; + } + else if (mode & ZLIB_FILEFUNC_MODE_EXISTING) + { + *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ; + *lpdwCreationDisposition = OPEN_EXISTING; + } + else if (mode & ZLIB_FILEFUNC_MODE_CREATE) + { + *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ; + *lpdwCreationDisposition = CREATE_ALWAYS; + } +} + +static voidpf win32_build_iowin(HANDLE hFile) +{ + voidpf ret=NULL; + + if ((hFile != NULL) && (hFile != INVALID_HANDLE_VALUE)) + { + WIN32FILE_IOWIN w32fiow; + w32fiow.hf = hFile; + w32fiow.error = 0; + ret = malloc(sizeof(WIN32FILE_IOWIN)); + + if (ret==NULL) + CloseHandle(hFile); + else + *((WIN32FILE_IOWIN*)ret) = w32fiow; + } + return ret; +} + +voidpf ZCALLBACK win32_open64_file_func (voidpf opaque,const void* filename,int mode) +{ + //const char* mode_fopen = NULL; + DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ; + HANDLE hFile = NULL; + + win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes); + +#ifdef IOWIN32_USING_WINRT_API +#ifdef UNICODE + if ((filename!=NULL) && (dwDesiredAccess != 0)) + hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL); +#else + if ((filename!=NULL) && (dwDesiredAccess != 0)) + { + WCHAR filenameW[FILENAME_MAX + 0x200 + 1]; + MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200); + hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL); + } +#endif +#else + if ((filename!=NULL) && (dwDesiredAccess != 0)) + hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL); +#endif + + return win32_build_iowin(hFile); +} + + +voidpf ZCALLBACK win32_open64_file_funcA (voidpf opaque,const void* filename,int mode) +{ + //const char* mode_fopen = NULL; + DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ; + HANDLE hFile = NULL; + + win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes); + +#ifdef IOWIN32_USING_WINRT_API + if ((filename!=NULL) && (dwDesiredAccess != 0)) + { + WCHAR filenameW[FILENAME_MAX + 0x200 + 1]; + MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200); + hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL); + } +#else + if ((filename!=NULL) && (dwDesiredAccess != 0)) + hFile = CreateFileA((LPCSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL); +#endif + + return win32_build_iowin(hFile); +} + + +voidpf ZCALLBACK win32_open64_file_funcW (voidpf opaque,const void* filename,int mode) +{ + //const char* mode_fopen = NULL; + DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ; + HANDLE hFile = NULL; + + win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes); + +#ifdef IOWIN32_USING_WINRT_API + if ((filename!=NULL) && (dwDesiredAccess != 0)) + hFile = CreateFile2((LPCWSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition,NULL); +#else + if ((filename!=NULL) && (dwDesiredAccess != 0)) + hFile = CreateFileW((LPCWSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL); +#endif + + return win32_build_iowin(hFile); +} + + +voidpf ZCALLBACK win32_open_file_func (voidpf opaque,const char* filename,int mode) +{ + //const char* mode_fopen = NULL; + DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ; + HANDLE hFile = NULL; + + win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes); + +#ifdef IOWIN32_USING_WINRT_API +#ifdef UNICODE + if ((filename!=NULL) && (dwDesiredAccess != 0)) + hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL); +#else + if ((filename!=NULL) && (dwDesiredAccess != 0)) + { + WCHAR filenameW[FILENAME_MAX + 0x200 + 1]; + MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200); + hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL); + } +#endif +#else + if ((filename!=NULL) && (dwDesiredAccess != 0)) + hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL); +#endif + + return win32_build_iowin(hFile); +} + + +uLong ZCALLBACK win32_read_file_func (voidpf opaque, voidpf stream, void* buf,uLong size) +{ + uLong ret=0; + HANDLE hFile = NULL; + if (stream!=NULL) + hFile = ((WIN32FILE_IOWIN*)stream) -> hf; + + if (hFile != NULL) + { + if (!ReadFile(hFile, buf, size, &ret, NULL)) + { + DWORD dwErr = GetLastError(); + if (dwErr == ERROR_HANDLE_EOF) + dwErr = 0; + ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; + } + } + + return ret; +} + + +uLong ZCALLBACK win32_write_file_func (voidpf opaque,voidpf stream,const void* buf,uLong size) +{ + uLong ret=0; + HANDLE hFile = NULL; + if (stream!=NULL) + hFile = ((WIN32FILE_IOWIN*)stream) -> hf; + + if (hFile != NULL) + { + if (!WriteFile(hFile, buf, size, &ret, NULL)) + { + DWORD dwErr = GetLastError(); + if (dwErr == ERROR_HANDLE_EOF) + dwErr = 0; + ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; + } + } + + return ret; +} + +static BOOL MySetFilePointerEx(HANDLE hFile, LARGE_INTEGER pos, LARGE_INTEGER *newPos, DWORD dwMoveMethod) +{ +#ifdef IOWIN32_USING_WINRT_API + return SetFilePointerEx(hFile, pos, newPos, dwMoveMethod); +#else + LONG lHigh = pos.HighPart; + DWORD dwNewPos = SetFilePointer(hFile, pos.LowPart, &lHigh, dwMoveMethod); + BOOL fOk = TRUE; + if (dwNewPos == 0xFFFFFFFF) + if (GetLastError() != NO_ERROR) + fOk = FALSE; + if ((newPos != NULL) && (fOk)) + { + newPos->LowPart = dwNewPos; + newPos->HighPart = lHigh; + } + return fOk; +#endif +} + +long ZCALLBACK win32_tell_file_func (voidpf opaque,voidpf stream) +{ + long ret=-1; + HANDLE hFile = NULL; + if (stream!=NULL) + hFile = ((WIN32FILE_IOWIN*)stream) -> hf; + if (hFile != NULL) + { + LARGE_INTEGER pos; + pos.QuadPart = 0; + + if (!MySetFilePointerEx(hFile, pos, &pos, FILE_CURRENT)) + { + DWORD dwErr = GetLastError(); + ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; + ret = -1; + } + else + ret=(long)pos.LowPart; + } + return ret; +} + +ZPOS64_T ZCALLBACK win32_tell64_file_func (voidpf opaque, voidpf stream) +{ + ZPOS64_T ret= (ZPOS64_T)-1; + HANDLE hFile = NULL; + if (stream!=NULL) + hFile = ((WIN32FILE_IOWIN*)stream)->hf; + + if (hFile) + { + LARGE_INTEGER pos; + pos.QuadPart = 0; + + if (!MySetFilePointerEx(hFile, pos, &pos, FILE_CURRENT)) + { + DWORD dwErr = GetLastError(); + ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; + ret = (ZPOS64_T)-1; + } + else + ret=pos.QuadPart; + } + return ret; +} + + +long ZCALLBACK win32_seek_file_func (voidpf opaque,voidpf stream,uLong offset,int origin) +{ + DWORD dwMoveMethod=0xFFFFFFFF; + HANDLE hFile = NULL; + + long ret=-1; + if (stream!=NULL) + hFile = ((WIN32FILE_IOWIN*)stream) -> hf; + switch (origin) + { + case ZLIB_FILEFUNC_SEEK_CUR : + dwMoveMethod = FILE_CURRENT; + break; + case ZLIB_FILEFUNC_SEEK_END : + dwMoveMethod = FILE_END; + break; + case ZLIB_FILEFUNC_SEEK_SET : + dwMoveMethod = FILE_BEGIN; + break; + default: return -1; + } + + if (hFile != NULL) + { + LARGE_INTEGER pos; + pos.QuadPart = offset; + if (!MySetFilePointerEx(hFile, pos, NULL, dwMoveMethod)) + { + DWORD dwErr = GetLastError(); + ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; + ret = -1; + } + else + ret=0; + } + return ret; +} + +long ZCALLBACK win32_seek64_file_func (voidpf opaque, voidpf stream,ZPOS64_T offset,int origin) +{ + DWORD dwMoveMethod=0xFFFFFFFF; + HANDLE hFile = NULL; + long ret=-1; + + if (stream!=NULL) + hFile = ((WIN32FILE_IOWIN*)stream)->hf; + + switch (origin) + { + case ZLIB_FILEFUNC_SEEK_CUR : + dwMoveMethod = FILE_CURRENT; + break; + case ZLIB_FILEFUNC_SEEK_END : + dwMoveMethod = FILE_END; + break; + case ZLIB_FILEFUNC_SEEK_SET : + dwMoveMethod = FILE_BEGIN; + break; + default: return -1; + } + + if (hFile) + { + LARGE_INTEGER pos; + pos.QuadPart = offset; + if (!MySetFilePointerEx(hFile, pos, NULL, dwMoveMethod)) + { + DWORD dwErr = GetLastError(); + ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; + ret = -1; + } + else + ret=0; + } + return ret; +} + +int ZCALLBACK win32_close_file_func (voidpf opaque, voidpf stream) +{ + int ret=-1; + + if (stream!=NULL) + { + HANDLE hFile; + hFile = ((WIN32FILE_IOWIN*)stream) -> hf; + if (hFile != NULL) + { + CloseHandle(hFile); + ret=0; + } + free(stream); + } + return ret; +} + +int ZCALLBACK win32_error_file_func (voidpf opaque,voidpf stream) +{ + int ret=-1; + if (stream!=NULL) + { + ret = ((WIN32FILE_IOWIN*)stream) -> error; + } + return ret; +} + +void fill_win32_filefunc (zlib_filefunc_def* pzlib_filefunc_def) +{ + pzlib_filefunc_def->zopen_file = win32_open_file_func; + pzlib_filefunc_def->zread_file = win32_read_file_func; + pzlib_filefunc_def->zwrite_file = win32_write_file_func; + pzlib_filefunc_def->ztell_file = win32_tell_file_func; + pzlib_filefunc_def->zseek_file = win32_seek_file_func; + pzlib_filefunc_def->zclose_file = win32_close_file_func; + pzlib_filefunc_def->zerror_file = win32_error_file_func; + pzlib_filefunc_def->opaque = NULL; +} + +void fill_win32_filefunc64(zlib_filefunc64_def* pzlib_filefunc_def) +{ + pzlib_filefunc_def->zopen64_file = win32_open64_file_func; + pzlib_filefunc_def->zread_file = win32_read_file_func; + pzlib_filefunc_def->zwrite_file = win32_write_file_func; + pzlib_filefunc_def->ztell64_file = win32_tell64_file_func; + pzlib_filefunc_def->zseek64_file = win32_seek64_file_func; + pzlib_filefunc_def->zclose_file = win32_close_file_func; + pzlib_filefunc_def->zerror_file = win32_error_file_func; + pzlib_filefunc_def->opaque = NULL; +} + + +void fill_win32_filefunc64A(zlib_filefunc64_def* pzlib_filefunc_def) +{ + pzlib_filefunc_def->zopen64_file = win32_open64_file_funcA; + pzlib_filefunc_def->zread_file = win32_read_file_func; + pzlib_filefunc_def->zwrite_file = win32_write_file_func; + pzlib_filefunc_def->ztell64_file = win32_tell64_file_func; + pzlib_filefunc_def->zseek64_file = win32_seek64_file_func; + pzlib_filefunc_def->zclose_file = win32_close_file_func; + pzlib_filefunc_def->zerror_file = win32_error_file_func; + pzlib_filefunc_def->opaque = NULL; +} + + +void fill_win32_filefunc64W(zlib_filefunc64_def* pzlib_filefunc_def) +{ + pzlib_filefunc_def->zopen64_file = win32_open64_file_funcW; + pzlib_filefunc_def->zread_file = win32_read_file_func; + pzlib_filefunc_def->zwrite_file = win32_write_file_func; + pzlib_filefunc_def->ztell64_file = win32_tell64_file_func; + pzlib_filefunc_def->zseek64_file = win32_seek64_file_func; + pzlib_filefunc_def->zclose_file = win32_close_file_func; + pzlib_filefunc_def->zerror_file = win32_error_file_func; + pzlib_filefunc_def->opaque = NULL; +} diff --git a/sdk/lib/3rdparty/zlib/contrib/minizip/iowin32.h b/sdk/lib/3rdparty/zlib/contrib/minizip/iowin32.h new file mode 100644 index 0000000000..0ca0969a7d --- /dev/null +++ b/sdk/lib/3rdparty/zlib/contrib/minizip/iowin32.h @@ -0,0 +1,28 @@ +/* iowin32.h -- IO base function header for compress/uncompress .zip + Version 1.1, February 14h, 2010 + part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html ) + + Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html ) + + Modifications for Zip64 support + Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) + + For more info read MiniZip_info.txt + +*/ + +#include <windows.h> + + +#ifdef __cplusplus +extern "C" { +#endif + +void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); +void fill_win32_filefunc64 OF((zlib_filefunc64_def* pzlib_filefunc_def)); +void fill_win32_filefunc64A OF((zlib_filefunc64_def* pzlib_filefunc_def)); +void fill_win32_filefunc64W OF((zlib_filefunc64_def* pzlib_filefunc_def)); + +#ifdef __cplusplus +} +#endif diff --git a/sdk/lib/3rdparty/zlib/contrib/minizip/unzip.c b/sdk/lib/3rdparty/zlib/contrib/minizip/unzip.c new file mode 100644 index 0000000000..c88b4b7de1 --- /dev/null +++ b/sdk/lib/3rdparty/zlib/contrib/minizip/unzip.c @@ -0,0 +1,2128 @@ +/* unzip.c -- IO for uncompress .zip files using zlib + Version 1.1, February 14h, 2010 + part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html ) + + Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html ) + + Modifications of Unzip for Zip64 + Copyright (C) 2007-2008 Even Rouault + + Modifications for Zip64 support on both zip and unzip + Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) + + For more info read MiniZip_info.txt + + + ------------------------------------------------------------------------------------ + Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of + compatibility with older software. The following is from the original crypt.c. + Code woven in by Terry Thorsen 1/2003. + + Copyright (c) 1990-2000 Info-ZIP. All rights reserved. + + See the accompanying file LICENSE, version 2000-Apr-09 or later + (the contents of which are also included in zip.h) for terms of use. + If, for some reason, all these files are missing, the Info-ZIP license + also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html + + crypt.c (full version) by Info-ZIP. Last revised: [see crypt.h] + + The encryption/decryption parts of this source code (as opposed to the + non-echoing password parts) were originally written in Europe. The + whole source package can be freely distributed, including from the USA. + (Prior to January 2000, re-export from the US was a violation of US law.) + + This encryption code is a direct transcription of the algorithm from + Roger Schlafly, described by Phil Katz in the file appnote.txt. This + file (appnote.txt) is distributed with the PKZIP program (even in the + version without encryption capabilities). + + ------------------------------------------------------------------------------------ + + Changes in unzip.c + + 2007-2008 - Even Rouault - Addition of cpl_unzGetCurrentFileZStreamPos + 2007-2008 - Even Rouault - Decoration of symbol names unz* -> cpl_unz* + 2007-2008 - Even Rouault - Remove old C style function prototypes + 2007-2008 - Even Rouault - Add unzip support for ZIP64 + + Copyright (C) 2007-2008 Even Rouault + + + Oct-2009 - Mathias Svensson - Removed cpl_* from symbol names (Even Rouault added them but since this is now moved to a new project (minizip64) I renamed them again). + Oct-2009 - Mathias Svensson - Fixed problem if uncompressed size was > 4G and compressed size was <4G + should only read the compressed/uncompressed size from the Zip64 format if + the size from normal header was 0xFFFFFFFF + Oct-2009 - Mathias Svensson - Applied some bug fixes from paches recived from Gilles Vollant + Oct-2009 - Mathias Svensson - Applied support to unzip files with compression mathod BZIP2 (bzip2 lib is required) + Patch created by Daniel Borca + + Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer + + Copyright (C) 1998 - 2010 Gilles Vollant, Even Rouault, Mathias Svensson + +*/ + + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#ifndef NOUNCRYPT + #define NOUNCRYPT +#endif + +#include "zlib.h" +#include "unzip.h" + +#ifdef STDC +# include <stddef.h> +# include <string.h> +# include <stdlib.h> +#endif +#ifdef NO_ERRNO_H + extern int errno; +#else +# include <errno.h> +#endif + + +#ifndef local +# define local static +#endif +/* compile with -Dlocal if your debugger can't find static symbols */ + + +#ifndef CASESENSITIVITYDEFAULT_NO +# if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) +# define CASESENSITIVITYDEFAULT_NO +# endif +#endif + + +#ifndef UNZ_BUFSIZE +#define UNZ_BUFSIZE (16384) +#endif + +#ifndef UNZ_MAXFILENAMEINZIP +#define UNZ_MAXFILENAMEINZIP (256) +#endif + +#ifndef ALLOC +# define ALLOC(size) (malloc(size)) +#endif +#ifndef TRYFREE +# define TRYFREE(p) {if (p) free(p);} +#endif + +#define SIZECENTRALDIRITEM (0x2e) +#define SIZEZIPLOCALHEADER (0x1e) + + +const char unz_copyright[] = + " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll"; + +/* unz_file_info_interntal contain internal info about a file in zipfile*/ +typedef struct unz_file_info64_internal_s +{ + ZPOS64_T offset_curfile;/* relative offset of local header 8 bytes */ +} unz_file_info64_internal; + + +/* file_in_zip_read_info_s contain internal information about a file in zipfile, + when reading and decompress it */ +typedef struct +{ + char *read_buffer; /* internal buffer for compressed data */ + z_stream stream; /* zLib stream structure for inflate */ + +#ifdef HAVE_BZIP2 + bz_stream bstream; /* bzLib stream structure for bziped */ +#endif + + ZPOS64_T pos_in_zipfile; /* position in byte on the zipfile, for fseek*/ + uLong stream_initialised; /* flag set if stream structure is initialised*/ + + ZPOS64_T offset_local_extrafield;/* offset of the local extra field */ + uInt size_local_extrafield;/* size of the local extra field */ + ZPOS64_T pos_local_extrafield; /* position in the local extra field in read*/ + ZPOS64_T total_out_64; + + uLong crc32; /* crc32 of all data uncompressed */ + uLong crc32_wait; /* crc32 we must obtain after decompress all */ + ZPOS64_T rest_read_compressed; /* number of byte to be decompressed */ + ZPOS64_T rest_read_uncompressed;/*number of byte to be obtained after decomp*/ + zlib_filefunc64_32_def z_filefunc; + voidpf filestream; /* io structore of the zipfile */ + uLong compression_method; /* compression method (0==store) */ + ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ + int raw; +} file_in_zip64_read_info_s; + + +/* unz64_s contain internal information about the zipfile +*/ +typedef struct +{ + zlib_filefunc64_32_def z_filefunc; + int is64bitOpenFunction; + voidpf filestream; /* io structore of the zipfile */ + unz_global_info64 gi; /* public global information */ + ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ + ZPOS64_T num_file; /* number of the current file in the zipfile*/ + ZPOS64_T pos_in_central_dir; /* pos of the current file in the central dir*/ + ZPOS64_T current_file_ok; /* flag about the usability of the current file*/ + ZPOS64_T central_pos; /* position of the beginning of the central dir*/ + + ZPOS64_T size_central_dir; /* size of the central directory */ + ZPOS64_T offset_central_dir; /* offset of start of central directory with + respect to the starting disk number */ + + unz_file_info64 cur_file_info; /* public info about the current file in zip*/ + unz_file_info64_internal cur_file_info_internal; /* private info about it*/ + file_in_zip64_read_info_s* pfile_in_zip_read; /* structure about the current + file if we are decompressing it */ + int encrypted; + + int isZip64; + +# ifndef NOUNCRYPT + unsigned long keys[3]; /* keys defining the pseudo-random sequence */ + const z_crc_t* pcrc_32_tab; +# endif +} unz64_s; + + +#ifndef NOUNCRYPT +#include "crypt.h" +#endif + +/* =========================================================================== + Read a byte from a gz_stream; update next_in and avail_in. Return EOF + for end of file. + IN assertion: the stream s has been successfully opened for reading. +*/ + + +local int unz64local_getByte OF(( + const zlib_filefunc64_32_def* pzlib_filefunc_def, + voidpf filestream, + int *pi)); + +local int unz64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi) +{ + unsigned char c; + int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1); + if (err==1) + { + *pi = (int)c; + return UNZ_OK; + } + else + { + if (ZERROR64(*pzlib_filefunc_def,filestream)) + return UNZ_ERRNO; + else + return UNZ_EOF; + } +} + + +/* =========================================================================== + Reads a long in LSB order from the given gz_stream. Sets +*/ +local int unz64local_getShort OF(( + const zlib_filefunc64_32_def* pzlib_filefunc_def, + voidpf filestream, + uLong *pX)); + +local int unz64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def, + voidpf filestream, + uLong *pX) +{ + uLong x ; + int i = 0; + int err; + + err = unz64local_getByte(pzlib_filefunc_def,filestream,&i); + x = (uLong)i; + + if (err==UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def,filestream,&i); + x |= ((uLong)i)<<8; + + if (err==UNZ_OK) + *pX = x; + else + *pX = 0; + return err; +} + +local int unz64local_getLong OF(( + const zlib_filefunc64_32_def* pzlib_filefunc_def, + voidpf filestream, + uLong *pX)); + +local int unz64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def, + voidpf filestream, + uLong *pX) +{ + uLong x ; + int i = 0; + int err; + + err = unz64local_getByte(pzlib_filefunc_def,filestream,&i); + x = (uLong)i; + + if (err==UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def,filestream,&i); + x |= ((uLong)i)<<8; + + if (err==UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def,filestream,&i); + x |= ((uLong)i)<<16; + + if (err==UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((uLong)i)<<24; + + if (err==UNZ_OK) + *pX = x; + else + *pX = 0; + return err; +} + +local int unz64local_getLong64 OF(( + const zlib_filefunc64_32_def* pzlib_filefunc_def, + voidpf filestream, + ZPOS64_T *pX)); + + +local int unz64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def, + voidpf filestream, + ZPOS64_T *pX) +{ + ZPOS64_T x ; + int i = 0; + int err; + + err = unz64local_getByte(pzlib_filefunc_def,filestream,&i); + x = (ZPOS64_T)i; + + if (err==UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def,filestream,&i); + x |= ((ZPOS64_T)i)<<8; + + if (err==UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def,filestream,&i); + x |= ((ZPOS64_T)i)<<16; + + if (err==UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def,filestream,&i); + x |= ((ZPOS64_T)i)<<24; + + if (err==UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def,filestream,&i); + x |= ((ZPOS64_T)i)<<32; + + if (err==UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def,filestream,&i); + x |= ((ZPOS64_T)i)<<40; + + if (err==UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def,filestream,&i); + x |= ((ZPOS64_T)i)<<48; + + if (err==UNZ_OK) + err = unz64local_getByte(pzlib_filefunc_def,filestream,&i); + x |= ((ZPOS64_T)i)<<56; + + if (err==UNZ_OK) + *pX = x; + else + *pX = 0; + return err; +} + +/* My own strcmpi / strcasecmp */ +local int strcmpcasenosensitive_internal (const char* fileName1, const char* fileName2) +{ + for (;;) + { + char c1=*(fileName1++); + char c2=*(fileName2++); + if ((c1>='a') && (c1<='z')) + c1 -= 0x20; + if ((c2>='a') && (c2<='z')) + c2 -= 0x20; + if (c1=='\0') + return ((c2=='\0') ? 0 : -1); + if (c2=='\0') + return 1; + if (c1<c2) + return -1; + if (c1>c2) + return 1; + } +} + + +#ifdef CASESENSITIVITYDEFAULT_NO +#define CASESENSITIVITYDEFAULTVALUE 2 +#else +#define CASESENSITIVITYDEFAULTVALUE 1 +#endif + +#ifndef STRCMPCASENOSENTIVEFUNCTION +#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal +#endif + +/* + Compare two filename (fileName1,fileName2). + If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp) + If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi + or strcasecmp) + If iCaseSenisivity = 0, case sensitivity is defaut of your operating system + (like 1 on Unix, 2 on Windows) + +*/ +extern int ZEXPORT unzStringFileNameCompare (const char* fileName1, + const char* fileName2, + int iCaseSensitivity) + +{ + if (iCaseSensitivity==0) + iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE; + + if (iCaseSensitivity==1) + return strcmp(fileName1,fileName2); + + return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2); +} + +#ifndef BUFREADCOMMENT +#define BUFREADCOMMENT (0x400) +#endif + +/* + Locate the Central directory of a zipfile (at the end, just before + the global comment) +*/ +local ZPOS64_T unz64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)); +local ZPOS64_T unz64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream) +{ + unsigned char* buf; + ZPOS64_T uSizeFile; + ZPOS64_T uBackRead; + ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */ + ZPOS64_T uPosFound=0; + + if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) + return 0; + + + uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream); + + if (uMaxBack>uSizeFile) + uMaxBack = uSizeFile; + + buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); + if (buf==NULL) + return 0; + + uBackRead = 4; + while (uBackRead<uMaxBack) + { + uLong uReadSize; + ZPOS64_T uReadPos ; + int i; + if (uBackRead+BUFREADCOMMENT>uMaxBack) + uBackRead = uMaxBack; + else + uBackRead+=BUFREADCOMMENT; + uReadPos = uSizeFile-uBackRead ; + + uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? + (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos); + if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) + break; + + if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) + break; + + for (i=(int)uReadSize-3; (i--)>0;) + if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && + ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) + { + uPosFound = uReadPos+i; + break; + } + + if (uPosFound!=0) + break; + } + TRYFREE(buf); + return uPosFound; +} + + +/* + Locate the Central directory 64 of a zipfile (at the end, just before + the global comment) +*/ +local ZPOS64_T unz64local_SearchCentralDir64 OF(( + const zlib_filefunc64_32_def* pzlib_filefunc_def, + voidpf filestream)); + +local ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def, + voidpf filestream) +{ + unsigned char* buf; + ZPOS64_T uSizeFile; + ZPOS64_T uBackRead; + ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */ + ZPOS64_T uPosFound=0; + uLong uL; + ZPOS64_T relativeOffset; + + if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) + return 0; + + + uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream); + + if (uMaxBack>uSizeFile) + uMaxBack = uSizeFile; + + buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); + if (buf==NULL) + return 0; + + uBackRead = 4; + while (uBackRead<uMaxBack) + { + uLong uReadSize; + ZPOS64_T uReadPos; + int i; + if (uBackRead+BUFREADCOMMENT>uMaxBack) + uBackRead = uMaxBack; + else + uBackRead+=BUFREADCOMMENT; + uReadPos = uSizeFile-uBackRead ; + + uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? + (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos); + if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) + break; + + if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) + break; + + for (i=(int)uReadSize-3; (i--)>0;) + if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && + ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07)) + { + uPosFound = uReadPos+i; + break; + } + + if (uPosFound!=0) + break; + } + TRYFREE(buf); + if (uPosFound == 0) + return 0; + + /* Zip64 end of central directory locator */ + if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0) + return 0; + + /* the signature, already checked */ + if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK) + return 0; + + /* number of the disk with the start of the zip64 end of central directory */ + if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK) + return 0; + if (uL != 0) + return 0; + + /* relative offset of the zip64 end of central directory record */ + if (unz64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=UNZ_OK) + return 0; + + /* total number of disks */ + if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK) + return 0; + if (uL != 1) + return 0; + + /* Goto end of central directory record */ + if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0) + return 0; + + /* the signature */ + if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK) + return 0; + + if (uL != 0x06064b50) + return 0; + + return relativeOffset; +} + +/* + Open a Zip file. path contain the full pathname (by example, + on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer + "zlib/zlib114.zip". + If the zipfile cannot be opened (file doesn't exist or in not valid), the + return value is NULL. + Else, the return value is a unzFile Handle, usable with other function + of this unzip package. +*/ +local unzFile unzOpenInternal (const void *path, + zlib_filefunc64_32_def* pzlib_filefunc64_32_def, + int is64bitOpenFunction) +{ + unz64_s us; + unz64_s *s; + ZPOS64_T central_pos; + uLong uL; + + uLong number_disk; /* number of the current dist, used for + spaning ZIP, unsupported, always 0*/ + uLong number_disk_with_CD; /* number the the disk with central dir, used + for spaning ZIP, unsupported, always 0*/ + ZPOS64_T number_entry_CD; /* total number of entries in + the central dir + (same than number_entry on nospan) */ + + int err=UNZ_OK; + + if (unz_copyright[0]!=' ') + return NULL; + + us.z_filefunc.zseek32_file = NULL; + us.z_filefunc.ztell32_file = NULL; +#ifndef __REACTOS__ + if (pzlib_filefunc64_32_def==NULL) + fill_fopen64_filefunc(&us.z_filefunc.zfile_func64); + else +#endif + us.z_filefunc = *pzlib_filefunc64_32_def; + us.is64bitOpenFunction = is64bitOpenFunction; + + + + us.filestream = ZOPEN64(us.z_filefunc, + path, + ZLIB_FILEFUNC_MODE_READ | + ZLIB_FILEFUNC_MODE_EXISTING); + if (us.filestream==NULL) + return NULL; + + central_pos = unz64local_SearchCentralDir64(&us.z_filefunc,us.filestream); + if (central_pos) + { + uLong uS; + ZPOS64_T uL64; + + us.isZip64 = 1; + + if (ZSEEK64(us.z_filefunc, us.filestream, + central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) + err=UNZ_ERRNO; + + /* the signature, already checked */ + if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK) + err=UNZ_ERRNO; + + /* size of zip64 end of central directory record */ + if (unz64local_getLong64(&us.z_filefunc, us.filestream,&uL64)!=UNZ_OK) + err=UNZ_ERRNO; + + /* version made by */ + if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK) + err=UNZ_ERRNO; + + /* version needed to extract */ + if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK) + err=UNZ_ERRNO; + + /* number of this disk */ + if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK) + err=UNZ_ERRNO; + + /* number of the disk with the start of the central directory */ + if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK) + err=UNZ_ERRNO; + + /* total number of entries in the central directory on this disk */ + if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK) + err=UNZ_ERRNO; + + /* total number of entries in the central directory */ + if (unz64local_getLong64(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK) + err=UNZ_ERRNO; + + if ((number_entry_CD!=us.gi.number_entry) || + (number_disk_with_CD!=0) || + (number_disk!=0)) + err=UNZ_BADZIPFILE; + + /* size of the central directory */ + if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK) + err=UNZ_ERRNO; + + /* offset of start of central directory with respect to the + starting disk number */ + if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK) + err=UNZ_ERRNO; + + us.gi.size_comment = 0; + } + else + { + central_pos = unz64local_SearchCentralDir(&us.z_filefunc,us.filestream); + if (central_pos==0) + err=UNZ_ERRNO; + + us.isZip64 = 0; + + if (ZSEEK64(us.z_filefunc, us.filestream, + central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) + err=UNZ_ERRNO; + + /* the signature, already checked */ + if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK) + err=UNZ_ERRNO; + + /* number of this disk */ + if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK) + err=UNZ_ERRNO; + + /* number of the disk with the start of the central directory */ + if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK) + err=UNZ_ERRNO; + + /* total number of entries in the central dir on this disk */ + if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK) + err=UNZ_ERRNO; + us.gi.number_entry = uL; + + /* total number of entries in the central dir */ + if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK) + err=UNZ_ERRNO; + number_entry_CD = uL; + + if ((number_entry_CD!=us.gi.number_entry) || + (number_disk_with_CD!=0) || + (number_disk!=0)) + err=UNZ_BADZIPFILE; + + /* size of the central directory */ + if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK) + err=UNZ_ERRNO; + us.size_central_dir = uL; + + /* offset of start of central directory with respect to the + starting disk number */ + if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK) + err=UNZ_ERRNO; + us.offset_central_dir = uL; + + /* zipfile comment length */ + if (unz64local_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK) + err=UNZ_ERRNO; + } + + if ((central_pos<us.offset_central_dir+us.size_central_dir) && + (err==UNZ_OK)) + err=UNZ_BADZIPFILE; + + if (err!=UNZ_OK) + { + ZCLOSE64(us.z_filefunc, us.filestream); + return NULL; + } + + us.byte_before_the_zipfile = central_pos - + (us.offset_central_dir+us.size_central_dir); + us.central_pos = central_pos; + us.pfile_in_zip_read = NULL; + us.encrypted = 0; + + + s=(unz64_s*)ALLOC(sizeof(unz64_s)); + if( s != NULL) + { + *s=us; + unzGoToFirstFile((unzFile)s); + } + return (unzFile)s; +} + +#ifndef __REACTOS__ +extern unzFile ZEXPORT unzOpen2 (const char *path, + zlib_filefunc_def* pzlib_filefunc32_def) +{ + if (pzlib_filefunc32_def != NULL) + { + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def); + return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 0); + } + else + return unzOpenInternal(path, NULL, 0); +} +#endif + +extern unzFile ZEXPORT unzOpen2_64 (const void *path, + zlib_filefunc64_def* pzlib_filefunc_def) +{ + if (pzlib_filefunc_def != NULL) + { + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def; + zlib_filefunc64_32_def_fill.ztell32_file = NULL; + zlib_filefunc64_32_def_fill.zseek32_file = NULL; + return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 1); + } + else + return unzOpenInternal(path, NULL, 1); +} + +extern unzFile ZEXPORT unzOpen (const char *path) +{ + return unzOpenInternal(path, NULL, 0); +} + +extern unzFile ZEXPORT unzOpen64 (const void *path) +{ + return unzOpenInternal(path, NULL, 1); +} + +/* + Close a ZipFile opened with unzOpen. + If there is files inside the .Zip opened with unzOpenCurrentFile (see later), + these files MUST be closed with unzCloseCurrentFile before call unzClose. + return UNZ_OK if there is no problem. */ +extern int ZEXPORT unzClose (unzFile file) +{ + unz64_s* s; + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz64_s*)file; + + if (s->pfile_in_zip_read!=NULL) + unzCloseCurrentFile(file); + + ZCLOSE64(s->z_filefunc, s->filestream); + TRYFREE(s); + return UNZ_OK; +} + + +/* + Write info about the ZipFile in the *pglobal_info structure. + No preparation of the structure is needed + return UNZ_OK if there is no problem. */ +extern int ZEXPORT unzGetGlobalInfo64 (unzFile file, unz_global_info64* pglobal_info) +{ + unz64_s* s; + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz64_s*)file; + *pglobal_info=s->gi; + return UNZ_OK; +} + +extern int ZEXPORT unzGetGlobalInfo (unzFile file, unz_global_info* pglobal_info32) +{ + unz64_s* s; + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz64_s*)file; + /* to do : check if number_entry is not truncated */ + pglobal_info32->number_entry = (uLong)s->gi.number_entry; + pglobal_info32->size_comment = s->gi.size_comment; + return UNZ_OK; +} +/* + Translate date/time from Dos format to tm_unz (readable more easilty) +*/ +local void unz64local_DosDateToTmuDate (ZPOS64_T ulDosDate, tm_unz* ptm) +{ + ZPOS64_T uDate; + uDate = (ZPOS64_T)(ulDosDate>>16); + ptm->tm_mday = (uInt)(uDate&0x1f) ; + ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ; + ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ; + + ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800); + ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ; + ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ; +} + +/* + Get Info about the current file in the zipfile, with internal only info +*/ +local int unz64local_GetCurrentFileInfoInternal OF((unzFile file, + unz_file_info64 *pfile_info, + unz_file_info64_internal + *pfile_info_internal, + char *szFileName, + uLong fileNameBufferSize, + void *extraField, + uLong extraFieldBufferSize, + char *szComment, + uLong commentBufferSize)); + +local int unz64local_GetCurrentFileInfoInternal (unzFile file, + unz_file_info64 *pfile_info, + unz_file_info64_internal + *pfile_info_internal, + char *szFileName, + uLong fileNameBufferSize, + void *extraField, + uLong extraFieldBufferSize, + char *szComment, + uLong commentBufferSize) +{ + unz64_s* s; + unz_file_info64 file_info; + unz_file_info64_internal file_info_internal; + int err=UNZ_OK; + uLong uMagic; + long lSeek=0; + uLong uL; + + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz64_s*)file; + if (ZSEEK64(s->z_filefunc, s->filestream, + s->pos_in_central_dir+s->byte_before_the_zipfile, + ZLIB_FILEFUNC_SEEK_SET)!=0) + err=UNZ_ERRNO; + + + /* we check the magic */ + if (err==UNZ_OK) + { + if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK) + err=UNZ_ERRNO; + else if (uMagic!=0x02014b50) + err=UNZ_BADZIPFILE; + } + + if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK) + err=UNZ_ERRNO; + + if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK) + err=UNZ_ERRNO; + + if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK) + err=UNZ_ERRNO; + + if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK) + err=UNZ_ERRNO; + + if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK) + err=UNZ_ERRNO; + + unz64local_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date); + + if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK) + err=UNZ_ERRNO; + + if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK) + err=UNZ_ERRNO; + file_info.compressed_size = uL; + + if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK) + err=UNZ_ERRNO; + file_info.uncompressed_size = uL; + + if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK) + err=UNZ_ERRNO; + + if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK) + err=UNZ_ERRNO; + + if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK) + err=UNZ_ERRNO; + + if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK) + err=UNZ_ERRNO; + + if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK) + err=UNZ_ERRNO; + + if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK) + err=UNZ_ERRNO; + + // relative offset of local header + if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK) + err=UNZ_ERRNO; + file_info_internal.offset_curfile = uL; + + lSeek+=file_info.size_filename; + if ((err==UNZ_OK) && (szFileName!=NULL)) + { + uLong uSizeRead ; + if (file_info.size_filename<fileNameBufferSize) + { + *(szFileName+file_info.size_filename)='\0'; + uSizeRead = file_info.size_filename; + } + else + uSizeRead = fileNameBufferSize; + + if ((file_info.size_filename>0) && (fileNameBufferSize>0)) + if (ZREAD64(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead) + err=UNZ_ERRNO; + lSeek -= uSizeRead; + } + + // Read extrafield + if ((err==UNZ_OK) && (extraField!=NULL)) + { + ZPOS64_T uSizeRead ; + if (file_info.size_file_extra<extraFieldBufferSize) + uSizeRead = file_info.size_file_extra; + else + uSizeRead = extraFieldBufferSize; + + if (lSeek!=0) + { + if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0) + lSeek=0; + else + err=UNZ_ERRNO; + } + + if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0)) + if (ZREAD64(s->z_filefunc, s->filestream,extraField,(uLong)uSizeRead)!=uSizeRead) + err=UNZ_ERRNO; + + lSeek += file_info.size_file_extra - (uLong)uSizeRead; + } + else + lSeek += file_info.size_file_extra; + + + if ((err==UNZ_OK) && (file_info.size_file_extra != 0)) + { + uLong acc = 0; + + // since lSeek now points to after the extra field we need to move back + lSeek -= file_info.size_file_extra; + + if (lSeek!=0) + { + if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0) + lSeek=0; + else + err=UNZ_ERRNO; + } + + while(acc < file_info.size_file_extra) + { + uLong headerId; + uLong dataSize; + + if (unz64local_getShort(&s->z_filefunc, s->filestream,&headerId) != UNZ_OK) + err=UNZ_ERRNO; + + if (unz64local_getShort(&s->z_filefunc, s->filestream,&dataSize) != UNZ_OK) + err=UNZ_ERRNO; + + /* ZIP64 extra fields */ + if (headerId == 0x0001) + { + uLong uL; + + if(file_info.uncompressed_size == MAXU32) + { + if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK) + err=UNZ_ERRNO; + } + + if(file_info.compressed_size == MAXU32) + { + if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK) + err=UNZ_ERRNO; + } + + if(file_info_internal.offset_curfile == MAXU32) + { + /* Relative Header offset */ + if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK) + err=UNZ_ERRNO; + } + + if(file_info.disk_num_start == MAXU32) + { + /* Disk Start Number */ + if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK) + err=UNZ_ERRNO; + } + + } + else + { + if (ZSEEK64(s->z_filefunc, s->filestream,dataSize,ZLIB_FILEFUNC_SEEK_CUR)!=0) + err=UNZ_ERRNO; + } + + acc += 2 + 2 + dataSize; + } + } + + if ((err==UNZ_OK) && (szComment!=NULL)) + { + uLong uSizeRead ; + if (file_info.size_file_comment<commentBufferSize) + { + *(szComment+file_info.size_file_comment)='\0'; + uSizeRead = file_info.size_file_comment; + } + else + uSizeRead = commentBufferSize; + + if (lSeek!=0) + { + if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0) + lSeek=0; + else + err=UNZ_ERRNO; + } + + if ((file_info.size_file_comment>0) && (commentBufferSize>0)) + if (ZREAD64(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead) + err=UNZ_ERRNO; + lSeek+=file_info.size_file_comment - uSizeRead; + } + else + lSeek+=file_info.size_file_comment; + + + if ((err==UNZ_OK) && (pfile_info!=NULL)) + *pfile_info=file_info; + + if ((err==UNZ_OK) && (pfile_info_internal!=NULL)) + *pfile_info_internal=file_info_internal; + + return err; +} + + + +/* + Write info about the ZipFile in the *pglobal_info structure. + No preparation of the structure is needed + return UNZ_OK if there is no problem. +*/ +extern int ZEXPORT unzGetCurrentFileInfo64 (unzFile file, + unz_file_info64 * pfile_info, + char * szFileName, uLong fileNameBufferSize, + void *extraField, uLong extraFieldBufferSize, + char* szComment, uLong commentBufferSize) +{ + return unz64local_GetCurrentFileInfoInternal(file,pfile_info,NULL, + szFileName,fileNameBufferSize, + extraField,extraFieldBufferSize, + szComment,commentBufferSize); +} + +extern int ZEXPORT unzGetCurrentFileInfo (unzFile file, + unz_file_info * pfile_info, + char * szFileName, uLong fileNameBufferSize, + void *extraField, uLong extraFieldBufferSize, + char* szComment, uLong commentBufferSize) +{ + int err; + unz_file_info64 file_info64; + err = unz64local_GetCurrentFileInfoInternal(file,&file_info64,NULL, + szFileName,fileNameBufferSize, + extraField,extraFieldBufferSize, + szComment,commentBufferSize); + if ((err==UNZ_OK) && (pfile_info != NULL)) + { + pfile_info->version = file_info64.version; + pfile_info->version_needed = file_info64.version_needed; + pfile_info->flag = file_info64.flag; + pfile_info->compression_method = file_info64.compression_method; + pfile_info->dosDate = file_info64.dosDate; + pfile_info->crc = file_info64.crc; + + pfile_info->size_filename = file_info64.size_filename; + pfile_info->size_file_extra = file_info64.size_file_extra; + pfile_info->size_file_comment = file_info64.size_file_comment; + + pfile_info->disk_num_start = file_info64.disk_num_start; + pfile_info->internal_fa = file_info64.internal_fa; + pfile_info->external_fa = file_info64.external_fa; + + pfile_info->tmu_date = file_info64.tmu_date, + + + pfile_info->compressed_size = (uLong)file_info64.compressed_size; + pfile_info->uncompressed_size = (uLong)file_info64.uncompressed_size; + + } + return err; +} +/* + Set the current file of the zipfile to the first file. + return UNZ_OK if there is no problem +*/ +extern int ZEXPORT unzGoToFirstFile (unzFile file) +{ + int err=UNZ_OK; + unz64_s* s; + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz64_s*)file; + s->pos_in_central_dir=s->offset_central_dir; + s->num_file=0; + err=unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info, + &s->cur_file_info_internal, + NULL,0,NULL,0,NULL,0); + s->current_file_ok = (err == UNZ_OK); + return err; +} + +/* + Set the current file of the zipfile to the next file. + return UNZ_OK if there is no problem + return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest. +*/ +extern int ZEXPORT unzGoToNextFile (unzFile file) +{ + unz64_s* s; + int err; + + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz64_s*)file; + if (!s->current_file_ok) + return UNZ_END_OF_LIST_OF_FILE; + if (s->gi.number_entry != 0xffff) /* 2^16 files overflow hack */ + if (s->num_file+1==s->gi.number_entry) + return UNZ_END_OF_LIST_OF_FILE; + + s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename + + s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ; + s->num_file++; + err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info, + &s->cur_file_info_internal, + NULL,0,NULL,0,NULL,0); + s->current_file_ok = (err == UNZ_OK); + return err; +} + + +/* + Try locate the file szFileName in the zipfile. + For the iCaseSensitivity signification, see unzStringFileNameCompare + + return value : + UNZ_OK if the file is found. It becomes the current file. + UNZ_END_OF_LIST_OF_FILE if the file is not found +*/ +extern int ZEXPORT unzLocateFile (unzFile file, const char *szFileName, int iCaseSensitivity) +{ + unz64_s* s; + int err; + + /* We remember the 'current' position in the file so that we can jump + * back there if we fail. + */ + unz_file_info64 cur_file_infoSaved; + unz_file_info64_internal cur_file_info_internalSaved; + ZPOS64_T num_fileSaved; + ZPOS64_T pos_in_central_dirSaved; + + + if (file==NULL) + return UNZ_PARAMERROR; + + if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP) + return UNZ_PARAMERROR; + + s=(unz64_s*)file; + if (!s->current_file_ok) + return UNZ_END_OF_LIST_OF_FILE; + + /* Save the current state */ + num_fileSaved = s->num_file; + pos_in_central_dirSaved = s->pos_in_central_dir; + cur_file_infoSaved = s->cur_file_info; + cur_file_info_internalSaved = s->cur_file_info_internal; + + err = unzGoToFirstFile(file); + + while (err == UNZ_OK) + { + char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1]; + err = unzGetCurrentFileInfo64(file,NULL, + szCurrentFileName,sizeof(szCurrentFileName)-1, + NULL,0,NULL,0); + if (err == UNZ_OK) + { + if (unzStringFileNameCompare(szCurrentFileName, + szFileName,iCaseSensitivity)==0) + return UNZ_OK; + err = unzGoToNextFile(file); + } + } + + /* We failed, so restore the state of the 'current file' to where we + * were. + */ + s->num_file = num_fileSaved ; + s->pos_in_central_dir = pos_in_central_dirSaved ; + s->cur_file_info = cur_file_infoSaved; + s->cur_file_info_internal = cur_file_info_internalSaved; + return err; +} + + +/* +/////////////////////////////////////////// +// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net) +// I need random access +// +// Further optimization could be realized by adding an ability +// to cache the directory in memory. The goal being a single +// comprehensive file read to put the file I need in a memory. +*/ + +/* +typedef struct unz_file_pos_s +{ + ZPOS64_T pos_in_zip_directory; // offset in file + ZPOS64_T num_of_file; // # of file +} unz_file_pos; +*/ + +extern int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos* file_pos) +{ + unz64_s* s; + + if (file==NULL || file_pos==NULL) + return UNZ_PARAMERROR; + s=(unz64_s*)file; + if (!s->current_file_ok) + return UNZ_END_OF_LIST_OF_FILE; + + file_pos->pos_in_zip_directory = s->pos_in_central_dir; + file_pos->num_of_file = s->num_file; + + return UNZ_OK; +} + +extern int ZEXPORT unzGetFilePos( + unzFile file, + unz_file_pos* file_pos) +{ + unz64_file_pos file_pos64; + int err = unzGetFilePos64(file,&file_pos64); + if (err==UNZ_OK) + { + file_pos->pos_in_zip_directory = (uLong)file_pos64.pos_in_zip_directory; + file_pos->num_of_file = (uLong)file_pos64.num_of_file; + } + return err; +} + +extern int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos* file_pos) +{ + unz64_s* s; + int err; + + if (file==NULL || file_pos==NULL) + return UNZ_PARAMERROR; + s=(unz64_s*)file; + + /* jump to the right spot */ + s->pos_in_central_dir = file_pos->pos_in_zip_directory; + s->num_file = file_pos->num_of_file; + + /* set the current file */ + err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info, + &s->cur_file_info_internal, + NULL,0,NULL,0,NULL,0); + /* return results */ + s->current_file_ok = (err == UNZ_OK); + return err; +} + +extern int ZEXPORT unzGoToFilePos( + unzFile file, + unz_file_pos* file_pos) +{ + unz64_file_pos file_pos64; + if (file_pos == NULL) + return UNZ_PARAMERROR; + + file_pos64.pos_in_zip_directory = file_pos->pos_in_zip_directory; + file_pos64.num_of_file = file_pos->num_of_file; + return unzGoToFilePos64(file,&file_pos64); +} + +/* +// Unzip Helper Functions - should be here? +/////////////////////////////////////////// +*/ + +/* + Read the local header of the current zipfile + Check the coherency of the local header and info in the end of central + directory about this file + store in *piSizeVar the size of extra info in local header + (filename and size of extra field data) +*/ +local int unz64local_CheckCurrentFileCoherencyHeader (unz64_s* s, uInt* piSizeVar, + ZPOS64_T * poffset_local_extrafield, + uInt * psize_local_extrafield) +{ + uLong uMagic,uData,uFlags; + uLong size_filename; + uLong size_extra_field; + int err=UNZ_OK; + + *piSizeVar = 0; + *poffset_local_extrafield = 0; + *psize_local_extrafield = 0; + + if (ZSEEK64(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile + + s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0) + return UNZ_ERRNO; + + + if (err==UNZ_OK) + { + if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK) + err=UNZ_ERRNO; + else if (uMagic!=0x04034b50) + err=UNZ_BADZIPFILE; + } + + if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) + err=UNZ_ERRNO; +/* + else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion)) + err=UNZ_BADZIPFILE; +*/ + if (unz64local_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK) + err=UNZ_ERRNO; + + if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) + err=UNZ_ERRNO; + else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method)) + err=UNZ_BADZIPFILE; + + if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) && +/* #ifdef HAVE_BZIP2 */ + (s->cur_file_info.compression_method!=Z_BZIP2ED) && +/* #endif */ + (s->cur_file_info.compression_method!=Z_DEFLATED)) + err=UNZ_BADZIPFILE; + + if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */ + err=UNZ_ERRNO; + + if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */ + err=UNZ_ERRNO; + else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) && ((uFlags & 8)==0)) + err=UNZ_BADZIPFILE; + + if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */ + err=UNZ_ERRNO; + else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) && ((uFlags & 8)==0)) + err=UNZ_BADZIPFILE; + + if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */ + err=UNZ_ERRNO; + else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && ((uFlags & 8)==0)) + err=UNZ_BADZIPFILE; + + if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK) + err=UNZ_ERRNO; + else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename)) + err=UNZ_BADZIPFILE; + + *piSizeVar += (uInt)size_filename; + + if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK) + err=UNZ_ERRNO; + *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile + + SIZEZIPLOCALHEADER + size_filename; + *psize_local_extrafield = (uInt)size_extra_field; + + *piSizeVar += (uInt)size_extra_field; + + return err; +} + +/* + Open for reading data the current file in the zipfile. + If there is no error and the file is opened, the return value is UNZ_OK. +*/ +extern int ZEXPORT unzOpenCurrentFile3 (unzFile file, int* method, + int* level, int raw, const char* password) +{ + int err=UNZ_OK; + uInt iSizeVar; + unz64_s* s; + file_in_zip64_read_info_s* pfile_in_zip_read_info; + ZPOS64_T offset_local_extrafield; /* offset of the local extra field */ + uInt size_local_extrafield; /* size of the local extra field */ +# ifndef NOUNCRYPT + char source[12]; +# else + if (password != NULL) + return UNZ_PARAMERROR; +# endif + + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz64_s*)file; + if (!s->current_file_ok) + return UNZ_PARAMERROR; + + if (s->pfile_in_zip_read != NULL) + unzCloseCurrentFile(file); + + if (unz64local_CheckCurrentFileCoherencyHeader(s,&iSizeVar, &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK) + return UNZ_BADZIPFILE; + + pfile_in_zip_read_info = (file_in_zip64_read_info_s*)ALLOC(sizeof(file_in_zip64_read_info_s)); + if (pfile_in_zip_read_info==NULL) + return UNZ_INTERNALERROR; + + pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE); + pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield; + pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield; + pfile_in_zip_read_info->pos_local_extrafield=0; + pfile_in_zip_read_info->raw=raw; + + if (pfile_in_zip_read_info->read_buffer==NULL) + { + TRYFREE(pfile_in_zip_read_info); + return UNZ_INTERNALERROR; + } + + pfile_in_zip_read_info->stream_initialised=0; + + if (method!=NULL) + *method = (int)s->cur_file_info.compression_method; + + if (level!=NULL) + { + *level = 6; + switch (s->cur_file_info.flag & 0x06) + { + case 6 : *level = 1; break; + case 4 : *level = 2; break; + case 2 : *level = 9; break; + } + } + + if ((s->cur_file_info.compression_method!=0) && +/* #ifdef HAVE_BZIP2 */ + (s->cur_file_info.compression_method!=Z_BZIP2ED) && +/* #endif */ + (s->cur_file_info.compression_method!=Z_DEFLATED)) + + err=UNZ_BADZIPFILE; + + pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc; + pfile_in_zip_read_info->crc32=0; + pfile_in_zip_read_info->total_out_64=0; + pfile_in_zip_read_info->compression_method = s->cur_file_info.compression_method; + pfile_in_zip_read_info->filestream=s->filestream; + pfile_in_zip_read_info->z_filefunc=s->z_filefunc; + pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile; + + pfile_in_zip_read_info->stream.total_out = 0; + + if ((s->cur_file_info.compression_method==Z_BZIP2ED) && (!raw)) + { +#ifdef HAVE_BZIP2 + pfile_in_zip_read_info->bstream.bzalloc = (void *(*) (void *, int, int))0; + pfile_in_zip_read_info->bstream.bzfree = (free_func)0; + pfile_in_zip_read_info->bstream.opaque = (voidpf)0; + pfile_in_zip_read_info->bstream.state = (voidpf)0; + + pfile_in_zip_read_info->stream.zalloc = (alloc_func)0; + pfile_in_zip_read_info->stream.zfree = (free_func)0; + pfile_in_zip_read_info->stream.opaque = (voidpf)0; + pfile_in_zip_read_info->stream.next_in = (voidpf)0; + pfile_in_zip_read_info->stream.avail_in = 0; + + err=BZ2_bzDecompressInit(&pfile_in_zip_read_info->bstream, 0, 0); + if (err == Z_OK) + pfile_in_zip_read_info->stream_initialised=Z_BZIP2ED; + else + { + TRYFREE(pfile_in_zip_read_info); + return err; + } +#else + pfile_in_zip_read_info->raw=1; +#endif + } + else if ((s->cur_file_info.compression_method==Z_DEFLATED) && (!raw)) + { + pfile_in_zip_read_info->stream.zalloc = (alloc_func)0; + pfile_in_zip_read_info->stream.zfree = (free_func)0; + pfile_in_zip_read_info->stream.opaque = (voidpf)0; + pfile_in_zip_read_info->stream.next_in = 0; + pfile_in_zip_read_info->stream.avail_in = 0; + + err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS); + if (err == Z_OK) + pfile_in_zip_read_info->stream_initialised=Z_DEFLATED; + else + { + TRYFREE(pfile_in_zip_read_info); + return err; + } + /* windowBits is passed < 0 to tell that there is no zlib header. + * Note that in this case inflate *requires* an extra "dummy" byte + * after the compressed stream in order to complete decompression and + * return Z_STREAM_END. + * In unzip, i don't wait absolutely Z_STREAM_END because I known the + * size of both compressed and uncompressed data + */ + } + pfile_in_zip_read_info->rest_read_compressed = + s->cur_file_info.compressed_size ; + pfile_in_zip_read_info->rest_read_uncompressed = + s->cur_file_info.uncompressed_size ; + + + pfile_in_zip_read_info->pos_in_zipfile = + s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + + iSizeVar; + + pfile_in_zip_read_info->stream.avail_in = (uInt)0; + + s->pfile_in_zip_read = pfile_in_zip_read_info; + s->encrypted = 0; + +# ifndef NOUNCRYPT + if (password != NULL) + { + int i; + s->pcrc_32_tab = get_crc_table(); + init_keys(password,s->keys,s->pcrc_32_tab); + if (ZSEEK64(s->z_filefunc, s->filestream, + s->pfile_in_zip_read->pos_in_zipfile + + s->pfile_in_zip_read->byte_before_the_zipfile, + SEEK_SET)!=0) + return UNZ_INTERNALERROR; + if(ZREAD64(s->z_filefunc, s->filestream,source, 12)<12) + return UNZ_INTERNALERROR; + + for (i = 0; i<12; i++) + zdecode(s->keys,s->pcrc_32_tab,source[i]); + + s->pfile_in_zip_read->pos_in_zipfile+=12; + s->encrypted=1; + } +# endif + + + return UNZ_OK; +} + +extern int ZEXPORT unzOpenCurrentFile (unzFile file) +{ + return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL); +} + +extern int ZEXPORT unzOpenCurrentFilePassword (unzFile file, const char* password) +{ + return unzOpenCurrentFile3(file, NULL, NULL, 0, password); +} + +extern int ZEXPORT unzOpenCurrentFile2 (unzFile file, int* method, int* level, int raw) +{ + return unzOpenCurrentFile3(file, method, level, raw, NULL); +} + +/** Addition for GDAL : START */ + +extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64( unzFile file) +{ + unz64_s* s; + file_in_zip64_read_info_s* pfile_in_zip_read_info; + s=(unz64_s*)file; + if (file==NULL) + return 0; //UNZ_PARAMERROR; + pfile_in_zip_read_info=s->pfile_in_zip_read; + if (pfile_in_zip_read_info==NULL) + return 0; //UNZ_PARAMERROR; + return pfile_in_zip_read_info->pos_in_zipfile + + pfile_in_zip_read_info->byte_before_the_zipfile; +} + +/** Addition for GDAL : END */ + +/* + Read bytes from the current file. + buf contain buffer where data must be copied + len the size of buf. + + return the number of byte copied if somes bytes are copied + return 0 if the end of file was reached + return <0 with error code if there is an error + (UNZ_ERRNO for IO error, or zLib error for uncompress error) +*/ +extern int ZEXPORT unzReadCurrentFile (unzFile file, voidp buf, unsigned len) +{ + int err=UNZ_OK; + uInt iRead = 0; + unz64_s* s; + file_in_zip64_read_info_s* pfile_in_zip_read_info; + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz64_s*)file; + pfile_in_zip_read_info=s->pfile_in_zip_read; + + if (pfile_in_zip_read_info==NULL) + return UNZ_PARAMERROR; + + + if (pfile_in_zip_read_info->read_buffer == NULL) + return UNZ_END_OF_LIST_OF_FILE; + if (len==0) + return 0; + + pfile_in_zip_read_info->stream.next_out = (Bytef*)buf; + + pfile_in_zip_read_info->stream.avail_out = (uInt)len; + + if ((len>pfile_in_zip_read_info->rest_read_uncompressed) && + (!(pfile_in_zip_read_info->raw))) + pfile_in_zip_read_info->stream.avail_out = + (uInt)pfile_in_zip_read_info->rest_read_uncompressed; + + if ((len>pfile_in_zip_read_info->rest_read_compressed+ + pfile_in_zip_read_info->stream.avail_in) && + (pfile_in_zip_read_info->raw)) + pfile_in_zip_read_info->stream.avail_out = + (uInt)pfile_in_zip_read_info->rest_read_compressed+ + pfile_in_zip_read_info->stream.avail_in; + + while (pfile_in_zip_read_info->stream.avail_out>0) + { + if ((pfile_in_zip_read_info->stream.avail_in==0) && + (pfile_in_zip_read_info->rest_read_compressed>0)) + { + uInt uReadThis = UNZ_BUFSIZE; + if (pfile_in_zip_read_info->rest_read_compressed<uReadThis) + uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed; + if (uReadThis == 0) + return UNZ_EOF; + if (ZSEEK64(pfile_in_zip_read_info->z_filefunc, + pfile_in_zip_read_info->filestream, + pfile_in_zip_read_info->pos_in_zipfile + + pfile_in_zip_read_info->byte_before_the_zipfile, + ZLIB_FILEFUNC_SEEK_SET)!=0) + return UNZ_ERRNO; + if (ZREAD64(pfile_in_zip_read_info->z_filefunc, + pfile_in_zip_read_info->filestream, + pfile_in_zip_read_info->read_buffer, + uReadThis)!=uReadThis) + return UNZ_ERRNO; + + +# ifndef NOUNCRYPT + if(s->encrypted) + { + uInt i; + for(i=0;i<uReadThis;i++) + pfile_in_zip_read_info->read_buffer[i] = + zdecode(s->keys,s->pcrc_32_tab, + pfile_in_zip_read_info->read_buffer[i]); + } +# endif + + + pfile_in_zip_read_info->pos_in_zipfile += uReadThis; + + pfile_in_zip_read_info->rest_read_compressed-=uReadThis; + + pfile_in_zip_read_info->stream.next_in = + (Bytef*)pfile_in_zip_read_info->read_buffer; + pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis; + } + + if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw)) + { + uInt uDoCopy,i ; + + if ((pfile_in_zip_read_info->stream.avail_in == 0) && + (pfile_in_zip_read_info->rest_read_compressed == 0)) + return (iRead==0) ? UNZ_EOF : iRead; + + if (pfile_in_zip_read_info->stream.avail_out < + pfile_in_zip_read_info->stream.avail_in) + uDoCopy = pfile_in_zip_read_info->stream.avail_out ; + else + uDoCopy = pfile_in_zip_read_info->stream.avail_in ; + + for (i=0;i<uDoCopy;i++) + *(pfile_in_zip_read_info->stream.next_out+i) = + *(pfile_in_zip_read_info->stream.next_in+i); + + pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uDoCopy; + + pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32, + pfile_in_zip_read_info->stream.next_out, + uDoCopy); + pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy; + pfile_in_zip_read_info->stream.avail_in -= uDoCopy; + pfile_in_zip_read_info->stream.avail_out -= uDoCopy; + pfile_in_zip_read_info->stream.next_out += uDoCopy; + pfile_in_zip_read_info->stream.next_in += uDoCopy; + pfile_in_zip_read_info->stream.total_out += uDoCopy; + iRead += uDoCopy; + } + else if (pfile_in_zip_read_info->compression_method==Z_BZIP2ED) + { +#ifdef HAVE_BZIP2 + uLong uTotalOutBefore,uTotalOutAfter; + const Bytef *bufBefore; + uLong uOutThis; + + pfile_in_zip_read_info->bstream.next_in = (char*)pfile_in_zip_read_info->stream.next_in; + pfile_in_zip_read_info->bstream.avail_in = pfile_in_zip_read_info->stream.avail_in; + pfile_in_zip_read_info->bstream.total_in_lo32 = pfile_in_zip_read_info->stream.total_in; + pfile_in_zip_read_info->bstream.total_in_hi32 = 0; + pfile_in_zip_read_info->bstream.next_out = (char*)pfile_in_zip_read_info->stream.next_out; + pfile_in_zip_read_info->bstream.avail_out = pfile_in_zip_read_info->stream.avail_out; + pfile_in_zip_read_info->bstream.total_out_lo32 = pfile_in_zip_read_info->stream.total_out; + pfile_in_zip_read_info->bstream.total_out_hi32 = 0; + + uTotalOutBefore = pfile_in_zip_read_info->bstream.total_out_lo32; + bufBefore = (const Bytef *)pfile_in_zip_read_info->bstream.next_out; + + err=BZ2_bzDecompress(&pfile_in_zip_read_info->bstream); + + uTotalOutAfter = pfile_in_zip_read_info->bstream.total_out_lo32; + uOutThis = uTotalOutAfter-uTotalOutBefore; + + pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis; + + pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,bufBefore, (uInt)(uOutThis)); + pfile_in_zip_read_info->rest_read_uncompressed -= uOutThis; + iRead += (uInt)(uTotalOutAfter - uTotalOutBefore); + + pfile_in_zip_read_info->stream.next_in = (Bytef*)pfile_in_zip_read_info->bstream.next_in; + pfile_in_zip_read_info->stream.avail_in = pfile_in_zip_read_info->bstream.avail_in; + pfile_in_zip_read_info->stream.total_in = pfile_in_zip_read_info->bstream.total_in_lo32; + pfile_in_zip_read_info->stream.next_out = (Bytef*)pfile_in_zip_read_info->bstream.next_out; + pfile_in_zip_read_info->stream.avail_out = pfile_in_zip_read_info->bstream.avail_out; + pfile_in_zip_read_info->stream.total_out = pfile_in_zip_read_info->bstream.total_out_lo32; + + if (err==BZ_STREAM_END) + return (iRead==0) ? UNZ_EOF : iRead; + if (err!=BZ_OK) + break; +#endif + } // end Z_BZIP2ED + else + { + ZPOS64_T uTotalOutBefore,uTotalOutAfter; + const Bytef *bufBefore; + ZPOS64_T uOutThis; + int flush=Z_SYNC_FLUSH; + + uTotalOutBefore = pfile_in_zip_read_info->stream.total_out; + bufBefore = pfile_in_zip_read_info->stream.next_out; + + /* + if ((pfile_in_zip_read_info->rest_read_uncompressed == + pfile_in_zip_read_info->stream.avail_out) && + (pfile_in_zip_read_info->rest_read_compressed == 0)) + flush = Z_FINISH; + */ + err=inflate(&pfile_in_zip_read_info->stream,flush); + + if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL)) + err = Z_DATA_ERROR; + + uTotalOutAfter = pfile_in_zip_read_info->stream.total_out; + uOutThis = uTotalOutAfter-uTotalOutBefore; + + pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis; + + pfile_in_zip_read_info->crc32 = + crc32(pfile_in_zip_read_info->crc32,bufBefore, + (uInt)(uOutThis)); + + pfile_in_zip_read_info->rest_read_uncompressed -= + uOutThis; + + iRead += (uInt)(uTotalOutAfter - uTotalOutBefore); + + if (err==Z_STREAM_END) + return (iRead==0) ? UNZ_EOF : iRead; + if (err!=Z_OK) + break; + } + } + + if (err==Z_OK) + return iRead; + return err; +} + + +/* + Give the current position in uncompressed data +*/ +extern z_off_t ZEXPORT unztell (unzFile file) +{ + unz64_s* s; + file_in_zip64_read_info_s* pfile_in_zip_read_info; + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz64_s*)file; + pfile_in_zip_read_info=s->pfile_in_zip_read; + + if (pfile_in_zip_read_info==NULL) + return UNZ_PARAMERROR; + + return (z_off_t)pfile_in_zip_read_info->stream.total_out; +} + +extern ZPOS64_T ZEXPORT unztell64 (unzFile file) +{ + + unz64_s* s; + file_in_zip64_read_info_s* pfile_in_zip_read_info; + if (file==NULL) + return (ZPOS64_T)-1; + s=(unz64_s*)file; + pfile_in_zip_read_info=s->pfile_in_zip_read; + + if (pfile_in_zip_read_info==NULL) + return (ZPOS64_T)-1; + + return pfile_in_zip_read_info->total_out_64; +} + + +/* + return 1 if the end of file was reached, 0 elsewhere +*/ +extern int ZEXPORT unzeof (unzFile file) +{ + unz64_s* s; + file_in_zip64_read_info_s* pfile_in_zip_read_info; + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz64_s*)file; + pfile_in_zip_read_info=s->pfile_in_zip_read; + + if (pfile_in_zip_read_info==NULL) + return UNZ_PARAMERROR; + + if (pfile_in_zip_read_info->rest_read_uncompressed == 0) + return 1; + else + return 0; +} + + + +/* +Read extra field from the current file (opened by unzOpenCurrentFile) +This is the local-header version of the extra field (sometimes, there is +more info in the local-header version than in the central-header) + + if buf==NULL, it return the size of the local extra field that can be read + + if buf!=NULL, len is the size of the buffer, the extra header is copied in + buf. + the return value is the number of bytes copied in buf, or (if <0) + the error code +*/ +extern int ZEXPORT unzGetLocalExtrafield (unzFile file, voidp buf, unsigned len) +{ + unz64_s* s; + file_in_zip64_read_info_s* pfile_in_zip_read_info; + uInt read_now; + ZPOS64_T size_to_read; + + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz64_s*)file; + pfile_in_zip_read_info=s->pfile_in_zip_read; + + if (pfile_in_zip_read_info==NULL) + return UNZ_PARAMERROR; + + size_to_read = (pfile_in_zip_read_info->size_local_extrafield - + pfile_in_zip_read_info->pos_local_extrafield); + + if (buf==NULL) + return (int)size_to_read; + + if (len>size_to_read) + read_now = (uInt)size_to_read; + else + read_now = (uInt)len ; + + if (read_now==0) + return 0; + + if (ZSEEK64(pfile_in_zip_read_info->z_filefunc, + pfile_in_zip_read_info->filestream, + pfile_in_zip_read_info->offset_local_extrafield + + pfile_in_zip_read_info->pos_local_extrafield, + ZLIB_FILEFUNC_SEEK_SET)!=0) + return UNZ_ERRNO; + + if (ZREAD64(pfile_in_zip_read_info->z_filefunc, + pfile_in_zip_read_info->filestream, + buf,read_now)!=read_now) + return UNZ_ERRNO; + + return (int)read_now; +} + +/* + Close the file in zip opened with unzOpenCurrentFile + Return UNZ_CRCERROR if all the file was read but the CRC is not good +*/ +extern int ZEXPORT unzCloseCurrentFile (unzFile file) +{ + int err=UNZ_OK; + + unz64_s* s; + file_in_zip64_read_info_s* pfile_in_zip_read_info; + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz64_s*)file; + pfile_in_zip_read_info=s->pfile_in_zip_read; + + if (pfile_in_zip_read_info==NULL) + return UNZ_PARAMERROR; + + + if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) && + (!pfile_in_zip_read_info->raw)) + { + if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait) + err=UNZ_CRCERROR; + } + + + TRYFREE(pfile_in_zip_read_info->read_buffer); + pfile_in_zip_read_info->read_buffer = NULL; + if (pfile_in_zip_read_info->stream_initialised == Z_DEFLATED) + inflateEnd(&pfile_in_zip_read_info->stream); +#ifdef HAVE_BZIP2 + else if (pfile_in_zip_read_info->stream_initialised == Z_BZIP2ED) + BZ2_bzDecompressEnd(&pfile_in_zip_read_info->bstream); +#endif + + + pfile_in_zip_read_info->stream_initialised = 0; + TRYFREE(pfile_in_zip_read_info); + + s->pfile_in_zip_read=NULL; + + return err; +} + + +/* + Get the global comment string of the ZipFile, in the szComment buffer. + uSizeBuf is the size of the szComment buffer. + return the number of byte copied or an error code <0 +*/ +extern int ZEXPORT unzGetGlobalComment (unzFile file, char * szComment, uLong uSizeBuf) +{ + unz64_s* s; + uLong uReadThis ; + if (file==NULL) + return (int)UNZ_PARAMERROR; + s=(unz64_s*)file; + + uReadThis = uSizeBuf; + if (uReadThis>s->gi.size_comment) + uReadThis = s->gi.size_comment; + + if (ZSEEK64(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0) + return UNZ_ERRNO; + + if (uReadThis>0) + { + *szComment='\0'; + if (ZREAD64(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis) + return UNZ_ERRNO; + } + + if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment)) + *(szComment+s->gi.size_comment)='\0'; + return (int)uReadThis; +} + +/* Additions by RX '2004 */ +extern ZPOS64_T ZEXPORT unzGetOffset64(unzFile file) +{ + unz64_s* s; + + if (file==NULL) + return 0; //UNZ_PARAMERROR; + s=(unz64_s*)file; + if (!s->current_file_ok) + return 0; + if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff) + if (s->num_file==s->gi.number_entry) + return 0; + return s->pos_in_central_dir; +} + +extern uLong ZEXPORT unzGetOffset (unzFile file) +{ + ZPOS64_T offset64; + + if (file==NULL) + return 0; //UNZ_PARAMERROR; + offset64 = unzGetOffset64(file); + return (uLong)offset64; +} + +extern int ZEXPORT unzSetOffset64(unzFile file, ZPOS64_T pos) +{ + unz64_s* s; + int err; + + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz64_s*)file; + + s->pos_in_central_dir = pos; + s->num_file = s->gi.number_entry; /* hack */ + err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info, + &s->cur_file_info_internal, + NULL,0,NULL,0,NULL,0); + s->current_file_ok = (err == UNZ_OK); + return err; +} + +extern int ZEXPORT unzSetOffset (unzFile file, uLong pos) +{ + return unzSetOffset64(file,pos); +} diff --git a/sdk/lib/3rdparty/zlib/contrib/minizip/unzip.h b/sdk/lib/3rdparty/zlib/contrib/minizip/unzip.h new file mode 100644 index 0000000000..2104e39150 --- /dev/null +++ b/sdk/lib/3rdparty/zlib/contrib/minizip/unzip.h @@ -0,0 +1,437 @@ +/* unzip.h -- IO for uncompress .zip files using zlib + Version 1.1, February 14h, 2010 + part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html ) + + Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html ) + + Modifications of Unzip for Zip64 + Copyright (C) 2007-2008 Even Rouault + + Modifications for Zip64 support on both zip and unzip + Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) + + For more info read MiniZip_info.txt + + --------------------------------------------------------------------------------- + + Condition of use and distribution are the same than zlib : + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + --------------------------------------------------------------------------------- + + Changes + + See header of unzip64.c + +*/ + +#ifndef _unz64_H +#define _unz64_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _ZLIB_H +#include "zlib.h" +#endif + +#ifndef _ZLIBIOAPI_H +#include "ioapi.h" +#endif + +#ifdef HAVE_BZIP2 +#include "bzlib.h" +#endif + +#define Z_BZIP2ED 12 + +#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP) +/* like the STRICT of WIN32, we define a pointer that cannot be converted + from (void*) without cast */ +typedef struct TagunzFile__ { int unused; } unzFile__; +typedef unzFile__ *unzFile; +#else +typedef voidp unzFile; +#endif + + +#define UNZ_OK (0) +#define UNZ_END_OF_LIST_OF_FILE (-100) +#define UNZ_ERRNO (Z_ERRNO) +#define UNZ_EOF (0) +#define UNZ_PARAMERROR (-102) +#define UNZ_BADZIPFILE (-103) +#define UNZ_INTERNALERROR (-104) +#define UNZ_CRCERROR (-105) + +/* tm_unz contain date/time info */ +typedef struct tm_unz_s +{ + uInt tm_sec; /* seconds after the minute - [0,59] */ + uInt tm_min; /* minutes after the hour - [0,59] */ + uInt tm_hour; /* hours since midnight - [0,23] */ + uInt tm_mday; /* day of the month - [1,31] */ + uInt tm_mon; /* months since January - [0,11] */ + uInt tm_year; /* years - [1980..2044] */ +} tm_unz; + +/* unz_global_info structure contain global data about the ZIPfile + These data comes from the end of central dir */ +typedef struct unz_global_info64_s +{ + ZPOS64_T number_entry; /* total number of entries in + the central dir on this disk */ + uLong size_comment; /* size of the global comment of the zipfile */ +} unz_global_info64; + +typedef struct unz_global_info_s +{ + uLong number_entry; /* total number of entries in + the central dir on this disk */ + uLong size_comment; /* size of the global comment of the zipfile */ +} unz_global_info; + +/* unz_file_info contain information about a file in the zipfile */ +typedef struct unz_file_info64_s +{ + uLong version; /* version made by 2 bytes */ + uLong version_needed; /* version needed to extract 2 bytes */ + uLong flag; /* general purpose bit flag 2 bytes */ + uLong compression_method; /* compression method 2 bytes */ + uLong dosDate; /* last mod file date in Dos fmt 4 bytes */ + uLong crc; /* crc-32 4 bytes */ + ZPOS64_T compressed_size; /* compressed size 8 bytes */ + ZPOS64_T uncompressed_size; /* uncompressed size 8 bytes */ + uLong size_filename; /* filename length 2 bytes */ + uLong size_file_extra; /* extra field length 2 bytes */ + uLong size_file_comment; /* file comment length 2 bytes */ + + uLong disk_num_start; /* disk number start 2 bytes */ + uLong internal_fa; /* internal file attributes 2 bytes */ + uLong external_fa; /* external file attributes 4 bytes */ + + tm_unz tmu_date; +} unz_file_info64; + +typedef struct unz_file_info_s +{ + uLong version; /* version made by 2 bytes */ + uLong version_needed; /* version needed to extract 2 bytes */ + uLong flag; /* general purpose bit flag 2 bytes */ + uLong compression_method; /* compression method 2 bytes */ + uLong dosDate; /* last mod file date in Dos fmt 4 bytes */ + uLong crc; /* crc-32 4 bytes */ + uLong compressed_size; /* compressed size 4 bytes */ + uLong uncompressed_size; /* uncompressed size 4 bytes */ + uLong size_filename; /* filename length 2 bytes */ + uLong size_file_extra; /* extra field length 2 bytes */ + uLong size_file_comment; /* file comment length 2 bytes */ + + uLong disk_num_start; /* disk number start 2 bytes */ + uLong internal_fa; /* internal file attributes 2 bytes */ + uLong external_fa; /* external file attributes 4 bytes */ + + tm_unz tmu_date; +} unz_file_info; + +extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1, + const char* fileName2, + int iCaseSensitivity)); +/* + Compare two filename (fileName1,fileName2). + If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp) + If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi + or strcasecmp) + If iCaseSenisivity = 0, case sensitivity is defaut of your operating system + (like 1 on Unix, 2 on Windows) +*/ + + +extern unzFile ZEXPORT unzOpen OF((const char *path)); +extern unzFile ZEXPORT unzOpen64 OF((const void *path)); +/* + Open a Zip file. path contain the full pathname (by example, + on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer + "zlib/zlib113.zip". + If the zipfile cannot be opened (file don't exist or in not valid), the + return value is NULL. + Else, the return value is a unzFile Handle, usable with other function + of this unzip package. + the "64" function take a const void* pointer, because the path is just the + value passed to the open64_file_func callback. + Under Windows, if UNICODE is defined, using fill_fopen64_filefunc, the path + is a pointer to a wide unicode string (LPCTSTR is LPCWSTR), so const char* + does not describe the reality +*/ + + +extern unzFile ZEXPORT unzOpen2 OF((const char *path, + zlib_filefunc_def* pzlib_filefunc_def)); +/* + Open a Zip file, like unzOpen, but provide a set of file low level API + for read/write the zip file (see ioapi.h) +*/ + +extern unzFile ZEXPORT unzOpen2_64 OF((const void *path, + zlib_filefunc64_def* pzlib_filefunc_def)); +/* + Open a Zip file, like unz64Open, but provide a set of file low level API + for read/write the zip file (see ioapi.h) +*/ + +extern int ZEXPORT unzClose OF((unzFile file)); +/* + Close a ZipFile opened with unzOpen. + If there is files inside the .Zip opened with unzOpenCurrentFile (see later), + these files MUST be closed with unzCloseCurrentFile before call unzClose. + return UNZ_OK if there is no problem. */ + +extern int ZEXPORT unzGetGlobalInfo OF((unzFile file, + unz_global_info *pglobal_info)); + +extern int ZEXPORT unzGetGlobalInfo64 OF((unzFile file, + unz_global_info64 *pglobal_info)); +/* + Write info about the ZipFile in the *pglobal_info structure. + No preparation of the structure is needed + return UNZ_OK if there is no problem. */ + + +extern int ZEXPORT unzGetGlobalComment OF((unzFile file, + char *szComment, + uLong uSizeBuf)); +/* + Get the global comment string of the ZipFile, in the szComment buffer. + uSizeBuf is the size of the szComment buffer. + return the number of byte copied or an error code <0 +*/ + + +/***************************************************************************/ +/* Unzip package allow you browse the directory of the zipfile */ + +extern int ZEXPORT unzGoToFirstFile OF((unzFile file)); +/* + Set the current file of the zipfile to the first file. + return UNZ_OK if there is no problem +*/ + +extern int ZEXPORT unzGoToNextFile OF((unzFile file)); +/* + Set the current file of the zipfile to the next file. + return UNZ_OK if there is no problem + return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest. +*/ + +extern int ZEXPORT unzLocateFile OF((unzFile file, + const char *szFileName, + int iCaseSensitivity)); +/* + Try locate the file szFileName in the zipfile. + For the iCaseSensitivity signification, see unzStringFileNameCompare + + return value : + UNZ_OK if the file is found. It becomes the current file. + UNZ_END_OF_LIST_OF_FILE if the file is not found +*/ + + +/* ****************************************** */ +/* Ryan supplied functions */ +/* unz_file_info contain information about a file in the zipfile */ +typedef struct unz_file_pos_s +{ + uLong pos_in_zip_directory; /* offset in zip file directory */ + uLong num_of_file; /* # of file */ +} unz_file_pos; + +extern int ZEXPORT unzGetFilePos( + unzFile file, + unz_file_pos* file_pos); + +extern int ZEXPORT unzGoToFilePos( + unzFile file, + unz_file_pos* file_pos); + +typedef struct unz64_file_pos_s +{ + ZPOS64_T pos_in_zip_directory; /* offset in zip file directory */ + ZPOS64_T num_of_file; /* # of file */ +} unz64_file_pos; + +extern int ZEXPORT unzGetFilePos64( + unzFile file, + unz64_file_pos* file_pos); + +extern int ZEXPORT unzGoToFilePos64( + unzFile file, + const unz64_file_pos* file_pos); + +/* ****************************************** */ + +extern int ZEXPORT unzGetCurrentFileInfo64 OF((unzFile file, + unz_file_info64 *pfile_info, + char *szFileName, + uLong fileNameBufferSize, + void *extraField, + uLong extraFieldBufferSize, + char *szComment, + uLong commentBufferSize)); + +extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file, + unz_file_info *pfile_info, + char *szFileName, + uLong fileNameBufferSize, + void *extraField, + uLong extraFieldBufferSize, + char *szComment, + uLong commentBufferSize)); +/* + Get Info about the current file + if pfile_info!=NULL, the *pfile_info structure will contain somes info about + the current file + if szFileName!=NULL, the filemane string will be copied in szFileName + (fileNameBufferSize is the size of the buffer) + if extraField!=NULL, the extra field information will be copied in extraField + (extraFieldBufferSize is the size of the buffer). + This is the Central-header version of the extra field + if szComment!=NULL, the comment string of the file will be copied in szComment + (commentBufferSize is the size of the buffer) +*/ + + +/** Addition for GDAL : START */ + +extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64 OF((unzFile file)); + +/** Addition for GDAL : END */ + + +/***************************************************************************/ +/* for reading the content of the current zipfile, you can open it, read data + from it, and close it (you can close it before reading all the file) + */ + +extern int ZEXPORT unzOpenCurrentFile OF((unzFile file)); +/* + Open for reading data the current file in the zipfile. + If there is no error, the return value is UNZ_OK. +*/ + +extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file, + const char* password)); +/* + Open for reading data the current file in the zipfile. + password is a crypting password + If there is no error, the return value is UNZ_OK. +*/ + +extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file, + int* method, + int* level, + int raw)); +/* + Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) + if raw==1 + *method will receive method of compression, *level will receive level of + compression + note : you can set level parameter as NULL (if you did not want known level, + but you CANNOT set method parameter as NULL +*/ + +extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file, + int* method, + int* level, + int raw, + const char* password)); +/* + Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) + if raw==1 + *method will receive method of compression, *level will receive level of + compression + note : you can set level parameter as NULL (if you did not want known level, + but you CANNOT set method parameter as NULL +*/ + + +extern int ZEXPORT unzCloseCurrentFile OF((unzFile file)); +/* + Close the file in zip opened with unzOpenCurrentFile + Return UNZ_CRCERROR if all the file was read but the CRC is not good +*/ + +extern int ZEXPORT unzReadCurrentFile OF((unzFile file, + voidp buf, + unsigned len)); +/* + Read bytes from the current file (opened by unzOpenCurrentFile) + buf contain buffer where data must be copied + len the size of buf. + + return the number of byte copied if somes bytes are copied + return 0 if the end of file was reached + return <0 with error code if there is an error + (UNZ_ERRNO for IO error, or zLib error for uncompress error) +*/ + +extern z_off_t ZEXPORT unztell OF((unzFile file)); + +extern ZPOS64_T ZEXPORT unztell64 OF((unzFile file)); +/* + Give the current position in uncompressed data +*/ + +extern int ZEXPORT unzeof OF((unzFile file)); +/* + return 1 if the end of file was reached, 0 elsewhere +*/ + +extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file, + voidp buf, + unsigned len)); +/* + Read extra field from the current file (opened by unzOpenCurrentFile) + This is the local-header version of the extra field (sometimes, there is + more info in the local-header version than in the central-header) + + if buf==NULL, it return the size of the local extra field + + if buf!=NULL, len is the size of the buffer, the extra header is copied in + buf. + the return value is the number of bytes copied in buf, or (if <0) + the error code +*/ + +/***************************************************************************/ + +/* Get the current file offset */ +extern ZPOS64_T ZEXPORT unzGetOffset64 (unzFile file); +extern uLong ZEXPORT unzGetOffset (unzFile file); + +/* Set the current file offset */ +extern int ZEXPORT unzSetOffset64 (unzFile file, ZPOS64_T pos); +extern int ZEXPORT unzSetOffset (unzFile file, uLong pos); + + + +#ifdef __cplusplus +} +#endif + +#endif /* _unz64_H */ diff --git a/sdk/lib/3rdparty/zlib/contrib/minizip/zip.c b/sdk/lib/3rdparty/zlib/contrib/minizip/zip.c new file mode 100644 index 0000000000..d5ab730933 --- /dev/null +++ b/sdk/lib/3rdparty/zlib/contrib/minizip/zip.c @@ -0,0 +1,2012 @@ +/* zip.c -- IO on .zip files using zlib + Version 1.1, February 14h, 2010 + part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html ) + + Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html ) + + Modifications for Zip64 support + Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) + + For more info read MiniZip_info.txt + + Changes + Oct-2009 - Mathias Svensson - Remove old C style function prototypes + Oct-2009 - Mathias Svensson - Added Zip64 Support when creating new file archives + Oct-2009 - Mathias Svensson - Did some code cleanup and refactoring to get better overview of some functions. + Oct-2009 - Mathias Svensson - Added zipRemoveExtraInfoBlock to strip extra field data from its ZIP64 data + It is used when recreting zip archive with RAW when deleting items from a zip. + ZIP64 data is automatically added to items that needs it, and existing ZIP64 data need to be removed. + Oct-2009 - Mathias Svensson - Added support for BZIP2 as compression mode (bzip2 lib is required) + Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer + +*/ + + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include "zlib.h" +#include "zip.h" + +#ifdef STDC +# include <stddef.h> +# include <string.h> +# include <stdlib.h> +#endif +#ifdef NO_ERRNO_H + extern int errno; +#else +# include <errno.h> +#endif + + +#ifndef local +# define local static +#endif +/* compile with -Dlocal if your debugger can't find static symbols */ + +#ifndef VERSIONMADEBY +# define VERSIONMADEBY (0x0) /* platform depedent */ +#endif + +#ifndef Z_BUFSIZE +#define Z_BUFSIZE (64*1024) //(16384) +#endif + +#ifndef Z_MAXFILENAMEINZIP +#define Z_MAXFILENAMEINZIP (256) +#endif + +#ifndef ALLOC +# define ALLOC(size) (malloc(size)) +#endif +#ifndef TRYFREE +# define TRYFREE(p) {if (p) free(p);} +#endif + +/* +#define SIZECENTRALDIRITEM (0x2e) +#define SIZEZIPLOCALHEADER (0x1e) +*/ + +/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ + + +// NOT sure that this work on ALL platform +#define MAKEULONG64(a, b) ((ZPOS64_T)(((unsigned long)(a)) | ((ZPOS64_T)((unsigned long)(b))) << 32)) + +#ifndef SEEK_CUR +#define SEEK_CUR 1 +#endif + +#ifndef SEEK_END +#define SEEK_END 2 +#endif + +#ifndef SEEK_SET +#define SEEK_SET 0 +#endif + +#ifndef DEF_MEM_LEVEL +#if MAX_MEM_LEVEL >= 8 +# define DEF_MEM_LEVEL 8 +#else +# define DEF_MEM_LEVEL MAX_MEM_LEVEL +#endif +#endif +const char zip_copyright[] =" zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll"; + + +#define SIZEDATA_INDATABLOCK (4096-(4*4)) + +#define LOCALHEADERMAGIC (0x04034b50) +#define CENTRALHEADERMAGIC (0x02014b50) +#define ENDHEADERMAGIC (0x06054b50) +#define ZIP64ENDHEADERMAGIC (0x6064b50) +#define ZIP64ENDLOCHEADERMAGIC (0x7064b50) + +#define FLAG_LOCALHEADER_OFFSET (0x06) +#define CRC_LOCALHEADER_OFFSET (0x0e) + +#define SIZECENTRALHEADER (0x2e) /* 46 */ + +typedef struct linkedlist_datablock_internal_s +{ + struct linkedlist_datablock_internal_s* next_datablock; + uLong avail_in_this_block; + uLong filled_in_this_block; + uLong unused; /* for future use and alignment */ + unsigned char data[SIZEDATA_INDATABLOCK]; +} linkedlist_datablock_internal; + +typedef struct linkedlist_data_s +{ + linkedlist_datablock_internal* first_block; + linkedlist_datablock_internal* last_block; +} linkedlist_data; + + +typedef struct +{ + z_stream stream; /* zLib stream structure for inflate */ +#ifdef HAVE_BZIP2 + bz_stream bstream; /* bzLib stream structure for bziped */ +#endif + + int stream_initialised; /* 1 is stream is initialised */ + uInt pos_in_buffered_data; /* last written byte in buffered_data */ + + ZPOS64_T pos_local_header; /* offset of the local header of the file + currenty writing */ + char* central_header; /* central header data for the current file */ + uLong size_centralExtra; + uLong size_centralheader; /* size of the central header for cur file */ + uLong size_centralExtraFree; /* Extra bytes allocated to the centralheader but that are not used */ + uLong flag; /* flag of the file currently writing */ + + int method; /* compression method of file currenty wr.*/ + int raw; /* 1 for directly writing raw data */ + Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/ + uLong dosDate; + uLong crc32; + int encrypt; + int zip64; /* Add ZIP64 extened information in the extra field */ + ZPOS64_T pos_zip64extrainfo; + ZPOS64_T totalCompressedData; + ZPOS64_T totalUncompressedData; +#ifndef NOCRYPT + unsigned long keys[3]; /* keys defining the pseudo-random sequence */ + const z_crc_t* pcrc_32_tab; + int crypt_header_size; +#endif +} curfile64_info; + +typedef struct +{ + zlib_filefunc64_32_def z_filefunc; + voidpf filestream; /* io structore of the zipfile */ + linkedlist_data central_dir;/* datablock with central dir in construction*/ + int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/ + curfile64_info ci; /* info on the file curretly writing */ + + ZPOS64_T begin_pos; /* position of the beginning of the zipfile */ + ZPOS64_T add_position_when_writing_offset; + ZPOS64_T number_entry; + +#ifndef NO_ADDFILEINEXISTINGZIP + char *globalcomment; +#endif + +} zip64_internal; + + +#ifndef NOCRYPT +#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED +#include "crypt.h" +#endif + +local linkedlist_datablock_internal* allocate_new_datablock() +{ + linkedlist_datablock_internal* ldi; + ldi = (linkedlist_datablock_internal*) + ALLOC(sizeof(linkedlist_datablock_internal)); + if (ldi!=NULL) + { + ldi->next_datablock = NULL ; + ldi->filled_in_this_block = 0 ; + ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ; + } + return ldi; +} + +local void free_datablock(linkedlist_datablock_internal* ldi) +{ + while (ldi!=NULL) + { + linkedlist_datablock_internal* ldinext = ldi->next_datablock; + TRYFREE(ldi); + ldi = ldinext; + } +} + +local void init_linkedlist(linkedlist_data* ll) +{ + ll->first_block = ll->last_block = NULL; +} + +local void free_linkedlist(linkedlist_data* ll) +{ + free_datablock(ll->first_block); + ll->first_block = ll->last_block = NULL; +} + + +local int add_data_in_datablock(linkedlist_data* ll, const void* buf, uLong len) +{ + linkedlist_datablock_internal* ldi; + const unsigned char* from_copy; + + if (ll==NULL) + return ZIP_INTERNALERROR; + + if (ll->last_block == NULL) + { + ll->first_block = ll->last_block = allocate_new_datablock(); + if (ll->first_block == NULL) + return ZIP_INTERNALERROR; + } + + ldi = ll->last_block; + from_copy = (unsigned char*)buf; + + while (len>0) + { + uInt copy_this; + uInt i; + unsigned char* to_copy; + + if (ldi->avail_in_this_block==0) + { + ldi->next_datablock = allocate_new_datablock(); + if (ldi->next_datablock == NULL) + return ZIP_INTERNALERROR; + ldi = ldi->next_datablock ; + ll->last_block = ldi; + } + + if (ldi->avail_in_this_block < len) + copy_this = (uInt)ldi->avail_in_this_block; + else + copy_this = (uInt)len; + + to_copy = &(ldi->data[ldi->filled_in_this_block]); + + for (i=0;i<copy_this;i++) + *(to_copy+i)=*(from_copy+i); + + ldi->filled_in_this_block += copy_this; + ldi->avail_in_this_block -= copy_this; + from_copy += copy_this ; + len -= copy_this; + } + return ZIP_OK; +} + + + +/****************************************************************************/ + +#ifndef NO_ADDFILEINEXISTINGZIP +/* =========================================================================== + Inputs a long in LSB order to the given file + nbByte == 1, 2 ,4 or 8 (byte, short or long, ZPOS64_T) +*/ + +local int zip64local_putValue OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte)); +local int zip64local_putValue (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte) +{ + unsigned char buf[8]; + int n; + for (n = 0; n < nbByte; n++) + { + buf[n] = (unsigned char)(x & 0xff); + x >>= 8; + } + if (x != 0) + { /* data overflow - hack for ZIP64 (X Roche) */ + for (n = 0; n < nbByte; n++) + { + buf[n] = 0xff; + } + } + + if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte) + return ZIP_ERRNO; + else + return ZIP_OK; +} + +local void zip64local_putValue_inmemory OF((void* dest, ZPOS64_T x, int nbByte)); +local void zip64local_putValue_inmemory (void* dest, ZPOS64_T x, int nbByte) +{ + unsigned char* buf=(unsigned char*)dest; + int n; + for (n = 0; n < nbByte; n++) { + buf[n] = (unsigned char)(x & 0xff); + x >>= 8; + } + + if (x != 0) + { /* data overflow - hack for ZIP64 */ + for (n = 0; n < nbByte; n++) + { + buf[n] = 0xff; + } + } +} + +/****************************************************************************/ + + +local uLong zip64local_TmzDateToDosDate(const tm_zip* ptm) +{ + uLong year = (uLong)ptm->tm_year; + if (year>=1980) + year-=1980; + else if (year>=80) + year-=80; + return + (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) | + ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour)); +} + + +/****************************************************************************/ + +local int zip64local_getByte OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi)); + +local int zip64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def,voidpf filestream,int* pi) +{ + unsigned char c; + int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1); + if (err==1) + { + *pi = (int)c; + return ZIP_OK; + } + else + { + if (ZERROR64(*pzlib_filefunc_def,filestream)) + return ZIP_ERRNO; + else + return ZIP_EOF; + } +} + + +/* =========================================================================== + Reads a long in LSB order from the given gz_stream. Sets +*/ +local int zip64local_getShort OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX)); + +local int zip64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX) +{ + uLong x ; + int i = 0; + int err; + + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x = (uLong)i; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((uLong)i)<<8; + + if (err==ZIP_OK) + *pX = x; + else + *pX = 0; + return err; +} + +local int zip64local_getLong OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX)); + +local int zip64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX) +{ + uLong x ; + int i = 0; + int err; + + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x = (uLong)i; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((uLong)i)<<8; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((uLong)i)<<16; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((uLong)i)<<24; + + if (err==ZIP_OK) + *pX = x; + else + *pX = 0; + return err; +} + +local int zip64local_getLong64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX)); + + +local int zip64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX) +{ + ZPOS64_T x; + int i = 0; + int err; + + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x = (ZPOS64_T)i; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((ZPOS64_T)i)<<8; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((ZPOS64_T)i)<<16; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((ZPOS64_T)i)<<24; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((ZPOS64_T)i)<<32; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((ZPOS64_T)i)<<40; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((ZPOS64_T)i)<<48; + + if (err==ZIP_OK) + err = zip64local_getByte(pzlib_filefunc_def,filestream,&i); + x += ((ZPOS64_T)i)<<56; + + if (err==ZIP_OK) + *pX = x; + else + *pX = 0; + + return err; +} + +#ifndef BUFREADCOMMENT +#define BUFREADCOMMENT (0x400) +#endif +/* + Locate the Central directory of a zipfile (at the end, just before + the global comment) +*/ +local ZPOS64_T zip64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)); + +local ZPOS64_T zip64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream) +{ + unsigned char* buf; + ZPOS64_T uSizeFile; + ZPOS64_T uBackRead; + ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */ + ZPOS64_T uPosFound=0; + + if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) + return 0; + + + uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream); + + if (uMaxBack>uSizeFile) + uMaxBack = uSizeFile; + + buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); + if (buf==NULL) + return 0; + + uBackRead = 4; + while (uBackRead<uMaxBack) + { + uLong uReadSize; + ZPOS64_T uReadPos ; + int i; + if (uBackRead+BUFREADCOMMENT>uMaxBack) + uBackRead = uMaxBack; + else + uBackRead+=BUFREADCOMMENT; + uReadPos = uSizeFile-uBackRead ; + + uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? + (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos); + if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) + break; + + if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) + break; + + for (i=(int)uReadSize-3; (i--)>0;) + if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && + ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) + { + uPosFound = uReadPos+i; + break; + } + + if (uPosFound!=0) + break; + } + TRYFREE(buf); + return uPosFound; +} + +/* +Locate the End of Zip64 Central directory locator and from there find the CD of a zipfile (at the end, just before +the global comment) +*/ +local ZPOS64_T zip64local_SearchCentralDir64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)); + +local ZPOS64_T zip64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream) +{ + unsigned char* buf; + ZPOS64_T uSizeFile; + ZPOS64_T uBackRead; + ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */ + ZPOS64_T uPosFound=0; + uLong uL; + ZPOS64_T relativeOffset; + + if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) + return 0; + + uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream); + + if (uMaxBack>uSizeFile) + uMaxBack = uSizeFile; + + buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); + if (buf==NULL) + return 0; + + uBackRead = 4; + while (uBackRead<uMaxBack) + { + uLong uReadSize; + ZPOS64_T uReadPos; + int i; + if (uBackRead+BUFREADCOMMENT>uMaxBack) + uBackRead = uMaxBack; + else + uBackRead+=BUFREADCOMMENT; + uReadPos = uSizeFile-uBackRead ; + + uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? + (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos); + if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) + break; + + if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) + break; + + for (i=(int)uReadSize-3; (i--)>0;) + { + // Signature "0x07064b50" Zip64 end of central directory locater + if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07)) + { + uPosFound = uReadPos+i; + break; + } + } + + if (uPosFound!=0) + break; + } + + TRYFREE(buf); + if (uPosFound == 0) + return 0; + + /* Zip64 end of central directory locator */ + if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0) + return 0; + + /* the signature, already checked */ + if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) + return 0; + + /* number of the disk with the start of the zip64 end of central directory */ + if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) + return 0; + if (uL != 0) + return 0; + + /* relative offset of the zip64 end of central directory record */ + if (zip64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=ZIP_OK) + return 0; + + /* total number of disks */ + if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) + return 0; + if (uL != 1) + return 0; + + /* Goto Zip64 end of central directory record */ + if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0) + return 0; + + /* the signature */ + if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK) + return 0; + + if (uL != 0x06064b50) // signature of 'Zip64 end of central directory' + return 0; + + return relativeOffset; +} + +int LoadCentralDirectoryRecord(zip64_internal* pziinit) +{ + int err=ZIP_OK; + ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ + + ZPOS64_T size_central_dir; /* size of the central directory */ + ZPOS64_T offset_central_dir; /* offset of start of central directory */ + ZPOS64_T central_pos; + uLong uL; + + uLong number_disk; /* number of the current dist, used for + spaning ZIP, unsupported, always 0*/ + uLong number_disk_with_CD; /* number the the disk with central dir, used + for spaning ZIP, unsupported, always 0*/ + ZPOS64_T number_entry; + ZPOS64_T number_entry_CD; /* total number of entries in + the central dir + (same than number_entry on nospan) */ + uLong VersionMadeBy; + uLong VersionNeeded; + uLong size_comment; + + int hasZIP64Record = 0; + + // check first if we find a ZIP64 record + central_pos = zip64local_SearchCentralDir64(&pziinit->z_filefunc,pziinit->filestream); + if(central_pos > 0) + { + hasZIP64Record = 1; + } + else if(central_pos == 0) + { + central_pos = zip64local_SearchCentralDir(&pziinit->z_filefunc,pziinit->filestream); + } + +/* disable to allow appending to empty ZIP archive + if (central_pos==0) + err=ZIP_ERRNO; +*/ + + if(hasZIP64Record) + { + ZPOS64_T sizeEndOfCentralDirectory; + if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0) + err=ZIP_ERRNO; + + /* the signature, already checked */ + if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK) + err=ZIP_ERRNO; + + /* size of zip64 end of central directory record */ + if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &sizeEndOfCentralDirectory)!=ZIP_OK) + err=ZIP_ERRNO; + + /* version made by */ + if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionMadeBy)!=ZIP_OK) + err=ZIP_ERRNO; + + /* version needed to extract */ + if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionNeeded)!=ZIP_OK) + err=ZIP_ERRNO; + + /* number of this disk */ + if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK) + err=ZIP_ERRNO; + + /* number of the disk with the start of the central directory */ + if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK) + err=ZIP_ERRNO; + + /* total number of entries in the central directory on this disk */ + if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &number_entry)!=ZIP_OK) + err=ZIP_ERRNO; + + /* total number of entries in the central directory */ + if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&number_entry_CD)!=ZIP_OK) + err=ZIP_ERRNO; + + if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0)) + err=ZIP_BADZIPFILE; + + /* size of the central directory */ + if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&size_central_dir)!=ZIP_OK) + err=ZIP_ERRNO; + + /* offset of start of central directory with respect to the + starting disk number */ + if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&offset_central_dir)!=ZIP_OK) + err=ZIP_ERRNO; + + // TODO.. + // read the comment from the standard central header. + size_comment = 0; + } + else + { + // Read End of central Directory info + if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) + err=ZIP_ERRNO; + + /* the signature, already checked */ + if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK) + err=ZIP_ERRNO; + + /* number of this disk */ + if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK) + err=ZIP_ERRNO; + + /* number of the disk with the start of the central directory */ + if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK) + err=ZIP_ERRNO; + + /* total number of entries in the central dir on this disk */ + number_entry = 0; + if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) + err=ZIP_ERRNO; + else + number_entry = uL; + + /* total number of entries in the central dir */ + number_entry_CD = 0; + if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) + err=ZIP_ERRNO; + else + number_entry_CD = uL; + + if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0)) + err=ZIP_BADZIPFILE; + + /* size of the central directory */ + size_central_dir = 0; + if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) + err=ZIP_ERRNO; + else + size_central_dir = uL; + + /* offset of start of central directory with respect to the starting disk number */ + offset_central_dir = 0; + if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK) + err=ZIP_ERRNO; + else + offset_central_dir = uL; + + + /* zipfile global comment length */ + if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &size_comment)!=ZIP_OK) + err=ZIP_ERRNO; + } + + if ((central_pos<offset_central_dir+size_central_dir) && + (err==ZIP_OK)) + err=ZIP_BADZIPFILE; + + if (err!=ZIP_OK) + { + ZCLOSE64(pziinit->z_filefunc, pziinit->filestream); + return ZIP_ERRNO; + } + + if (size_comment>0) + { + pziinit->globalcomment = (char*)ALLOC(size_comment+1); + if (pziinit->globalcomment) + { + size_comment = ZREAD64(pziinit->z_filefunc, pziinit->filestream, pziinit->globalcomment,size_comment); + pziinit->globalcomment[size_comment]=0; + } + } + + byte_before_the_zipfile = central_pos - (offset_central_dir+size_central_dir); + pziinit->add_position_when_writing_offset = byte_before_the_zipfile; + + { + ZPOS64_T size_central_dir_to_read = size_central_dir; + size_t buf_size = SIZEDATA_INDATABLOCK; + void* buf_read = (void*)ALLOC(buf_size); + if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir + byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0) + err=ZIP_ERRNO; + + while ((size_central_dir_to_read>0) && (err==ZIP_OK)) + { + ZPOS64_T read_this = SIZEDATA_INDATABLOCK; + if (read_this > size_central_dir_to_read) + read_this = size_central_dir_to_read; + + if (ZREAD64(pziinit->z_filefunc, pziinit->filestream,buf_read,(uLong)read_this) != read_this) + err=ZIP_ERRNO; + + if (err==ZIP_OK) + err = add_data_in_datablock(&pziinit->central_dir,buf_read, (uLong)read_this); + + size_central_dir_to_read-=read_this; + } + TRYFREE(buf_read); + } + pziinit->begin_pos = byte_before_the_zipfile; + pziinit->number_entry = number_entry_CD; + + if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET) != 0) + err=ZIP_ERRNO; + + return err; +} + + +#endif /* !NO_ADDFILEINEXISTINGZIP*/ + + +/************************************************************/ +extern zipFile ZEXPORT zipOpen3 (const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_32_def* pzlib_filefunc64_32_def) +{ + zip64_internal ziinit; + zip64_internal* zi; + int err=ZIP_OK; + + ziinit.z_filefunc.zseek32_file = NULL; + ziinit.z_filefunc.ztell32_file = NULL; +#ifndef __REACTOS__ + if (pzlib_filefunc64_32_def==NULL) + fill_fopen64_filefunc(&ziinit.z_filefunc.zfile_func64); + else +#endif + ziinit.z_filefunc = *pzlib_filefunc64_32_def; + + + ziinit.filestream = ZOPEN64(ziinit.z_filefunc, + pathname, + (append == APPEND_STATUS_CREATE) ? + (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) : + (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING)); + + if (ziinit.filestream == NULL) + return NULL; + + if (append == APPEND_STATUS_CREATEAFTER) + ZSEEK64(ziinit.z_filefunc,ziinit.filestream,0,SEEK_END); + + ziinit.begin_pos = ZTELL64(ziinit.z_filefunc,ziinit.filestream); + ziinit.in_opened_file_inzip = 0; + ziinit.ci.stream_initialised = 0; + ziinit.number_entry = 0; + ziinit.add_position_when_writing_offset = 0; + init_linkedlist(&(ziinit.central_dir)); + + + + zi = (zip64_internal*)ALLOC(sizeof(zip64_internal)); + if (zi==NULL) + { + ZCLOSE64(ziinit.z_filefunc,ziinit.filestream); + return NULL; + } + + /* now we add file in a zipfile */ +# ifndef NO_ADDFILEINEXISTINGZIP + ziinit.globalcomment = NULL; + if (append == APPEND_STATUS_ADDINZIP) + { + // Read and Cache Central Directory Records + err = LoadCentralDirectoryRecord(&ziinit); + } + + if (globalcomment) + { + *globalcomment = ziinit.globalcomment; + } +# endif /* !NO_ADDFILEINEXISTINGZIP*/ + + if (err != ZIP_OK) + { +# ifndef NO_ADDFILEINEXISTINGZIP + TRYFREE(ziinit.globalcomment); +# endif /* !NO_ADDFILEINEXISTINGZIP*/ + TRYFREE(zi); + return NULL; + } + else + { + *zi = ziinit; + return (zipFile)zi; + } +} + +#ifndef __REACTOS__ +extern zipFile ZEXPORT zipOpen2 (const char *pathname, int append, zipcharpc* globalcomment, zlib_filefunc_def* pzlib_filefunc32_def) +{ + if (pzlib_filefunc32_def != NULL) + { + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def); + return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill); + } + else + return zipOpen3(pathname, append, globalcomment, NULL); +} +#endif + +extern zipFile ZEXPORT zipOpen2_64 (const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_def* pzlib_filefunc_def) +{ + if (pzlib_filefunc_def != NULL) + { + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def; + zlib_filefunc64_32_def_fill.ztell32_file = NULL; + zlib_filefunc64_32_def_fill.zseek32_file = NULL; + return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill); + } + else + return zipOpen3(pathname, append, globalcomment, NULL); +} + + + +extern zipFile ZEXPORT zipOpen (const char* pathname, int append) +{ + return zipOpen3((const void*)pathname,append,NULL,NULL); +} + +extern zipFile ZEXPORT zipOpen64 (const void* pathname, int append) +{ + return zipOpen3(pathname,append,NULL,NULL); +} + +int Write_LocalFileHeader(zip64_internal* zi, const char* filename, uInt size_extrafield_local, const void* extrafield_local) +{ + /* write the local header */ + int err; + uInt size_filename = (uInt)strlen(filename); + uInt size_extrafield = size_extrafield_local; + + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC, 4); + + if (err==ZIP_OK) + { + if(zi->ci.zip64) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);/* version needed to extract */ + else + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */ + } + + if (err==ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2); + + if (err==ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2); + + if (err==ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4); + + // CRC / Compressed size / Uncompressed size will be filled in later and rewritten later + if (err==ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */ + if (err==ZIP_OK) + { + if(zi->ci.zip64) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* compressed size, unknown */ + else + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */ + } + if (err==ZIP_OK) + { + if(zi->ci.zip64) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* uncompressed size, unknown */ + else + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */ + } + + if (err==ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2); + + if(zi->ci.zip64) + { + size_extrafield += 20; + } + + if (err==ZIP_OK) + err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield,2); + + if ((err==ZIP_OK) && (size_filename > 0)) + { + if (ZWRITE64(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename) + err = ZIP_ERRNO; + } + + if ((err==ZIP_OK) && (size_extrafield_local > 0)) + { + if (ZWRITE64(zi->z_filefunc, zi->filestream, extrafield_local, size_extrafield_local) != size_extrafield_local) + err = ZIP_ERRNO; + } + + + if ((err==ZIP_OK) && (zi->ci.zip64)) + { + // write the Zip64 extended info + short HeaderID = 1; + short DataSize = 16; + ZPOS64_T CompressedSize = 0; + ZPOS64_T UncompressedSize = 0; + + // Remember position of Zip64 extended info for the local file header. (needed when we update size after done with file) + zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc,zi->filestream); + + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)HeaderID,2); + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)DataSize,2); + + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)UncompressedSize,8); + err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)CompressedSize,8); + } + + return err; +} + +/* + NOTE. + When writing RAW the ZIP64 extended information in extrafield_local and extrafield_global needs to be stripped + before calling this function it can be done with zipRemoveExtraInfoBlock + + It is not done here because then we need to realloc a new buffer since parameters are 'const' and I want to minimize + unnecessary allocations. + */ +extern int ZEXPORT zipOpenNewFileInZip4_64 (zipFile file, const char* filename, const zip_fileinfo* zipfi, + const void* extrafield_local, uInt size_extrafield_local, + const void* extrafield_global, uInt size_extrafield_global, + const char* comment, int method, int level, int raw, + int windowBits,int memLevel, int strategy, + const char* password, uLong crcForCrypting, + uLong versionMadeBy, uLong flagBase, int zip64) +{ + zip64_internal* zi; + uInt size_filename; + uInt size_comment; + uInt i; + int err = ZIP_OK; + +# ifdef NOCRYPT + (crcForCrypting); + if (password != NULL) + return ZIP_PARAMERROR; +# endif + + if (file == NULL) + return ZIP_PARAMERROR; + +#ifdef HAVE_BZIP2 + if ((method!=0) && (method!=Z_DEFLATED) && (method!=Z_BZIP2ED)) + return ZIP_PARAMERROR; +#else + if ((method!=0) && (method!=Z_DEFLATED)) + return ZIP_PARAMERROR; +#endif + + zi = (zip64_internal*)file; + + if (zi->in_opened_file_inzip == 1) + { + err = zipCloseFileInZip (file); + if (err != ZIP_OK) + return err; + } + + if (filename==NULL) + filename="-"; + + if (comment==NULL) + size_comment = 0; + else + size_comment = (uInt)strlen(comment); + + size_filename = (uInt)strlen(filename); + + if (zipfi == NULL) + zi->ci.dosDate = 0; + else + { + if (zipfi->dosDate != 0) + zi->ci.dosDate = zipfi->dosDate; + else + zi->ci.dosDate = zip64local_TmzDateToDosDate(&zipfi->tmz_date); + } + + zi->ci.flag = flagBase; + if ((level==8) || (level==9)) + zi->ci.flag |= 2; + if (level==2) + zi->ci.flag |= 4; + if (level==1) + zi->ci.flag |= 6; + if (password != NULL) + zi->ci.flag |= 1; + + zi->ci.crc32 = 0; + zi->ci.method = method; + zi->ci.encrypt = 0; + zi->ci.stream_initialised = 0; + zi->ci.pos_in_buffered_data = 0; + zi->ci.raw = raw; + zi->ci.pos_local_header = ZTELL64(zi->z_filefunc,zi->filestream); + + zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + size_extrafield_global + size_comment; + zi->ci.size_centralExtraFree = 32; // Extra space we have reserved in case we need to add ZIP64 extra info data + + zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader + zi->ci.size_centralExtraFree); + + zi->ci.size_centralExtra = size_extrafield_global; + zip64local_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4); + /* version info */ + zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)versionMadeBy,2); + zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2); + zip64local_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2); + zip64local_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2); + zip64local_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4); + zip64local_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/ + zip64local_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/ + zip64local_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/ + zip64local_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2); + zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2); + zip64local_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2); + zip64local_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/ + + if (zipfi==NULL) + zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2); + else + zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2); + + if (zipfi==NULL) + zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4); + else + zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4); + + if(zi->ci.pos_local_header >= 0xffffffff) + zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)0xffffffff,4); + else + zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header - zi->add_position_when_writing_offset,4); + + for (i=0;i<size_filename;i++) + *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i); + + for (i=0;i<size_extrafield_global;i++) ... 1203 lines suppressed ...

1 0

03/06: [SHELL32_APITEST] Show that our current SHCreateFileExtractIconW is incorrect. CORE-14082
by Mark Jansen 07 Apr '18

07 Apr '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=7fe78f2779bf47a9e2d14… commit 7fe78f2779bf47a9e2d1495f96b56fce8fb8060e Author: Mark Jansen <mark.jansen(a)reactos.org> AuthorDate: Tue Mar 27 19:58:43 2018 +0200 Commit: Mark Jansen <mark.jansen(a)reactos.org> CommitDate: Sat Apr 7 15:29:59 2018 +0200 [SHELL32_APITEST] Show that our current SHCreateFileExtractIconW is incorrect. CORE-14082 --- .../apitests/shell32/SHCreateFileExtractIconW.cpp | 172 ++++++++++++++------- 1 file changed, 113 insertions(+), 59 deletions(-) diff --git a/modules/rostests/apitests/shell32/SHCreateFileExtractIconW.cpp b/modules/rostests/apitests/shell32/SHCreateFileExtractIconW.cpp index b48054ee86..144ce8128e 100644 --- a/modules/rostests/apitests/shell32/SHCreateFileExtractIconW.cpp +++ b/modules/rostests/apitests/shell32/SHCreateFileExtractIconW.cpp @@ -2,7 +2,7 @@ * PROJECT: ReactOS API tests * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) * PURPOSE: Test for SHCreateFileExtractIconW - * COPYRIGHT: Copyright 2017 Mark Jansen (mark.jansen(a)reactos.org) + * COPYRIGHT: Copyright 2017,2018 Mark Jansen (mark.jansen(a)reactos.org) */ #include "shelltest.h" @@ -35,6 +35,22 @@ static TestData IconTests[] = { NULL, FILE_ATTRIBUTE_DIRECTORY }, }; +struct TestIID +{ + const GUID* IID; + HRESULT ExpectedCreate; + HRESULT ExpectedQueryInterface; +}; + +static TestIID InterfaceTests[] = +{ + { &IID_IDefaultExtractIconInit, E_NOINTERFACE, E_NOINTERFACE }, + { &IID_IExtractIconW, S_OK, S_OK }, + { &IID_IExtractIconA, S_OK, S_OK }, + { &IID_IPersist, E_NOINTERFACE, E_NOINTERFACE }, + { &IID_IPersistFile, E_NOINTERFACE, E_NOINTERFACE }, +}; + static void ExtractOneBitmap(HBITMAP hbm, CComHeapPtr<BYTE>& data, DWORD& size) { @@ -81,6 +97,9 @@ START_TEST(SHCreateFileExtractIconW) HICON myIcon; pSHCreateFileExtractIconW = (HRESULT (__stdcall *)(LPCWSTR, DWORD, REFIID, void **))GetProcAddress(shell32, "SHCreateFileExtractIconW"); + /* Show that icons returned are always the same */ + UINT tryFlags[4] = { 0, GIL_FORSHORTCUT, GIL_OPENICON }; + CoInitialize(NULL); GetModuleFileNameW(NULL, CurrentModule, _countof(CurrentModule)); @@ -101,6 +120,24 @@ START_TEST(SHCreateFileExtractIconW) return; } + for (size_t n = 0; n < _countof(InterfaceTests); ++n) + { + { + CComPtr<IUnknown> spUnknown; + HRESULT hr = pSHCreateFileExtractIconW(L"test.txt", FILE_ATTRIBUTE_NORMAL, *InterfaceTests[n].IID, (void**)&spUnknown); + ok(hr == InterfaceTests[n].ExpectedCreate, "Expected hr to be 0x%lx, was 0x%lx for %u\n", InterfaceTests[n].ExpectedCreate, hr, n); + } + + { + CComPtr<IUnknown> spUnknown, spUnknown2; + HRESULT hr = pSHCreateFileExtractIconW(L"test.txt", FILE_ATTRIBUTE_NORMAL, IID_PPV_ARG(IUnknown, &spUnknown)); + ok(hr == S_OK, "Expected hr to be S_OK, was 0x%lx for %u\n", hr, n); + + hr = spUnknown->QueryInterface(*InterfaceTests[n].IID, (void**)&spUnknown2); + ok(hr == InterfaceTests[n].ExpectedQueryInterface, "Expected hr to be 0x%lx, was 0x%lx for %u\n", InterfaceTests[n].ExpectedQueryInterface, hr, n); + } + } + for (size_t n = 0; n < _countof(IconTests); ++n) { TestData& cur = IconTests[n]; @@ -119,85 +156,102 @@ START_TEST(SHCreateFileExtractIconW) if (!SUCCEEDED(hr)) continue; - int ilIndex = -1; - UINT wFlags = 0xdeaddead; - WCHAR Buffer[MAX_PATH]; + /* Show that GIL_DEFAULTICON does not work. */ + { + int ilIndex = -1; + UINT wFlags = 0xdeaddead; + WCHAR Buffer[MAX_PATH]; + + hr = spExtract->GetIconLocation(GIL_DEFAULTICON, Buffer, _countof(Buffer), &ilIndex, &wFlags); + ok(hr == S_FALSE, "Expected hr to be S_FALSE, was 0x%lx for %S(0x%lx)\n", hr, cur.Name, cur.dwFlags); + } - hr = spExtract->GetIconLocation(0, Buffer, _countof(Buffer), &ilIndex, &wFlags); - ok(hr == S_OK, "Expected hr to be S_OK, was 0x%lx for %S(%lx)\n", hr, cur.Name, cur.dwFlags); - if (!SUCCEEDED(hr)) - continue; - ok(wFlags & (GIL_NOTFILENAME|GIL_PERCLASS), "Expected GIL_NOTFILENAME|GIL_PERCLASS to be set for %S(%lx)\n", cur.Name, cur.dwFlags); - ok(!wcscmp(Buffer, L"*"), "Expected '*', was '%S' for %S(%lx)\n", Buffer, cur.Name, cur.dwFlags); + for (UINT idFlags = 0; idFlags < _countof(tryFlags); ++idFlags) + { + int ilIndex = -1; + UINT wFlags = 0xdeaddead; + WCHAR Buffer[MAX_PATH]; - HICON ico; - hr = spExtract->Extract(Buffer, ilIndex, &ico, NULL, 0); + hr = spExtract->GetIconLocation(tryFlags[idFlags], Buffer, _countof(Buffer), &ilIndex, &wFlags); + ok(hr == S_OK, "Expected hr to be S_OK, was 0x%lx for %S(0x%lx,0x%x)\n", hr, cur.Name, cur.dwFlags, tryFlags[idFlags]); + if (!SUCCEEDED(hr)) + continue; - /* Visualize the icon extracted for whoever is stepping through this code. */ - HWND console = GetConsoleWindow(); - SendMessage(console, WM_SETICON, ICON_BIG, (LPARAM)ico); - SendMessage(console, WM_SETICON, ICON_SMALL, (LPARAM)ico); + ok(wFlags & (GIL_NOTFILENAME|GIL_PERCLASS), "Expected GIL_NOTFILENAME|GIL_PERCLASS to be set for %S(0x%lx,0x%x)\n", cur.Name, cur.dwFlags, tryFlags[idFlags]); + ok(!wcscmp(Buffer, L"*"), "Expected '*', was '%S' for %S(0x%lx,0x%x)\n", Buffer, cur.Name, cur.dwFlags, tryFlags[idFlags]); - CComHeapPtr<BYTE> colorData, maskData; - DWORD colorSize = 0, maskSize = 0; + HICON ico; + hr = spExtract->Extract(Buffer, ilIndex, &ico, NULL, 0); - GetIconData(ico, colorData, colorSize, maskData, maskSize); + /* Visualize the icon extracted for whoever is stepping through this code. */ + HWND console = GetConsoleWindow(); + SendMessage(console, WM_SETICON, ICON_BIG, (LPARAM)ico); + SendMessage(console, WM_SETICON, ICON_SMALL, (LPARAM)ico); - if (!colorSize || !maskSize) - continue; + CComHeapPtr<BYTE> colorData, maskData; + DWORD colorSize = 0, maskSize = 0; - SHFILEINFOW shfi; - ULONG_PTR firet = SHGetFileInfoW(cur.Name, cur.dwFlags, &shfi, sizeof(shfi), SHGFI_USEFILEATTRIBUTES | SHGFI_ICON); + GetIconData(ico, colorData, colorSize, maskData, maskSize); - if (!firet) - continue; + if (!colorSize || !maskSize) + continue; - CComHeapPtr<BYTE> colorDataRef, maskDataRef; - DWORD colorSizeRef = 0, maskSizeRef = 0; - GetIconData(shfi.hIcon, colorDataRef, colorSizeRef, maskDataRef, maskSizeRef); + SHFILEINFOW shfi; + ULONG_PTR firet = SHGetFileInfoW(cur.Name, cur.dwFlags, &shfi, sizeof(shfi), SHGFI_USEFILEATTRIBUTES | SHGFI_ICON | SHGFI_SYSICONINDEX); - ok(colorSizeRef == colorSize, "Expected %lu, was %lu for %S(%lx)\n", colorSizeRef, colorSize, cur.Name, cur.dwFlags); - ok(maskSizeRef == maskSize, "Expected %lu, was %lu for %S(%lx)\n", maskSizeRef, maskSize, cur.Name, cur.dwFlags); + if (!firet) + continue; - if (colorSizeRef == colorSize) - { - ok(!memcmp(colorData, colorDataRef, colorSize), "Expected equal colorData for %S(%lx)\n", cur.Name, cur.dwFlags); - } + ok(shfi.iIcon == ilIndex, "Expected ilIndex to be 0%x, was 0x%x for %S(0x%lx,0x%x)\n", shfi.iIcon, ilIndex, cur.Name, cur.dwFlags, tryFlags[idFlags]); - if (maskSizeRef == maskSize) - { - ok(!memcmp(maskData, maskDataRef, maskSize), "Expected equal maskData for %S(%lx)\n", cur.Name, cur.dwFlags); - } - if (useMyIcon) - { - colorDataRef.Free(); - maskDataRef.Free(); - colorSizeRef = maskSizeRef = 0; - GetIconData(myIcon, colorDataRef, colorSizeRef, maskDataRef, maskSizeRef); + CComHeapPtr<BYTE> colorDataRef, maskDataRef; + DWORD colorSizeRef = 0, maskSizeRef = 0; + GetIconData(shfi.hIcon, colorDataRef, colorSizeRef, maskDataRef, maskSizeRef); - ok(colorSizeRef == colorSize, "Expected %lu, was %lu for %S(%lx)\n", colorSizeRef, colorSize, cur.Name, cur.dwFlags); - ok(maskSizeRef == maskSize, "Expected %lu, was %lu for %S(%lx)\n", maskSizeRef, maskSize, cur.Name, cur.dwFlags); + ok(colorSizeRef == colorSize, "Expected %lu, was %lu for %S(0x%lx,0x%x)\n", colorSizeRef, colorSize, cur.Name, cur.dwFlags, tryFlags[idFlags]); + ok(maskSizeRef == maskSize, "Expected %lu, was %lu for %S(0x%lx,0x%x)\n", maskSizeRef, maskSize, cur.Name, cur.dwFlags, tryFlags[idFlags]); if (colorSizeRef == colorSize) { - /* Incase requested filetype does not match, the exe icon is not used! */ - if (cur.dwFlags == FILE_ATTRIBUTE_DIRECTORY) - { - ok(memcmp(colorData, colorDataRef, colorSize), "Expected colorData to be changed for %S(%lx)\n", cur.Name, cur.dwFlags); - } - else + ok(!memcmp(colorData, colorDataRef, colorSize), "Expected equal colorData for %S(0x%lx,0x%x)\n", cur.Name, cur.dwFlags, tryFlags[idFlags]); + } + + if (maskSizeRef == maskSize) + { + ok(!memcmp(maskData, maskDataRef, maskSize), "Expected equal maskData for %S(0x%lx,0x%x)\n", cur.Name, cur.dwFlags, tryFlags[idFlags]); + } + + if (useMyIcon) + { + colorDataRef.Free(); + maskDataRef.Free(); + colorSizeRef = maskSizeRef = 0; + GetIconData(myIcon, colorDataRef, colorSizeRef, maskDataRef, maskSizeRef); + + ok(colorSizeRef == colorSize, "Expected %lu, was %lu for %S(0x%lx,0x%x)\n", colorSizeRef, colorSize, cur.Name, cur.dwFlags, tryFlags[idFlags]); + ok(maskSizeRef == maskSize, "Expected %lu, was %lu for %S(0x%lx,0x%x)\n", maskSizeRef, maskSize, cur.Name, cur.dwFlags, tryFlags[idFlags]); + + if (colorSizeRef == colorSize) { - ok(!memcmp(colorData, colorDataRef, colorSize), "Expected equal colorData for %S(%lx)\n", cur.Name, cur.dwFlags); + /* In case requested filetype does not match, the exe icon is not used! */ + if (cur.dwFlags == FILE_ATTRIBUTE_DIRECTORY) + { + ok(memcmp(colorData, colorDataRef, colorSize), "Expected colorData to be changed for %S(0x%lx,0x%x)\n", cur.Name, cur.dwFlags, tryFlags[idFlags]); + } + else + { + ok(!memcmp(colorData, colorDataRef, colorSize), "Expected equal colorData for %S(0x%lx,0x%x)\n", cur.Name, cur.dwFlags, tryFlags[idFlags]); + } } - } - // Mask is not reliable for some reason - //if (maskSizeRef == maskSize) - //{ - // ok(!memcmp(maskData, maskDataRef, maskSize), "Expected equal maskData for %S(%lx)\n", cur.Name, cur.dwFlags); - //} + // Mask is not reliable for some reason + //if (maskSizeRef == maskSize) + //{ + // ok(!memcmp(maskData, maskDataRef, maskSize), "Expected equal maskData for %S(0x%lx,0x%lx)\n", cur.Name, cur.dwFlags); + //} + } } } }

1 0

02/06: [SHELL32] Partially implement SHCreateFileExtractIconW CORE-14082
by Mark Jansen 07 Apr '18

07 Apr '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=a69393205ad3e37c4ba28… commit a69393205ad3e37c4ba286385f29644683518cd8 Author: Mark Jansen <mark.jansen(a)reactos.org> AuthorDate: Tue Mar 27 19:57:00 2018 +0200 Commit: Mark Jansen <mark.jansen(a)reactos.org> CommitDate: Sat Apr 7 15:29:58 2018 +0200 [SHELL32] Partially implement SHCreateFileExtractIconW CORE-14082 --- dll/win32/shell32/CExtractIcon.cpp | 36 ++++++++++++++++++++++++++++++++++++ dll/win32/shell32/stubs.cpp | 14 -------------- 2 files changed, 36 insertions(+), 14 deletions(-) diff --git a/dll/win32/shell32/CExtractIcon.cpp b/dll/win32/shell32/CExtractIcon.cpp index 232d2c212f..26bdb4e930 100644 --- a/dll/win32/shell32/CExtractIcon.cpp +++ b/dll/win32/shell32/CExtractIcon.cpp @@ -338,3 +338,39 @@ HRESULT WINAPI SHCreateDefaultExtractIcon(REFIID riid, void **ppv) { return ShellObjectCreator<CExtractIcon>(riid, ppv); } + +/* + * Partially implemented + * See apitests\shell32\SHCreateFileExtractIconW.cpp for details + * Currently (march 2018) our shell does not handle IExtractIconW with an invalid path, + * so this (wrong) implementation actually works better for us. + */ +EXTERN_C HRESULT +WINAPI +SHCreateFileExtractIconW(LPCWSTR pszPath, + DWORD dwFileAttributes, + REFIID riid, + void **ppv) +{ + SHFILEINFOW shfi; + ULONG_PTR firet = SHGetFileInfoW(pszPath, dwFileAttributes, &shfi, sizeof(shfi), SHGFI_USEFILEATTRIBUTES | SHGFI_ICONLOCATION); + HRESULT hr = E_FAIL; + if (firet) + { + CComPtr<IDefaultExtractIconInit> iconInit; + hr = SHCreateDefaultExtractIcon(IID_PPV_ARG(IDefaultExtractIconInit, &iconInit)); + if (FAILED_UNEXPECTEDLY(hr)) + return hr; + + hr = iconInit->SetNormalIcon(shfi.szDisplayName, shfi.iIcon); + if (FAILED_UNEXPECTEDLY(hr)) + return hr; + + return iconInit->QueryInterface(riid, ppv); + } + if (FAILED_UNEXPECTEDLY(hr)) + return hr; + + return hr; +} + diff --git a/dll/win32/shell32/stubs.cpp b/dll/win32/shell32/stubs.cpp index 48339a6a83..f2019e5f2d 100644 --- a/dll/win32/shell32/stubs.cpp +++ b/dll/win32/shell32/stubs.cpp @@ -69,20 +69,6 @@ PathIsEqualOrSubFolder(LPWSTR lpFolder, LPWSTR lpSubFolder) return FALSE; } -/* - * Unimplemented - */ -EXTERN_C HRESULT -WINAPI -SHCreateFileExtractIconW(LPCWSTR pszPath, - DWORD dwFileAttributes, - REFIID riid, - void **ppv) -{ - FIXME("SHCreateFileExtractIconW() stub\n"); - return E_FAIL; -} - EXTERN_C HRESULT WINAPI SHGetUnreadMailCountW(HKEY hKeyUser,

1 0

01/06: [SHELL32] Initial partial IShellFolderViewCB implementation.
by Mark Jansen 07 Apr '18

07 Apr '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=0d07967a27e747e57d551… commit 0d07967a27e747e57d5518439e178565745f8f5b Author: Mark Jansen <mark.jansen(a)reactos.org> AuthorDate: Mon Dec 18 23:27:05 2017 +0100 Commit: Mark Jansen <mark.jansen(a)reactos.org> CommitDate: Sat Apr 7 15:29:53 2018 +0200 [SHELL32] Initial partial IShellFolderViewCB implementation. --- dll/win32/shell32/CDefView.cpp | 35 +++++++++++++++++++++++++++++-- dll/win32/shell32/CDefaultContextMenu.cpp | 12 ++++++++--- 2 files changed, 42 insertions(+), 5 deletions(-) diff --git a/dll/win32/shell32/CDefView.cpp b/dll/win32/shell32/CDefView.cpp index 336b3fc534..33e5b5a760 100644 --- a/dll/win32/shell32/CDefView.cpp +++ b/dll/win32/shell32/CDefView.cpp @@ -72,6 +72,7 @@ class CDefView : private: CComPtr<IShellFolder> m_pSFParent; CComPtr<IShellFolder2> m_pSF2Parent; + CComPtr<IShellFolderViewCB> m_pShellFolderViewCB; CComPtr<IShellBrowser> m_pShellBrowser; CComPtr<ICommDlgBrowser> m_pCommDlgBrowser; CComPtr<IShellFolderViewDual> m_pShellFolderViewDual; @@ -113,6 +114,7 @@ class CDefView : private: HRESULT _MergeToolbar(); BOOL _Sort(); + VOID _DoFolderViewCB(UINT uMsg, WPARAM wParam, LPARAM lParam); public: CDefView(); @@ -951,6 +953,8 @@ HRESULT CDefView::FillList() /*turn the listview's redrawing back on and force it to draw*/ m_ListView.SetRedraw(TRUE); + _DoFolderViewCB(SFVM_LISTREFRESHED, NULL, NULL); + return S_OK; } @@ -1059,6 +1063,8 @@ LRESULT CDefView::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandl m_hNotify = SHChangeNotifyRegister(m_hWnd, SHCNRF_InterruptLevel | SHCNRF_ShellLevel, SHCNE_ALLEVENTS, SHV_CHANGE_NOTIFY, 1, &ntreg); } + /* _DoFolderViewCB(SFVM_GETNOTIFY, ?? ??) */ + m_hAccel = LoadAcceleratorsW(shell32_hInstance, MAKEINTRESOURCEW(IDA_SHELLVIEW)); UpdateStatusbar(); @@ -1410,6 +1416,8 @@ LRESULT CDefView::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled ::MoveWindow(m_ListView, 0, 0, wWidth, wHeight, TRUE); } + _DoFolderViewCB(SFVM_SIZE, 0, 0); + return 0; } @@ -1757,6 +1765,7 @@ LRESULT CDefView::OnNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandl TRACE("-- LVN_ITEMCHANGED %p\n", this); OnStateChange(CDBOSC_SELCHANGE); /* the browser will get the IDataObject now */ UpdateStatusbar(); + _DoFolderViewCB(SFVM_SELECTIONCHANGED, NULL/* FIXME */, NULL/* FIXME */); break; case LVN_BEGINDRAG: @@ -2588,6 +2597,8 @@ HRESULT STDMETHODCALLTYPE CDefView::CreateViewWindow3(IShellBrowser *psb, IShell if (!*hwnd) return E_FAIL; + _DoFolderViewCB(SFVM_WINDOWCREATED, (WPARAM)m_hWnd, NULL); + SetWindowPos(HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW); UpdateWindow(); @@ -2796,8 +2807,11 @@ HRESULT STDMETHODCALLTYPE CDefView::GetItemSpacing(ITEMSPACING *spacing) HRESULT STDMETHODCALLTYPE CDefView::SetCallback(IShellFolderViewCB *new_cb, IShellFolderViewCB **old_cb) { - FIXME("(%p)->(%p %p) stub\n", this, new_cb, old_cb); - return E_NOTIMPL; + if (old_cb) + *old_cb = m_pShellFolderViewCB.Detach(); + + m_pShellFolderViewCB = new_cb; + return S_OK; } HRESULT STDMETHODCALLTYPE CDefView::Select(UINT flags) @@ -3231,6 +3245,14 @@ HRESULT CDefView::_MergeToolbar() return S_OK; } +VOID CDefView::_DoFolderViewCB(UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + if (m_pShellFolderViewCB) + { + m_pShellFolderViewCB->MessageSFVCB(uMsg, wParam, lParam); + } +} + HRESULT CDefView_CreateInstance(IShellFolder *pFolder, REFIID riid, LPVOID * ppvOut) { return ShellObjectCreatorInit<CDefView>(pFolder, riid, ppvOut); @@ -3273,6 +3295,15 @@ HRESULT WINAPI SHCreateShellFolderView(const SFV_CREATE *pcsfv, if (FAILED(hRes)) return hRes; + if (pcsfv->psfvcb) + { + CComPtr<IShellFolderView> sfv; + if (SUCCEEDED(psv->QueryInterface(IID_PPV_ARG(IShellFolderView, &sfv)))) + { + sfv->SetCallback(pcsfv->psfvcb, NULL); + } + } + *ppsv = psv.Detach(); return hRes; } diff --git a/dll/win32/shell32/CDefaultContextMenu.cpp b/dll/win32/shell32/CDefaultContextMenu.cpp index fac9b50907..93ce54c984 100644 --- a/dll/win32/shell32/CDefaultContextMenu.cpp +++ b/dll/win32/shell32/CDefaultContextMenu.cpp @@ -369,18 +369,24 @@ CDefaultContextMenu::LoadDynamicContextMenuHandler(HKEY hKey, const CLSID *pclsi CComPtr<IContextMenu> pcm; hr = SHCoCreateInstance(NULL, pclsid, NULL, IID_PPV_ARG(IContextMenu, &pcm)); - if (FAILED_UNEXPECTEDLY(hr)) + if (FAILED(hr)) + { + ERR("SHCoCreateInstance(IContextMenu) failed.clsid %s hr 0x%x\n", wine_dbgstr_guid(pclsid), hr); return hr; + } CComPtr<IShellExtInit> pExtInit; hr = pcm->QueryInterface(IID_PPV_ARG(IShellExtInit, &pExtInit)); - if (FAILED_UNEXPECTEDLY(hr)) + if (FAILED(hr)) + { + ERR("IContextMenu->QueryInterface(IShellExtInit) failed.clsid %s hr 0x%x\n", wine_dbgstr_guid(pclsid), hr); return hr; + } hr = pExtInit->Initialize(m_pidlFolder, m_pDataObj, hKey); if (FAILED(hr)) { - WARN("IShellExtInit::Initialize failed.clsid %s hr 0x%x\n", wine_dbgstr_guid(pclsid), hr); + ERR("IShellExtInit::Initialize failed.clsid %s hr 0x%x\n", wine_dbgstr_guid(pclsid), hr); return hr; }

1 0

03/03: [APISETS] Add the initial set of auto-generated files. CORE-13231
by Mark Jansen 07 Apr '18

07 Apr '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=3f15a0d473ef745b9643a… commit 3f15a0d473ef745b9643a3497270c229814221d5 Author: Mark Jansen <mark.jansen(a)reactos.org> AuthorDate: Sat Apr 7 03:24:12 2018 +0200 Commit: Mark Jansen <mark.jansen(a)reactos.org> CommitDate: Sat Apr 7 14:50:59 2018 +0200 [APISETS] Add the initial set of auto-generated files. CORE-13231 --- dll/CMakeLists.txt | 2 +- dll/apisets/CMakeLists.txt | 247 +++++ .../api-ms-win-appmodel-identity-l1-1-0.spec | 20 + .../api-ms-win-appmodel-runtime-l1-1-1.spec | 30 + .../api-ms-win-appmodel-runtime-l1-1-2.spec | 20 + dll/apisets/api-ms-win-core-apiquery-l1-1-0.spec | 4 + dll/apisets/api-ms-win-core-appcompat-l1-1-1.spec | 13 + dll/apisets/api-ms-win-core-appinit-l1-1-0.spec | 4 + dll/apisets/api-ms-win-core-atoms-l1-1-0.spec | 20 + dll/apisets/api-ms-win-core-bem-l1-1-0.spec | 8 + dll/apisets/api-ms-win-core-com-l1-1-0.spec | 83 ++ dll/apisets/api-ms-win-core-com-l1-1-1.spec | 85 ++ .../api-ms-win-core-com-private-l1-1-0.spec | 94 ++ dll/apisets/api-ms-win-core-console-l1-1-0.spec | 17 + dll/apisets/api-ms-win-core-console-l2-1-0.spec | 41 + dll/apisets/api-ms-win-core-crt-l1-1-0.spec | 101 ++ dll/apisets/api-ms-win-core-crt-l2-1-0.spec | 22 + dll/apisets/api-ms-win-core-datetime-l1-1-0.spec | 7 + dll/apisets/api-ms-win-core-datetime-l1-1-1.spec | 9 + dll/apisets/api-ms-win-core-debug-l1-1-0.spec | 7 + dll/apisets/api-ms-win-core-debug-l1-1-1.spec | 12 + dll/apisets/api-ms-win-core-delayload-l1-1-0.spec | 4 + dll/apisets/api-ms-win-core-delayload-l1-1-1.spec | 6 + .../api-ms-win-core-errorhandling-l1-1-0.spec | 10 + .../api-ms-win-core-errorhandling-l1-1-1.spec | 15 + .../api-ms-win-core-errorhandling-l1-1-2.spec | 16 + .../api-ms-win-core-errorhandling-l1-1-3.spec | 19 + dll/apisets/api-ms-win-core-fibers-l1-1-0.spec | 7 + dll/apisets/api-ms-win-core-fibers-l1-1-1.spec | 8 + dll/apisets/api-ms-win-core-file-l1-1-0.spec | 79 ++ dll/apisets/api-ms-win-core-file-l1-2-0.spec | 82 ++ dll/apisets/api-ms-win-core-file-l1-2-1.spec | 85 ++ dll/apisets/api-ms-win-core-file-l1-2-2.spec | 13 + dll/apisets/api-ms-win-core-file-l2-1-0.spec | 14 + dll/apisets/api-ms-win-core-file-l2-1-1.spec | 15 + dll/apisets/api-ms-win-core-file-l2-1-2.spec | 17 + dll/apisets/api-ms-win-core-handle-l1-1-0.spec | 7 + dll/apisets/api-ms-win-core-heap-l1-1-0.spec | 19 + dll/apisets/api-ms-win-core-heap-l1-2-0.spec | 18 + dll/apisets/api-ms-win-core-heap-l2-1-0.spec | 10 + .../api-ms-win-core-heap-obsolete-l1-1-0.spec | 18 + .../api-ms-win-core-interlocked-l1-1-0.spec | 15 + .../api-ms-win-core-interlocked-l1-2-0.spec | 15 + dll/apisets/api-ms-win-core-io-l1-1-0.spec | 10 + dll/apisets/api-ms-win-core-io-l1-1-1.spec | 13 + dll/apisets/api-ms-win-core-job-l1-1-0.spec | 4 + dll/apisets/api-ms-win-core-job-l2-1-0.spec | 9 + .../api-ms-win-core-kernel32-legacy-l1-1-0.spec | 57 + .../api-ms-win-core-kernel32-legacy-l1-1-1.spec | 72 ++ .../api-ms-win-core-kernel32-private-l1-1-1.spec | 4 + .../api-ms-win-core-largeinteger-l1-1-0.spec | 4 + .../api-ms-win-core-libraryloader-l1-1-0.spec | 32 + .../api-ms-win-core-libraryloader-l1-1-1.spec | 33 + .../api-ms-win-core-libraryloader-l1-2-0.spec | 32 + .../api-ms-win-core-libraryloader-l1-2-1.spec | 6 + .../api-ms-win-core-libraryloader-l1-2-2.spec | 7 + .../api-ms-win-core-localization-l1-1-0.spec | 50 + .../api-ms-win-core-localization-l1-2-0.spec | 62 ++ .../api-ms-win-core-localization-l1-2-1.spec | 63 ++ .../api-ms-win-core-localization-l2-1-0.spec | 15 + ...i-ms-win-core-localization-obsolete-l1-1-0.spec | 14 + ...i-ms-win-core-localization-obsolete-l1-2-0.spec | 13 + ...i-ms-win-core-localization-obsolete-l1-3-0.spec | 12 + ...pi-ms-win-core-localization-private-l1-1-0.spec | 14 + .../api-ms-win-core-localregistry-l1-1-0.spec | 43 + dll/apisets/api-ms-win-core-memory-l1-1-0.spec | 19 + dll/apisets/api-ms-win-core-memory-l1-1-1.spec | 35 + dll/apisets/api-ms-win-core-memory-l1-1-2.spec | 42 + dll/apisets/api-ms-win-core-misc-l1-1-0.spec | 37 + dll/apisets/api-ms-win-core-namedpipe-l1-1-0.spec | 14 + dll/apisets/api-ms-win-core-namedpipe-l1-2-0.spec | 13 + dll/apisets/api-ms-win-core-namespace-l1-1-0.spec | 9 + .../api-ms-win-core-normalization-l1-1-0.spec | 8 + dll/apisets/api-ms-win-core-path-l1-1-0.spec | 25 + .../api-ms-win-core-privateprofile-l1-1-1.spec | 5 + .../api-ms-win-core-processenvironment-l1-1-0.spec | 25 + .../api-ms-win-core-processenvironment-l1-2-0.spec | 27 + .../api-ms-win-core-processthreads-l1-1-0.spec | 52 + .../api-ms-win-core-processthreads-l1-1-1.spec | 66 ++ .../api-ms-win-core-processthreads-l1-1-2.spec | 73 ++ ...s-win-core-processtopology-obsolete-l1-1-0.spec | 8 + dll/apisets/api-ms-win-core-profile-l1-1-0.spec | 5 + dll/apisets/api-ms-win-core-psapi-ansi-l1-1-0.spec | 9 + dll/apisets/api-ms-win-core-psapi-l1-1-0.spec | 19 + .../api-ms-win-core-psapi-obsolete-l1-1-0.spec | 10 + dll/apisets/api-ms-win-core-quirks-l1-1-0.spec | 11 + dll/apisets/api-ms-win-core-realtime-l1-1-0.spec | 8 + dll/apisets/api-ms-win-core-registry-l1-1-0.spec | 46 + dll/apisets/api-ms-win-core-registry-l2-1-0.spec | 36 + ...pi-ms-win-core-registryuserspecific-l1-1-0.spec | 28 + dll/apisets/api-ms-win-core-rtlsupport-l1-1-0.spec | 18 + dll/apisets/api-ms-win-core-rtlsupport-l1-2-0.spec | 9 + .../api-ms-win-core-shlwapi-legacy-l1-1-0.spec | 91 ++ .../api-ms-win-core-shlwapi-obsolete-l1-1-0.spec | 64 ++ .../api-ms-win-core-shlwapi-obsolete-l1-2-0.spec | 61 + dll/apisets/api-ms-win-core-shutdown-l1-1-0.spec | 5 + dll/apisets/api-ms-win-core-sidebyside-l1-1-0.spec | 14 + dll/apisets/api-ms-win-core-string-l1-1-0.spec | 11 + dll/apisets/api-ms-win-core-string-l2-1-0.spec | 13 + .../api-ms-win-core-string-obsolete-l1-1-0.spec | 13 + dll/apisets/api-ms-win-core-stringansi-l1-1-0.spec | 15 + dll/apisets/api-ms-win-core-synch-ansi-l1-1-0.spec | 10 + dll/apisets/api-ms-win-core-synch-l1-1-0.spec | 45 + dll/apisets/api-ms-win-core-synch-l1-2-0.spec | 61 + dll/apisets/api-ms-win-core-synch-l1-2-1.spec | 64 ++ dll/apisets/api-ms-win-core-sysinfo-l1-1-0.spec | 31 + dll/apisets/api-ms-win-core-sysinfo-l1-2-0.spec | 34 + dll/apisets/api-ms-win-core-sysinfo-l1-2-1.spec | 39 + dll/apisets/api-ms-win-core-threadpool-l1-1-0.spec | 45 + dll/apisets/api-ms-win-core-threadpool-l1-2-0.spec | 40 + .../api-ms-win-core-threadpool-legacy-l1-1-0.spec | 10 + .../api-ms-win-core-threadpool-private-l1-1-0.spec | 4 + dll/apisets/api-ms-win-core-timezone-l1-1-0.spec | 16 + dll/apisets/api-ms-win-core-toolhelp-l1-1-0.spec | 10 + dll/apisets/api-ms-win-core-url-l1-1-0.spec | 41 + dll/apisets/api-ms-win-core-util-l1-1-0.spec | 8 + dll/apisets/api-ms-win-core-version-l1-1-0.spec | 7 + dll/apisets/api-ms-win-core-version-l1-1-1.spec | 9 + .../api-ms-win-core-version-private-l1-1-0.spec | 4 + .../api-ms-win-core-versionansi-l1-1-0.spec | 7 + ...i-ms-win-core-windowserrorreporting-l1-1-0.spec | 13 + .../api-ms-win-core-winrt-error-l1-1-0.spec | 14 + .../api-ms-win-core-winrt-error-l1-1-1.spec | 22 + .../api-ms-win-core-winrt-errorprivate-l1-1-1.spec | 5 + dll/apisets/api-ms-win-core-winrt-l1-1-0.spec | 12 + .../api-ms-win-core-winrt-registration-l1-1-0.spec | 5 + ...s-win-core-winrt-roparameterizediid-l1-1-0.spec | 6 + .../api-ms-win-core-winrt-string-l1-1-0.spec | 30 + dll/apisets/api-ms-win-core-wow64-l1-1-0.spec | 6 + dll/apisets/api-ms-win-core-wow64-l1-1-1.spec | 8 + dll/apisets/api-ms-win-core-xstate-l1-1-0.spec | 11 + dll/apisets/api-ms-win-core-xstate-l2-1-0.spec | 9 + dll/apisets/api-ms-win-crt-conio-l1-1-0.spec | 33 + dll/apisets/api-ms-win-crt-convert-l1-1-0.spec | 125 +++ dll/apisets/api-ms-win-crt-environment-l1-1-0.spec | 21 + dll/apisets/api-ms-win-crt-filesystem-l1-1-0.spec | 68 ++ dll/apisets/api-ms-win-crt-heap-l1-1-0.spec | 30 + dll/apisets/api-ms-win-crt-locale-l1-1-0.spec | 23 + dll/apisets/api-ms-win-crt-math-l1-1-0.spec | 344 ++++++ dll/apisets/api-ms-win-crt-multibyte-l1-1-0.spec | 204 ++++ dll/apisets/api-ms-win-crt-private-l1-1-0.spec | 1170 ++++++++++++++++++++ dll/apisets/api-ms-win-crt-process-l1-1-0.spec | 39 + dll/apisets/api-ms-win-crt-runtime-l1-1-0.spec | 110 ++ dll/apisets/api-ms-win-crt-stdio-l1-1-0.spec | 162 +++ dll/apisets/api-ms-win-crt-string-l1-1-0.spec | 181 +++ dll/apisets/api-ms-win-crt-time-l1-1-0.spec | 75 ++ dll/apisets/api-ms-win-crt-utility-l1-1-0.spec | 27 + dll/apisets/api-ms-win-devices-config-l1-1-1.spec | 42 + dll/apisets/api-ms-win-devices-query-l1-1-1.spec | 18 + .../api-ms-win-downlevel-advapi32-l1-1-0.spec | 148 +++ .../api-ms-win-downlevel-advapi32-l2-1-0.spec | 17 + .../api-ms-win-downlevel-normaliz-l1-1-0.spec | 5 + dll/apisets/api-ms-win-downlevel-ole32-l1-1-0.spec | 51 + .../api-ms-win-downlevel-shell32-l1-1-0.spec | 6 + .../api-ms-win-downlevel-shlwapi-l1-1-0.spec | 158 +++ .../api-ms-win-downlevel-shlwapi-l2-1-0.spec | 59 + .../api-ms-win-downlevel-user32-l1-1-0.spec | 25 + .../api-ms-win-downlevel-version-l1-1-0.spec | 9 + dll/apisets/api-ms-win-dx-d3dkmt-l1-1-0.spec | 100 ++ ...api-ms-win-eventing-classicprovider-l1-1-0.spec | 11 + .../api-ms-win-eventing-consumer-l1-1-0.spec | 6 + .../api-ms-win-eventing-controller-l1-1-0.spec | 14 + dll/apisets/api-ms-win-eventing-legacy-l1-1-0.spec | 17 + .../api-ms-win-eventing-provider-l1-1-0.spec | 13 + dll/apisets/api-ms-win-eventlog-legacy-l1-1-0.spec | 9 + dll/apisets/api-ms-win-gdi-dpiinfo-l1-1-0.spec | 4 + dll/apisets/api-ms-win-mm-joystick-l1-1-0.spec | 13 + dll/apisets/api-ms-win-mm-misc-l1-1-1.spec | 33 + dll/apisets/api-ms-win-mm-mme-l1-1-0.spec | 105 ++ dll/apisets/api-ms-win-mm-time-l1-1-0.spec | 8 + .../api-ms-win-ntuser-dc-access-l1-1-0.spec | 5 + .../api-ms-win-ntuser-rectangle-l1-1-0.spec | 14 + dll/apisets/api-ms-win-perf-legacy-l1-1-0.spec | 12 + dll/apisets/api-ms-win-power-base-l1-1-0.spec | 8 + dll/apisets/api-ms-win-power-setting-l1-1-0.spec | 11 + .../api-ms-win-rtcore-ntuser-draw-l1-1-0.spec | 4 + .../api-ms-win-rtcore-ntuser-private-l1-1-0.spec | 12 + .../api-ms-win-rtcore-ntuser-private-l1-1-4.spec | 4 + .../api-ms-win-rtcore-ntuser-window-l1-1-0.spec | 84 ++ .../api-ms-win-rtcore-ntuser-winevent-l1-1-0.spec | 7 + .../api-ms-win-rtcore-ntuser-wmpointer-l1-1-0.spec | 28 + .../api-ms-win-rtcore-ntuser-wmpointer-l1-1-3.spec | 4 + ...-win-security-activedirectoryclient-l1-1-0.spec | 11 + dll/apisets/api-ms-win-security-audit-l1-1-1.spec | 18 + dll/apisets/api-ms-win-security-base-l1-1-0.spec | 100 ++ dll/apisets/api-ms-win-security-base-l1-2-0.spec | 105 ++ .../api-ms-win-security-base-private-l1-1-1.spec | 6 + .../api-ms-win-security-credentials-l1-1-0.spec | 32 + .../api-ms-win-security-grouppolicy-l1-1-0.spec | 26 + .../api-ms-win-security-lsalookup-l1-1-0.spec | 14 + .../api-ms-win-security-lsalookup-l1-1-1.spec | 19 + .../api-ms-win-security-lsalookup-l2-1-0.spec | 9 + .../api-ms-win-security-lsalookup-l2-1-1.spec | 10 + .../api-ms-win-security-lsapolicy-l1-1-0.spec | 25 + .../api-ms-win-security-provider-l1-1-0.spec | 9 + dll/apisets/api-ms-win-security-sddl-l1-1-0.spec | 7 + ...api-ms-win-security-systemfunctions-l1-1-0.spec | 6 + dll/apisets/api-ms-win-service-core-l1-1-0.spec | 6 + dll/apisets/api-ms-win-service-core-l1-1-1.spec | 9 + .../api-ms-win-service-management-l1-1-0.spec | 10 + .../api-ms-win-service-management-l2-1-0.spec | 11 + dll/apisets/api-ms-win-service-private-l1-1-1.spec | 19 + dll/apisets/api-ms-win-service-winsvc-l1-1-0.spec | 29 + dll/apisets/api-ms-win-service-winsvc-l1-2-0.spec | 19 + dll/apisets/api-ms-win-shcore-obsolete-l1-1-0.spec | 6 + dll/apisets/api-ms-win-shcore-scaling-l1-1-1.spec | 12 + dll/apisets/api-ms-win-shcore-stream-l1-1-0.spec | 18 + dll/apisets/api-ms-win-shcore-thread-l1-1-0.spec | 11 + dll/apisets/api-ms-win-shell-shellcom-l1-1-0.spec | 4 + .../api-ms-win-shell-shellfolders-l1-1-0.spec | 17 + 210 files changed, 7720 insertions(+), 1 deletion(-) diff --git a/dll/CMakeLists.txt b/dll/CMakeLists.txt index c9f4f72195..08458544df 100644 --- a/dll/CMakeLists.txt +++ b/dll/CMakeLists.txt @@ -1,6 +1,6 @@ add_subdirectory(3rdparty) -#add_subdirectory(apisets) +add_subdirectory(apisets) add_subdirectory(appcompat) add_subdirectory(cpl) add_subdirectory(directx) diff --git a/dll/apisets/CMakeLists.txt b/dll/apisets/CMakeLists.txt new file mode 100644 index 0000000000..aaf12c3880 --- /dev/null +++ b/dll/apisets/CMakeLists.txt @@ -0,0 +1,247 @@ + +# This file is generated by update.py, please edit CMakeLists.txt.in instead +# Generated from wine-3.5-91-g3263d51a1f + +project(apisets) + +function (add_apiset apiset_name baseaddress) + spec2def(${apiset_name}.dll ${apiset_name}.spec ADD_IMPORTLIB) + + add_definitions( + -D_CTYPE_DISABLE_MACROS + -D_NO_INLINING + -D__CRT__NO_INLINE + -D__STDC_WANT_SECURE_LIB__=0 + -D_INC_STRING + -D_CTYPE_DEFINED + -D_WCTYPE_DEFINED + -D_CRT_ERRNO_DEFINED) + + add_library(${apiset_name} SHARED + ${CMAKE_CURRENT_BINARY_DIR}/${apiset_name}_stubs.c + ${CMAKE_CURRENT_BINARY_DIR}/${apiset_name}.def) + + add_dependencies(${apiset_name} xdk) + set_module_type(${apiset_name} win32dll ENTRYPOINT 0 UNICODE IMAGEBASE ${baseaddress}) + + if(NOT MSVC) + add_target_compile_flags(${apiset_name} "-fno-builtin") + else() + add_target_compile_flags(${apiset_name} "/wd4026 /wd4273") + endif() + + add_importlibs(${apiset_name} ${ARGN} kernel32 ntdll) + + add_cd_file(TARGET ${apiset_name} DESTINATION reactos/system32 FOR all) +endfunction() + +# Apisets will be appended + +add_apiset(api-ms-win-appmodel-identity-l1-1-0 0x60000000 ) +add_apiset(api-ms-win-appmodel-runtime-l1-1-1 0x60020000 ) +add_apiset(api-ms-win-appmodel-runtime-l1-1-2 0x60040000 ) +add_apiset(api-ms-win-core-apiquery-l1-1-0 0x60060000 ) +add_apiset(api-ms-win-core-appcompat-l1-1-1 0x60070000 ) +add_apiset(api-ms-win-core-appinit-l1-1-0 0x60080000 ) +add_apiset(api-ms-win-core-atoms-l1-1-0 0x60090000 ) +add_apiset(api-ms-win-core-bem-l1-1-0 0x600a0000 ) +add_apiset(api-ms-win-core-com-l1-1-0 0x600b0000 ole32) +add_apiset(api-ms-win-core-com-l1-1-1 0x600c0000 ole32) +add_apiset(api-ms-win-core-com-private-l1-1-0 0x600e0000 ole32) +add_apiset(api-ms-win-core-console-l1-1-0 0x60130000 ) +add_apiset(api-ms-win-core-console-l2-1-0 0x60140000 ) +add_apiset(api-ms-win-core-crt-l1-1-0 0x60150000 msvcrt) +add_apiset(api-ms-win-core-crt-l2-1-0 0x60180000 msvcrt) +add_apiset(api-ms-win-core-datetime-l1-1-0 0x60190000 ) +add_apiset(api-ms-win-core-datetime-l1-1-1 0x601a0000 ) +add_apiset(api-ms-win-core-debug-l1-1-0 0x601b0000 ) +add_apiset(api-ms-win-core-debug-l1-1-1 0x601c0000 ) +add_apiset(api-ms-win-core-delayload-l1-1-0 0x601d0000 ) +add_apiset(api-ms-win-core-delayload-l1-1-1 0x601e0000 ) +add_apiset(api-ms-win-core-errorhandling-l1-1-0 0x601f0000 ) +add_apiset(api-ms-win-core-errorhandling-l1-1-1 0x60200000 ) +add_apiset(api-ms-win-core-errorhandling-l1-1-2 0x60210000 ) +add_apiset(api-ms-win-core-errorhandling-l1-1-3 0x60220000 ) +add_apiset(api-ms-win-core-fibers-l1-1-0 0x60230000 ) +add_apiset(api-ms-win-core-fibers-l1-1-1 0x60240000 ) +add_apiset(api-ms-win-core-file-l1-1-0 0x60250000 ) +add_apiset(api-ms-win-core-file-l1-2-0 0x60260000 ) +add_apiset(api-ms-win-core-file-l1-2-1 0x60270000 ) +add_apiset(api-ms-win-core-file-l1-2-2 0x60280000 ) +add_apiset(api-ms-win-core-file-l2-1-0 0x60290000 kernel32_vista) +add_apiset(api-ms-win-core-file-l2-1-1 0x602a0000 kernel32_vista) +add_apiset(api-ms-win-core-file-l2-1-2 0x602b0000 kernel32_vista) +add_apiset(api-ms-win-core-handle-l1-1-0 0x602c0000 ) +add_apiset(api-ms-win-core-heap-l1-1-0 0x602d0000 ) +add_apiset(api-ms-win-core-heap-l1-2-0 0x602e0000 ) +add_apiset(api-ms-win-core-heap-l2-1-0 0x602f0000 ) +add_apiset(api-ms-win-core-heap-obsolete-l1-1-0 0x60300000 ) +add_apiset(api-ms-win-core-interlocked-l1-1-0 0x60310000 ) +add_apiset(api-ms-win-core-interlocked-l1-2-0 0x60320000 ) +add_apiset(api-ms-win-core-io-l1-1-0 0x60330000 ) +add_apiset(api-ms-win-core-io-l1-1-1 0x60340000 ) +add_apiset(api-ms-win-core-job-l1-1-0 0x60350000 ) +add_apiset(api-ms-win-core-job-l2-1-0 0x60360000 ) +add_apiset(api-ms-win-core-kernel32-legacy-l1-1-0 0x60370000 ) +add_apiset(api-ms-win-core-kernel32-legacy-l1-1-1 0x60380000 ) +add_apiset(api-ms-win-core-kernel32-private-l1-1-1 0x603a0000 ) +add_apiset(api-ms-win-core-largeinteger-l1-1-0 0x603b0000 ) +add_apiset(api-ms-win-core-libraryloader-l1-1-0 0x603c0000 user32) +add_apiset(api-ms-win-core-libraryloader-l1-1-1 0x603d0000 user32) +add_apiset(api-ms-win-core-libraryloader-l1-2-0 0x603e0000 user32) +add_apiset(api-ms-win-core-libraryloader-l1-2-1 0x603f0000 ) +add_apiset(api-ms-win-core-libraryloader-l1-2-2 0x60400000 ) +add_apiset(api-ms-win-core-localization-l1-1-0 0x60410000 ) +add_apiset(api-ms-win-core-localization-l1-2-0 0x60430000 ) +add_apiset(api-ms-win-core-localization-l1-2-1 0x60450000 ) +add_apiset(api-ms-win-core-localization-l2-1-0 0x60470000 ) +add_apiset(api-ms-win-core-localization-obsolete-l1-1-0 0x60480000 ) +add_apiset(api-ms-win-core-localization-obsolete-l1-2-0 0x60490000 ) +add_apiset(api-ms-win-core-localization-obsolete-l1-3-0 0x604a0000 ) +add_apiset(api-ms-win-core-localization-private-l1-1-0 0x604b0000 ) +add_apiset(api-ms-win-core-localregistry-l1-1-0 0x604c0000 advapi32 advapi32_vista) +add_apiset(api-ms-win-core-memory-l1-1-0 0x604d0000 ) +add_apiset(api-ms-win-core-memory-l1-1-1 0x604e0000 ) +add_apiset(api-ms-win-core-memory-l1-1-2 0x604f0000 ) +add_apiset(api-ms-win-core-misc-l1-1-0 0x60500000 ) +add_apiset(api-ms-win-core-namedpipe-l1-1-0 0x60510000 advapi32) +add_apiset(api-ms-win-core-namedpipe-l1-2-0 0x60520000 advapi32) +add_apiset(api-ms-win-core-namespace-l1-1-0 0x60530000 ) +add_apiset(api-ms-win-core-normalization-l1-1-0 0x60540000 ) +add_apiset(api-ms-win-core-path-l1-1-0 0x60550000 ) +add_apiset(api-ms-win-core-privateprofile-l1-1-1 0x60570000 ) +add_apiset(api-ms-win-core-processenvironment-l1-1-0 0x60580000 ) +add_apiset(api-ms-win-core-processenvironment-l1-2-0 0x60590000 ) +add_apiset(api-ms-win-core-processthreads-l1-1-0 0x605a0000 advapi32) +add_apiset(api-ms-win-core-processthreads-l1-1-1 0x605b0000 advapi32) +add_apiset(api-ms-win-core-processthreads-l1-1-2 0x605d0000 advapi32) +add_apiset(api-ms-win-core-processtopology-obsolete-l1-1-0 0x605f0000 ) +add_apiset(api-ms-win-core-profile-l1-1-0 0x60600000 ) +add_apiset(api-ms-win-core-psapi-ansi-l1-1-0 0x60610000 ) +add_apiset(api-ms-win-core-psapi-l1-1-0 0x60620000 ) +add_apiset(api-ms-win-core-psapi-obsolete-l1-1-0 0x60630000 ) +add_apiset(api-ms-win-core-quirks-l1-1-0 0x60640000 ) +add_apiset(api-ms-win-core-realtime-l1-1-0 0x60650000 ) +add_apiset(api-ms-win-core-registry-l1-1-0 0x60660000 advapi32 advapi32_vista) +add_apiset(api-ms-win-core-registry-l2-1-0 0x60670000 advapi32 advapi32_vista) +add_apiset(api-ms-win-core-registryuserspecific-l1-1-0 0x60680000 shlwapi) +add_apiset(api-ms-win-core-rtlsupport-l1-1-0 0x60690000 ) +add_apiset(api-ms-win-core-rtlsupport-l1-2-0 0x606a0000 ) +add_apiset(api-ms-win-core-shlwapi-legacy-l1-1-0 0x606b0000 shlwapi) +add_apiset(api-ms-win-core-shlwapi-obsolete-l1-1-0 0x606c0000 shlwapi) +add_apiset(api-ms-win-core-shlwapi-obsolete-l1-2-0 0x606d0000 shlwapi) +add_apiset(api-ms-win-core-shutdown-l1-1-0 0x606e0000 advapi32) +add_apiset(api-ms-win-core-sidebyside-l1-1-0 0x606f0000 ) +add_apiset(api-ms-win-core-string-l1-1-0 0x60700000 ) +add_apiset(api-ms-win-core-string-l2-1-0 0x60710000 user32) +add_apiset(api-ms-win-core-string-obsolete-l1-1-0 0x60720000 ) +add_apiset(api-ms-win-core-stringansi-l1-1-0 0x60730000 user32) +add_apiset(api-ms-win-core-synch-ansi-l1-1-0 0x60740000 ) +add_apiset(api-ms-win-core-synch-l1-1-0 0x60750000 kernel32_vista) +add_apiset(api-ms-win-core-synch-l1-2-0 0x60760000 kernel32_vista) +add_apiset(api-ms-win-core-synch-l1-2-1 0x60780000 kernel32_vista) +add_apiset(api-ms-win-core-sysinfo-l1-1-0 0x607a0000 kernel32_vista) +add_apiset(api-ms-win-core-sysinfo-l1-2-0 0x607b0000 kernel32_vista) +add_apiset(api-ms-win-core-sysinfo-l1-2-1 0x607c0000 kernel32_vista) +add_apiset(api-ms-win-core-threadpool-l1-1-0 0x607d0000 ) +add_apiset(api-ms-win-core-threadpool-l1-2-0 0x60800000 ) +add_apiset(api-ms-win-core-threadpool-legacy-l1-1-0 0x60830000 ) +add_apiset(api-ms-win-core-threadpool-private-l1-1-0 0x60840000 ) +add_apiset(api-ms-win-core-timezone-l1-1-0 0x60850000 ) +add_apiset(api-ms-win-core-toolhelp-l1-1-0 0x60860000 ) +add_apiset(api-ms-win-core-url-l1-1-0 0x60870000 shlwapi) +add_apiset(api-ms-win-core-util-l1-1-0 0x60880000 ) +add_apiset(api-ms-win-core-version-l1-1-0 0x60890000 version) +add_apiset(api-ms-win-core-version-l1-1-1 0x608a0000 version) +add_apiset(api-ms-win-core-version-private-l1-1-0 0x608b0000 ) +add_apiset(api-ms-win-core-versionansi-l1-1-0 0x608c0000 version) +add_apiset(api-ms-win-core-windowserrorreporting-l1-1-0 0x608d0000 ) +add_apiset(api-ms-win-core-winrt-error-l1-1-0 0x608e0000 ) +add_apiset(api-ms-win-core-winrt-error-l1-1-1 0x608f0000 ) +add_apiset(api-ms-win-core-winrt-errorprivate-l1-1-1 0x60910000 ) +add_apiset(api-ms-win-core-winrt-l1-1-0 0x60920000 ) +add_apiset(api-ms-win-core-winrt-registration-l1-1-0 0x60930000 ) +add_apiset(api-ms-win-core-winrt-roparameterizediid-l1-1-0 0x60940000 ) +add_apiset(api-ms-win-core-winrt-string-l1-1-0 0x60950000 ) +add_apiset(api-ms-win-core-wow64-l1-1-0 0x60970000 ) +add_apiset(api-ms-win-core-wow64-l1-1-1 0x60980000 ) +add_apiset(api-ms-win-core-xstate-l1-1-0 0x60990000 ) +add_apiset(api-ms-win-core-xstate-l2-1-0 0x609a0000 ) +add_apiset(api-ms-win-crt-conio-l1-1-0 0x609b0000 msvcrt) +add_apiset(api-ms-win-crt-convert-l1-1-0 0x609d0000 msvcrt) +add_apiset(api-ms-win-crt-environment-l1-1-0 0x60a30000 msvcrt) +add_apiset(api-ms-win-crt-filesystem-l1-1-0 0x60a40000 msvcrt) +add_apiset(api-ms-win-crt-heap-l1-1-0 0x60a70000 msvcrt) +add_apiset(api-ms-win-crt-locale-l1-1-0 0x60a80000 msvcrt) +add_apiset(api-ms-win-crt-math-l1-1-0 0x60a90000 msvcrt) +add_apiset(api-ms-win-crt-multibyte-l1-1-0 0x60ba0000 msvcrt) +add_apiset(api-ms-win-crt-private-l1-1-0 0x60c20000 msvcrt) +add_apiset(api-ms-win-crt-process-l1-1-0 0x61090000 msvcrt) +add_apiset(api-ms-win-crt-runtime-l1-1-0 0x610a0000 msvcrt) +add_apiset(api-ms-win-crt-stdio-l1-1-0 0x610e0000 msvcrt) +add_apiset(api-ms-win-crt-string-l1-1-0 0x61130000 msvcrt) +add_apiset(api-ms-win-crt-time-l1-1-0 0x61190000 msvcrt) +add_apiset(api-ms-win-crt-utility-l1-1-0 0x611c0000 msvcrt) +add_apiset(api-ms-win-devices-config-l1-1-1 0x611d0000 setupapi) +add_apiset(api-ms-win-devices-query-l1-1-1 0x611e0000 ) +add_apiset(api-ms-win-downlevel-advapi32-l1-1-0 0x611f0000 advapi32 advapi32_vista) +add_apiset(api-ms-win-downlevel-advapi32-l2-1-0 0x61210000 advapi32) +add_apiset(api-ms-win-downlevel-normaliz-l1-1-0 0x61220000 ) +add_apiset(api-ms-win-downlevel-ole32-l1-1-0 0x61230000 ole32) +add_apiset(api-ms-win-downlevel-shell32-l1-1-0 0x61240000 shell32) +add_apiset(api-ms-win-downlevel-shlwapi-l1-1-0 0x61250000 shlwapi) +add_apiset(api-ms-win-downlevel-shlwapi-l2-1-0 0x61260000 shlwapi) +add_apiset(api-ms-win-downlevel-user32-l1-1-0 0x61270000 user32) +add_apiset(api-ms-win-downlevel-version-l1-1-0 0x61280000 version) +add_apiset(api-ms-win-dx-d3dkmt-l1-1-0 0x61290000 gdi32) +add_apiset(api-ms-win-eventing-classicprovider-l1-1-0 0x612f0000 advapi32) +add_apiset(api-ms-win-eventing-consumer-l1-1-0 0x61300000 advapi32) +add_apiset(api-ms-win-eventing-controller-l1-1-0 0x61310000 advapi32) +add_apiset(api-ms-win-eventing-legacy-l1-1-0 0x61320000 advapi32) +add_apiset(api-ms-win-eventing-provider-l1-1-0 0x61330000 ) +add_apiset(api-ms-win-eventlog-legacy-l1-1-0 0x61340000 advapi32) +add_apiset(api-ms-win-gdi-dpiinfo-l1-1-0 0x61350000 ) +add_apiset(api-ms-win-mm-joystick-l1-1-0 0x61360000 winmm) +add_apiset(api-ms-win-mm-misc-l1-1-1 0x61370000 winmm) +add_apiset(api-ms-win-mm-mme-l1-1-0 0x61380000 winmm) +add_apiset(api-ms-win-mm-time-l1-1-0 0x61390000 winmm) +add_apiset(api-ms-win-ntuser-dc-access-l1-1-0 0x613a0000 user32) +add_apiset(api-ms-win-ntuser-rectangle-l1-1-0 0x613b0000 user32) +add_apiset(api-ms-win-perf-legacy-l1-1-0 0x613c0000 ) +add_apiset(api-ms-win-power-base-l1-1-0 0x613d0000 powrprof) +add_apiset(api-ms-win-power-setting-l1-1-0 0x613e0000 powrprof) +add_apiset(api-ms-win-rtcore-ntuser-draw-l1-1-0 0x613f0000 user32) +add_apiset(api-ms-win-rtcore-ntuser-private-l1-1-0 0x61400000 user32) +add_apiset(api-ms-win-rtcore-ntuser-private-l1-1-4 0x61410000 ) +add_apiset(api-ms-win-rtcore-ntuser-window-l1-1-0 0x61420000 user32) +add_apiset(api-ms-win-rtcore-ntuser-winevent-l1-1-0 0x61430000 user32) +add_apiset(api-ms-win-rtcore-ntuser-wmpointer-l1-1-0 0x61440000 ) +add_apiset(api-ms-win-rtcore-ntuser-wmpointer-l1-1-3 0x61460000 ) +add_apiset(api-ms-win-security-activedirectoryclient-l1-1-0 0x61470000 ntdsapi) +add_apiset(api-ms-win-security-audit-l1-1-1 0x61480000 ) +add_apiset(api-ms-win-security-base-l1-1-0 0x61490000 advapi32) +add_apiset(api-ms-win-security-base-l1-2-0 0x614a0000 advapi32) +add_apiset(api-ms-win-security-base-private-l1-1-1 0x614b0000 advapi32) +add_apiset(api-ms-win-security-credentials-l1-1-0 0x614c0000 advapi32) +add_apiset(api-ms-win-security-grouppolicy-l1-1-0 0x614d0000 userenv) +add_apiset(api-ms-win-security-lsalookup-l1-1-0 0x614f0000 ) +add_apiset(api-ms-win-security-lsalookup-l1-1-1 0x61500000 ) +add_apiset(api-ms-win-security-lsalookup-l2-1-0 0x61510000 advapi32) +add_apiset(api-ms-win-security-lsalookup-l2-1-1 0x61520000 advapi32) +add_apiset(api-ms-win-security-lsapolicy-l1-1-0 0x61530000 advapi32) +add_apiset(api-ms-win-security-provider-l1-1-0 0x61540000 advapi32) +add_apiset(api-ms-win-security-sddl-l1-1-0 0x61550000 advapi32) +add_apiset(api-ms-win-security-systemfunctions-l1-1-0 0x61560000 advapi32) +add_apiset(api-ms-win-service-core-l1-1-0 0x61570000 advapi32) +add_apiset(api-ms-win-service-core-l1-1-1 0x61580000 advapi32) +add_apiset(api-ms-win-service-management-l1-1-0 0x61590000 advapi32) +add_apiset(api-ms-win-service-management-l2-1-0 0x615a0000 advapi32) +add_apiset(api-ms-win-service-private-l1-1-1 0x615b0000 advapi32) +add_apiset(api-ms-win-service-winsvc-l1-1-0 0x615c0000 advapi32) +add_apiset(api-ms-win-service-winsvc-l1-2-0 0x615d0000 advapi32) +add_apiset(api-ms-win-shcore-obsolete-l1-1-0 0x615e0000 shlwapi shell32) +add_apiset(api-ms-win-shcore-scaling-l1-1-1 0x615f0000 ) +add_apiset(api-ms-win-shcore-stream-l1-1-0 0x61600000 shlwapi) +add_apiset(api-ms-win-shcore-thread-l1-1-0 0x61610000 shlwapi) +add_apiset(api-ms-win-shell-shellcom-l1-1-0 0x61620000 shell32) +add_apiset(api-ms-win-shell-shellfolders-l1-1-0 0x61630000 shell32) diff --git a/dll/apisets/api-ms-win-appmodel-identity-l1-1-0.spec b/dll/apisets/api-ms-win-appmodel-identity-l1-1-0.spec new file mode 100644 index 0000000000..a9c096a722 --- /dev/null +++ b/dll/apisets/api-ms-win-appmodel-identity-l1-1-0.spec @@ -0,0 +1,20 @@ + +# This file is autogenerated by update.py + +@ stub AppContainerDeriveSidFromMoniker +@ stub AppContainerFreeMemory +@ stub AppContainerLookupDisplayNameMrtReference +@ stub AppContainerLookupMoniker +@ stub AppContainerRegisterSid +@ stub AppContainerUnregisterSid +@ stub AppXFreeMemory +@ stub AppXGetApplicationData +@ stub AppXGetDevelopmentMode +@ stub AppXGetOSMaxVersionTested +@ stub AppXGetOSMinVersion +@ stub AppXGetPackageCapabilities +@ stub AppXGetPackageSid +@ stub AppXGetPackageState +@ stub AppXLookupDisplayName +@ stub AppXLookupMoniker +@ stub AppXSetPackageState diff --git a/dll/apisets/api-ms-win-appmodel-runtime-l1-1-1.spec b/dll/apisets/api-ms-win-appmodel-runtime-l1-1-1.spec new file mode 100644 index 0000000000..c814f9b98d --- /dev/null +++ b/dll/apisets/api-ms-win-appmodel-runtime-l1-1-1.spec @@ -0,0 +1,30 @@ + +# This file is autogenerated by update.py + +@ stub ClosePackageInfo +@ stub FindPackagesByPackageFamily +@ stub FormatApplicationUserModelId +@ stub GetApplicationUserModelId +@ stub GetCurrentApplicationUserModelId +@ stub GetCurrentPackageFamilyName +@ stub GetCurrentPackageFullName +@ stub GetCurrentPackageId +@ stub GetCurrentPackageInfo +@ stub GetCurrentPackagePath +@ stub GetPackageApplicationIds +@ stub GetPackageFamilyName +@ stub GetPackageFullName +@ stub GetPackageId +@ stub GetPackageInfo +@ stub GetPackagePath +@ stub GetPackagePathByFullName +@ stub GetPackagesByPackageFamily +@ stub GetStagedPackageOrigin +@ stub GetStagedPackagePathByFullName +@ stub OpenPackageInfoByFullName +@ stub PackageFamilyNameFromFullName +@ stub PackageFamilyNameFromId +@ stub PackageFullNameFromId +@ stub PackageIdFromFullName +@ stub PackageNameAndPublisherIdFromFamilyName +@ stub ParseApplicationUserModelId diff --git a/dll/apisets/api-ms-win-appmodel-runtime-l1-1-2.spec b/dll/apisets/api-ms-win-appmodel-runtime-l1-1-2.spec new file mode 100644 index 0000000000..b5699a9add --- /dev/null +++ b/dll/apisets/api-ms-win-appmodel-runtime-l1-1-2.spec @@ -0,0 +1,20 @@ + +# This file is autogenerated by update.py + +@ stub AppPolicyGetClrCompat +@ stub AppPolicyGetCreateFileAccess +@ stub AppPolicyGetLifecycleManagement +@ stub AppPolicyGetMediaFoundationCodecLoading +@ stub AppPolicyGetProcessTerminationMethod +@ stub AppPolicyGetShowDeveloperDiagnostic +@ stub AppPolicyGetThreadInitializationType +@ stub AppPolicyGetWindowingModel +@ stub GetApplicationUserModelIdFromToken +@ stub GetPackageFamilyNameFromToken +@ stub GetPackageFullNameFromToken +@ stub OpenPackageInfoByFullNameForUser +@ stub VerifyApplicationUserModelId +@ stub VerifyPackageFamilyName +@ stub VerifyPackageFullName +@ stub VerifyPackageId +@ stub VerifyPackageRelativeApplicationId diff --git a/dll/apisets/api-ms-win-core-apiquery-l1-1-0.spec b/dll/apisets/api-ms-win-core-apiquery-l1-1-0.spec new file mode 100644 index 0000000000..712d3a4569 --- /dev/null +++ b/dll/apisets/api-ms-win-core-apiquery-l1-1-0.spec @@ -0,0 +1,4 @@ + +# This file is autogenerated by update.py + +@ stub ApiSetQueryApiSetPresence diff --git a/dll/apisets/api-ms-win-core-appcompat-l1-1-1.spec b/dll/apisets/api-ms-win-core-appcompat-l1-1-1.spec new file mode 100644 index 0000000000..60349e169a --- /dev/null +++ b/dll/apisets/api-ms-win-core-appcompat-l1-1-1.spec @@ -0,0 +1,13 @@ + +# This file is autogenerated by update.py + +@ stdcall BaseCheckAppcompatCache() kernel32.BaseCheckAppcompatCache +@ stub BaseCheckAppcompatCacheEx +@ stdcall BaseCleanupAppcompatCacheSupport() kernel32.BaseCleanupAppcompatCacheSupport +@ stdcall BaseDumpAppcompatCache() kernel32.BaseDumpAppcompatCache +@ stdcall BaseFlushAppcompatCache() kernel32.BaseFlushAppcompatCache +@ stub BaseFreeAppCompatDataForProcess +@ stdcall BaseInitAppcompatCacheSupport() kernel32.BaseInitAppcompatCacheSupport +@ stdcall BaseIsAppcompatInfrastructureDisabled() kernel32.BaseIsAppcompatInfrastructureDisabled +@ stub BaseReadAppCompatDataForProcess +@ stdcall BaseUpdateAppcompatCache() kernel32.BaseUpdateAppcompatCache diff --git a/dll/apisets/api-ms-win-core-appinit-l1-1-0.spec b/dll/apisets/api-ms-win-core-appinit-l1-1-0.spec new file mode 100644 index 0000000000..7083e2fd97 --- /dev/null +++ b/dll/apisets/api-ms-win-core-appinit-l1-1-0.spec @@ -0,0 +1,4 @@ + +# This file is autogenerated by update.py + +@ stub LoadAppInitDlls diff --git a/dll/apisets/api-ms-win-core-atoms-l1-1-0.spec b/dll/apisets/api-ms-win-core-atoms-l1-1-0.spec new file mode 100644 index 0000000000..7ce1b9b45a --- /dev/null +++ b/dll/apisets/api-ms-win-core-atoms-l1-1-0.spec @@ -0,0 +1,20 @@ + +# This file is autogenerated by update.py + +@ stdcall AddAtomA() kernel32.AddAtomA +@ stdcall AddAtomW() kernel32.AddAtomW +@ stdcall DeleteAtom() kernel32.DeleteAtom +@ stdcall FindAtomA() kernel32.FindAtomA +@ stdcall FindAtomW() kernel32.FindAtomW +@ stdcall GetAtomNameA() kernel32.GetAtomNameA +@ stdcall GetAtomNameW() kernel32.GetAtomNameW +@ stdcall GlobalAddAtomA() kernel32.GlobalAddAtomA +@ stub GlobalAddAtomExA +@ stub GlobalAddAtomExW +@ stdcall GlobalAddAtomW() kernel32.GlobalAddAtomW +@ stdcall GlobalDeleteAtom() kernel32.GlobalDeleteAtom +@ stdcall GlobalFindAtomA() kernel32.GlobalFindAtomA +@ stdcall GlobalFindAtomW() kernel32.GlobalFindAtomW +@ stdcall GlobalGetAtomNameA() kernel32.GlobalGetAtomNameA +@ stdcall GlobalGetAtomNameW() kernel32.GlobalGetAtomNameW +@ stdcall InitAtomTable() kernel32.InitAtomTable diff --git a/dll/apisets/api-ms-win-core-bem-l1-1-0.spec b/dll/apisets/api-ms-win-core-bem-l1-1-0.spec new file mode 100644 index 0000000000..e165ae3643 --- /dev/null +++ b/dll/apisets/api-ms-win-core-bem-l1-1-0.spec @@ -0,0 +1,8 @@ + +# This file is autogenerated by update.py + +@ stub BemCopyReference +@ stub BemCreateContractFrom +@ stub BemCreateReference +@ stub BemFreeContract +@ stub BemFreeReference diff --git a/dll/apisets/api-ms-win-core-com-l1-1-0.spec b/dll/apisets/api-ms-win-core-com-l1-1-0.spec new file mode 100644 index 0000000000..8e20346a07 --- /dev/null +++ b/dll/apisets/api-ms-win-core-com-l1-1-0.spec @@ -0,0 +1,83 @@ + +# This file is autogenerated by update.py + +@ stdcall CLSIDFromProgID() ole32.CLSIDFromProgID +@ stdcall CLSIDFromString() ole32.CLSIDFromString +@ stdcall CoAddRefServerProcess() ole32.CoAddRefServerProcess +@ stub CoAllowUnmarshalerCLSID +@ stdcall CoCancelCall() ole32.CoCancelCall +@ stdcall CoCopyProxy() ole32.CoCopyProxy +@ stdcall CoCreateFreeThreadedMarshaler() ole32.CoCreateFreeThreadedMarshaler +@ stdcall CoCreateGuid() ole32.CoCreateGuid +@ stdcall CoCreateInstance() ole32.CoCreateInstance +@ stdcall CoCreateInstanceEx() ole32.CoCreateInstanceEx +@ stub CoCreateInstanceFromApp +@ stub CoDecodeProxy +@ stub CoDecrementMTAUsage +@ stdcall CoDisableCallCancellation() ole32.CoDisableCallCancellation +@ stub CoDisconnectContext +@ stdcall CoDisconnectObject() ole32.CoDisconnectObject +@ stdcall CoEnableCallCancellation() ole32.CoEnableCallCancellation +@ stdcall CoFreeUnusedLibraries() ole32.CoFreeUnusedLibraries +@ stdcall CoFreeUnusedLibrariesEx() ole32.CoFreeUnusedLibrariesEx +@ stub CoGetApartmentType +@ stdcall CoGetCallContext() ole32.CoGetCallContext +@ stdcall CoGetCallerTID() ole32.CoGetCallerTID +@ stdcall CoGetCancelObject() ole32.CoGetCancelObject +@ stdcall CoGetClassObject() ole32.CoGetClassObject +@ stdcall CoGetContextToken() ole32.CoGetContextToken +@ stdcall CoGetCurrentLogicalThreadId() ole32.CoGetCurrentLogicalThreadId +@ stdcall CoGetCurrentProcess() ole32.CoGetCurrentProcess +@ stdcall CoGetDefaultContext() ole32.CoGetDefaultContext +@ stdcall CoGetInterfaceAndReleaseStream() ole32.CoGetInterfaceAndReleaseStream +@ stdcall CoGetMalloc() ole32.CoGetMalloc +@ stdcall CoGetMarshalSizeMax() ole32.CoGetMarshalSizeMax +@ stdcall CoGetObjectContext() ole32.CoGetObjectContext +@ stdcall CoGetPSClsid() ole32.CoGetPSClsid +@ stdcall CoGetStandardMarshal() ole32.CoGetStandardMarshal +@ stdcall CoGetStdMarshalEx() ole32.CoGetStdMarshalEx +@ stdcall CoGetTreatAsClass() ole32.CoGetTreatAsClass +@ stdcall CoImpersonateClient() ole32.CoImpersonateClient +@ stub CoIncrementMTAUsage +@ stdcall CoInitializeEx() ole32.CoInitializeEx +@ stdcall CoInitializeSecurity() ole32.CoInitializeSecurity +@ stub CoInvalidateRemoteMachineBindings +@ stdcall CoIsHandlerConnected() ole32.CoIsHandlerConnected +@ stdcall CoLockObjectExternal() ole32.CoLockObjectExternal +@ stdcall CoMarshalHresult() ole32.CoMarshalHresult +@ stdcall CoMarshalInterThreadInterfaceInStream() ole32.CoMarshalInterThreadInterfaceInStream +@ stdcall CoMarshalInterface() ole32.CoMarshalInterface +@ stdcall CoQueryAuthenticationServices() ole32.CoQueryAuthenticationServices +@ stdcall CoQueryClientBlanket() ole32.CoQueryClientBlanket +@ stdcall CoQueryProxyBlanket() ole32.CoQueryProxyBlanket +@ stdcall CoRegisterClassObject() ole32.CoRegisterClassObject +@ stdcall CoRegisterPSClsid() ole32.CoRegisterPSClsid +@ stdcall CoRegisterSurrogate() ole32.CoRegisterSurrogate +@ stdcall CoReleaseMarshalData() ole32.CoReleaseMarshalData +@ stdcall CoReleaseServerProcess() ole32.CoReleaseServerProcess +@ stdcall CoResumeClassObjects() ole32.CoResumeClassObjects +@ stdcall CoRevertToSelf() ole32.CoRevertToSelf +@ stdcall CoRevokeClassObject() ole32.CoRevokeClassObject +@ stub CoSetCancelObject +@ stdcall CoSetProxyBlanket() ole32.CoSetProxyBlanket +@ stdcall CoSuspendClassObjects() ole32.CoSuspendClassObjects +@ stdcall CoSwitchCallContext() ole32.CoSwitchCallContext +@ stdcall CoTaskMemAlloc() ole32.CoTaskMemAlloc +@ stdcall CoTaskMemFree() ole32.CoTaskMemFree +@ stdcall CoTaskMemRealloc() ole32.CoTaskMemRealloc +@ stub CoTestCancel +@ stdcall CoUninitialize() ole32.CoUninitialize +@ stdcall CoUnmarshalHresult() ole32.CoUnmarshalHresult +@ stdcall CoUnmarshalInterface() ole32.CoUnmarshalInterface +@ stdcall CoWaitForMultipleHandles() ole32.CoWaitForMultipleHandles +@ stub CoWaitForMultipleObjects +@ stdcall CreateStreamOnHGlobal() ole32.CreateStreamOnHGlobal +@ stdcall FreePropVariantArray() ole32.FreePropVariantArray +@ stdcall GetHGlobalFromStream() ole32.GetHGlobalFromStream +@ stdcall IIDFromString() ole32.IIDFromString +@ stdcall ProgIDFromCLSID() ole32.ProgIDFromCLSID +@ stdcall PropVariantClear() ole32.PropVariantClear +@ stdcall PropVariantCopy() ole32.PropVariantCopy +@ stdcall StringFromCLSID() ole32.StringFromCLSID +@ stdcall StringFromGUID2() ole32.StringFromGUID2 +@ stdcall StringFromIID() ole32.StringFromIID diff --git a/dll/apisets/api-ms-win-core-com-l1-1-1.spec b/dll/apisets/api-ms-win-core-com-l1-1-1.spec new file mode 100644 index 0000000000..db415e1b3a --- /dev/null +++ b/dll/apisets/api-ms-win-core-com-l1-1-1.spec @@ -0,0 +1,85 @@ + +# This file is autogenerated by update.py + +@ stdcall CLSIDFromProgID() ole32.CLSIDFromProgID +@ stdcall CLSIDFromString() ole32.CLSIDFromString +@ stdcall CoAddRefServerProcess() ole32.CoAddRefServerProcess +@ stub CoAllowUnmarshalerCLSID +@ stdcall CoCancelCall() ole32.CoCancelCall +@ stdcall CoCopyProxy() ole32.CoCopyProxy +@ stdcall CoCreateFreeThreadedMarshaler() ole32.CoCreateFreeThreadedMarshaler +@ stdcall CoCreateGuid() ole32.CoCreateGuid +@ stdcall CoCreateInstance() ole32.CoCreateInstance +@ stdcall CoCreateInstanceEx() ole32.CoCreateInstanceEx +@ stub CoCreateInstanceFromApp +@ stub CoDecodeProxy +@ stub CoDecrementMTAUsage +@ stdcall CoDisableCallCancellation() ole32.CoDisableCallCancellation +@ stub CoDisconnectContext +@ stdcall CoDisconnectObject() ole32.CoDisconnectObject +@ stdcall CoEnableCallCancellation() ole32.CoEnableCallCancellation +@ stdcall CoFreeUnusedLibraries() ole32.CoFreeUnusedLibraries +@ stdcall CoFreeUnusedLibrariesEx() ole32.CoFreeUnusedLibrariesEx +@ stub CoGetApartmentType +@ stdcall CoGetCallContext() ole32.CoGetCallContext +@ stdcall CoGetCallerTID() ole32.CoGetCallerTID +@ stdcall CoGetCancelObject() ole32.CoGetCancelObject +@ stdcall CoGetClassObject() ole32.CoGetClassObject +@ stdcall CoGetContextToken() ole32.CoGetContextToken +@ stdcall CoGetCurrentLogicalThreadId() ole32.CoGetCurrentLogicalThreadId +@ stdcall CoGetCurrentProcess() ole32.CoGetCurrentProcess +@ stdcall CoGetDefaultContext() ole32.CoGetDefaultContext +@ stdcall CoGetInterfaceAndReleaseStream() ole32.CoGetInterfaceAndReleaseStream +@ stdcall CoGetMalloc() ole32.CoGetMalloc +@ stdcall CoGetMarshalSizeMax() ole32.CoGetMarshalSizeMax +@ stdcall CoGetObjectContext() ole32.CoGetObjectContext +@ stdcall CoGetPSClsid() ole32.CoGetPSClsid +@ stdcall CoGetStandardMarshal() ole32.CoGetStandardMarshal +@ stdcall CoGetStdMarshalEx() ole32.CoGetStdMarshalEx +@ stdcall CoGetTreatAsClass() ole32.CoGetTreatAsClass +@ stdcall CoImpersonateClient() ole32.CoImpersonateClient +@ stub CoIncrementMTAUsage +@ stdcall CoInitializeEx() ole32.CoInitializeEx +@ stdcall CoInitializeSecurity() ole32.CoInitializeSecurity +@ stub CoInvalidateRemoteMachineBindings +@ stdcall CoIsHandlerConnected() ole32.CoIsHandlerConnected +@ stdcall CoLockObjectExternal() ole32.CoLockObjectExternal +@ stdcall CoMarshalHresult() ole32.CoMarshalHresult +@ stdcall CoMarshalInterThreadInterfaceInStream() ole32.CoMarshalInterThreadInterfaceInStream +@ stdcall CoMarshalInterface() ole32.CoMarshalInterface +@ stdcall CoQueryAuthenticationServices() ole32.CoQueryAuthenticationServices +@ stdcall CoQueryClientBlanket() ole32.CoQueryClientBlanket +@ stdcall CoQueryProxyBlanket() ole32.CoQueryProxyBlanket +@ stub CoRegisterActivationFilter +@ stdcall CoRegisterClassObject() ole32.CoRegisterClassObject +@ stdcall CoRegisterPSClsid() ole32.CoRegisterPSClsid +@ stdcall CoRegisterSurrogate() ole32.CoRegisterSurrogate +@ stdcall CoReleaseMarshalData() ole32.CoReleaseMarshalData +@ stdcall CoReleaseServerProcess() ole32.CoReleaseServerProcess +@ stdcall CoResumeClassObjects() ole32.CoResumeClassObjects +@ stdcall CoRevertToSelf() ole32.CoRevertToSelf +@ stdcall CoRevokeClassObject() ole32.CoRevokeClassObject +@ stub CoSetCancelObject +@ stdcall CoSetProxyBlanket() ole32.CoSetProxyBlanket +@ stdcall CoSuspendClassObjects() ole32.CoSuspendClassObjects +@ stdcall CoSwitchCallContext() ole32.CoSwitchCallContext +@ stdcall CoTaskMemAlloc() ole32.CoTaskMemAlloc +@ stdcall CoTaskMemFree() ole32.CoTaskMemFree +@ stdcall CoTaskMemRealloc() ole32.CoTaskMemRealloc +@ stub CoTestCancel +@ stdcall CoUninitialize() ole32.CoUninitialize +@ stdcall CoUnmarshalHresult() ole32.CoUnmarshalHresult +@ stdcall CoUnmarshalInterface() ole32.CoUnmarshalInterface +@ stdcall CoWaitForMultipleHandles() ole32.CoWaitForMultipleHandles +@ stub CoWaitForMultipleObjects +@ stdcall CreateStreamOnHGlobal() ole32.CreateStreamOnHGlobal +@ stdcall FreePropVariantArray() ole32.FreePropVariantArray +@ stdcall GetHGlobalFromStream() ole32.GetHGlobalFromStream +@ stdcall IIDFromString() ole32.IIDFromString +@ stdcall ProgIDFromCLSID() ole32.ProgIDFromCLSID +@ stdcall PropVariantClear() ole32.PropVariantClear +@ stdcall PropVariantCopy() ole32.PropVariantCopy +@ stub RoGetAgileReference +@ stdcall StringFromCLSID() ole32.StringFromCLSID +@ stdcall StringFromGUID2() ole32.StringFromGUID2 +@ stdcall StringFromIID() ole32.StringFromIID diff --git a/dll/apisets/api-ms-win-core-com-private-l1-1-0.spec b/dll/apisets/api-ms-win-core-com-private-l1-1-0.spec new file mode 100644 index 0000000000..8845ce8acb --- /dev/null +++ b/dll/apisets/api-ms-win-core-com-private-l1-1-0.spec @@ -0,0 +1,94 @@ + +# This file is autogenerated by update.py + +@ stub CLSIDFromOle1Class +@ stub CleanupOleStateInAllTls +@ stub CleanupTlsOleState +@ stub ClearCleanupFlag +@ stub CoCreateErrorInfo +@ stub CoCreateObjectInContext +@ stub CoDeactivateObject +@ stub CoGetActivationState +@ stub CoGetApartmentID +@ stub CoGetCallState +@ stub CoGetClassVersion +@ stub CoGetErrorInfo +@ stdcall CoGetInstanceFromFile() ole32.CoGetInstanceFromFile +@ stdcall CoGetInstanceFromIStorage() ole32.CoGetInstanceFromIStorage +@ stub CoGetModuleType +@ stub CoGetProcessIdentifier +@ stub CoGetSystemSecurityPermissions +@ stdcall CoInitializeWOW() ole32.CoInitializeWOW +@ stub CoPopServiceDomain +@ stub CoPushServiceDomain +@ stub CoReactivateObject +@ stdcall CoRegisterInitializeSpy() ole32.CoRegisterInitializeSpy +@ stdcall CoRegisterMallocSpy() ole32.CoRegisterMallocSpy +@ stdcall CoRegisterMessageFilter() ole32.CoRegisterMessageFilter +@ stdcall CoRegisterSurrogateEx() ole32.CoRegisterSurrogateEx +@ stub CoRetireServer +@ stdcall CoRevokeInitializeSpy() ole32.CoRevokeInitializeSpy +@ stdcall CoRevokeMallocSpy() ole32.CoRevokeMallocSpy +@ stub CoSetErrorInfo +@ stdcall CoUnloadingWOW() ole32.CoUnloadingWOW +@ stub CoVrfCheckThreadState +@ stub CoVrfGetThreadState +@ stub CoVrfReleaseThreadState +@ stdcall DllDebugObjectRPCHook() ole32.DllDebugObjectRPCHook +@ stdcall EnableHookObject() ole32.EnableHookObject +@ stub FreePropVariantArrayWorker +@ stub GetCatalogHelper +@ stub GetFuncDescs +@ stdcall GetHookInterface() ole32.GetHookInterface +@ stub HkOleRegisterObject +@ stub InternalAppInvokeExceptionFilter +@ stub InternalCCFreeUnused +@ stub InternalCCGetClassInformationForDde +@ stub InternalCCGetClassInformationFromKey +@ stub InternalCCSetDdeServerWindow +@ stub InternalCMLSendReceive +@ stub InternalCallAsProxyExceptionFilter +@ stub InternalCallFrameExceptionFilter +@ stub InternalCallerIsAppContainer +@ stub InternalCanMakeOutCall +@ stub InternalCoIsSurrogateProcess +@ stub InternalCoRegisterDisconnectCallback +@ stub InternalCoRegisterSurrogatedObject +@ stub InternalCoStdMarshalObject +@ stub InternalCoUnregisterDisconnectCallback +@ stub InternalCompleteObjRef +@ stub InternalCreateCAggId +@ stub InternalCreateIdentityHandler +@ stub InternalDoATClassCreate +@ stub InternalFillLocalOXIDInfo +@ stub InternalFreeObjRef +@ stub InternalGetWindowPropInterface +@ stub InternalIrotEnumRunning +@ stub InternalIrotGetObject +@ stub InternalIrotGetTimeOfLastChange +@ stub InternalIrotIsRunning +@ stub InternalIrotNoteChangeTime +@ stub InternalIrotRegister +@ stub InternalIrotRevoke +@ stub InternalIsApartmentInitialized +@ stub InternalIsProcessInitialized +@ stub InternalMarshalObjRef +@ stub InternalNotifyDDStartOrStop +@ stub InternalOleModalLoopBlockFn +@ stub InternalRegisterWindowPropInterface +@ stub InternalReleaseMarshalObjRef +@ stub InternalSTAInvoke +@ stub InternalServerExceptionFilter +@ stub InternalSetAptCallCtrlOnTlsIfRequired +@ stub InternalSetOleThunkWowPtr +@ stub InternalStubInvoke +@ stub InternalTlsAllocData +@ stub InternalUnmarshalObjRef +@ stub NdrExtStubInitialize +@ stub NdrOleDllGetClassObject +@ stub NdrOleInitializeExtension +@ stub NdrpFindInterface +@ stub ReleaseFuncDescs +@ stub SetCleanupFlag +@ stdcall UpdateDCOMSettings() ole32.UpdateDCOMSettings +@ stub UpdateProcessTracing diff --git a/dll/apisets/api-ms-win-core-console-l1-1-0.spec b/dll/apisets/api-ms-win-core-console-l1-1-0.spec new file mode 100644 index 0000000000..b0ef6ebd9e --- /dev/null +++ b/dll/apisets/api-ms-win-core-console-l1-1-0.spec @@ -0,0 +1,17 @@ + +# This file is autogenerated by update.py + +@ stdcall AllocConsole() kernel32.AllocConsole +@ stdcall GetConsoleCP() kernel32.GetConsoleCP +@ stdcall GetConsoleMode() kernel32.GetConsoleMode +@ stdcall GetConsoleOutputCP() kernel32.GetConsoleOutputCP +@ stdcall GetNumberOfConsoleInputEvents() kernel32.GetNumberOfConsoleInputEvents +@ stdcall PeekConsoleInputA() kernel32.PeekConsoleInputA +@ stdcall ReadConsoleA() kernel32.ReadConsoleA +@ stdcall ReadConsoleInputA() kernel32.ReadConsoleInputA +@ stdcall ReadConsoleInputW() kernel32.ReadConsoleInputW +@ stdcall ReadConsoleW() kernel32.ReadConsoleW +@ stdcall SetConsoleCtrlHandler() kernel32.SetConsoleCtrlHandler +@ stdcall SetConsoleMode() kernel32.SetConsoleMode +@ stdcall WriteConsoleA() kernel32.WriteConsoleA +@ stdcall WriteConsoleW() kernel32.WriteConsoleW diff --git a/dll/apisets/api-ms-win-core-console-l2-1-0.spec b/dll/apisets/api-ms-win-core-console-l2-1-0.spec new file mode 100644 index 0000000000..8e51ba51a5 --- /dev/null +++ b/dll/apisets/api-ms-win-core-console-l2-1-0.spec @@ -0,0 +1,41 @@ + +# This file is autogenerated by update.py + +@ stdcall AttachConsole() kernel32.AttachConsole +@ stdcall CreateConsoleScreenBuffer() kernel32.CreateConsoleScreenBuffer +@ stdcall FillConsoleOutputAttribute() kernel32.FillConsoleOutputAttribute +@ stdcall FillConsoleOutputCharacterA() kernel32.FillConsoleOutputCharacterA +@ stdcall FillConsoleOutputCharacterW() kernel32.FillConsoleOutputCharacterW +@ stdcall FlushConsoleInputBuffer() kernel32.FlushConsoleInputBuffer +@ stdcall FreeConsole() kernel32.FreeConsole +@ stdcall GenerateConsoleCtrlEvent() kernel32.GenerateConsoleCtrlEvent +@ stdcall GetConsoleCursorInfo() kernel32.GetConsoleCursorInfo +@ stdcall GetConsoleScreenBufferInfo() kernel32.GetConsoleScreenBufferInfo +@ stub GetConsoleScreenBufferInfoEx +@ stdcall GetConsoleTitleW() kernel32.GetConsoleTitleW +@ stdcall GetLargestConsoleWindowSize() kernel32.GetLargestConsoleWindowSize +@ stdcall PeekConsoleInputW() kernel32.PeekConsoleInputW +@ stdcall ReadConsoleOutputA() kernel32.ReadConsoleOutputA +@ stdcall ReadConsoleOutputAttribute() kernel32.ReadConsoleOutputAttribute +@ stdcall ReadConsoleOutputCharacterA() kernel32.ReadConsoleOutputCharacterA +@ stdcall ReadConsoleOutputCharacterW() kernel32.ReadConsoleOutputCharacterW +@ stdcall ReadConsoleOutputW() kernel32.ReadConsoleOutputW +@ stdcall ScrollConsoleScreenBufferA() kernel32.ScrollConsoleScreenBufferA +@ stdcall ScrollConsoleScreenBufferW() kernel32.ScrollConsoleScreenBufferW +@ stdcall SetConsoleActiveScreenBuffer() kernel32.SetConsoleActiveScreenBuffer +@ stdcall SetConsoleCP() kernel32.SetConsoleCP +@ stdcall SetConsoleCursorInfo() kernel32.SetConsoleCursorInfo +@ stdcall SetConsoleCursorPosition() kernel32.SetConsoleCursorPosition +@ stdcall SetConsoleOutputCP() kernel32.SetConsoleOutputCP +@ stub SetConsoleScreenBufferInfoEx +@ stdcall SetConsoleScreenBufferSize() kernel32.SetConsoleScreenBufferSize +@ stdcall SetConsoleTextAttribute() kernel32.SetConsoleTextAttribute +@ stdcall SetConsoleTitleW() kernel32.SetConsoleTitleW +@ stdcall SetConsoleWindowInfo() kernel32.SetConsoleWindowInfo +@ stdcall WriteConsoleInputA() kernel32.WriteConsoleInputA +@ stdcall WriteConsoleInputW() kernel32.WriteConsoleInputW +@ stdcall WriteConsoleOutputA() kernel32.WriteConsoleOutputA +@ stdcall WriteConsoleOutputAttribute() kernel32.WriteConsoleOutputAttribute +@ stdcall WriteConsoleOutputCharacterA() kernel32.WriteConsoleOutputCharacterA +@ stdcall WriteConsoleOutputCharacterW() kernel32.WriteConsoleOutputCharacterW +@ stdcall WriteConsoleOutputW() kernel32.WriteConsoleOutputW diff --git a/dll/apisets/api-ms-win-core-crt-l1-1-0.spec b/dll/apisets/api-ms-win-core-crt-l1-1-0.spec new file mode 100644 index 0000000000..5e7595c4fc --- /dev/null +++ b/dll/apisets/api-ms-win-core-crt-l1-1-0.spec @@ -0,0 +1,101 @@ + +# This file is autogenerated by update.py + +@ stdcall __isascii() msvcrt.__isascii +@ stdcall _atoi64() msvcrt._atoi64 +@ stdcall _errno() msvcrt._errno +@ stub _except_handler4_common +@ stdcall -arch=i386,x86_64,arm _fltused() ntdll._fltused +@ stdcall -arch=i386 _ftol() msvcrt._ftol +@ stub _ftol2 +@ stub _ftol2_sse +@ stub _i64tow_s +@ stub _itow_s +@ stub _local_unwind4 +@ stub _ltow_s +@ stub _snprintf_s +@ stub _snwprintf_s +@ stub _splitpath_s +@ stdcall _stricmp() msvcrt._stricmp +@ stub _strlwr_s +@ stdcall _strnicmp() msvcrt._strnicmp +@ stub _strupr_s +@ stub _ui64tow_s +@ stdcall _ultow() msvcrt._ultow +@ stub _ultow_s +@ stub _vsnprintf_s +@ stub _vsnwprintf_s +@ stdcall _wcsicmp() msvcrt._wcsicmp +@ stub _wcslwr_s +@ stdcall _wcsnicmp() msvcrt._wcsnicmp +@ stdcall _wcstoi64() msvcrt._wcstoi64 +@ stdcall _wcstoui64() msvcrt._wcstoui64 +@ stub _wcsupr_s +@ stub _wsplitpath_s +@ stdcall _wtoi() msvcrt._wtoi +@ stdcall _wtoi64() msvcrt._wtoi64 +@ stdcall _wtol() msvcrt._wtol +@ stdcall atoi() msvcrt.atoi +@ stdcall atol() msvcrt.atol +@ stdcall isalnum() msvcrt.isalnum +@ stdcall isdigit() msvcrt.isdigit +@ stdcall isgraph() msvcrt.isgraph +@ stdcall islower() msvcrt.islower +@ stdcall isprint() msvcrt.isprint +@ stdcall isspace() msvcrt.isspace +@ stdcall isupper() msvcrt.isupper +@ stdcall iswalnum() msvcrt.iswalnum +@ stdcall iswascii() msvcrt.iswascii +@ stdcall iswctype() msvcrt.iswctype +@ stdcall iswdigit() msvcrt.iswdigit +@ stdcall iswgraph() msvcrt.iswgraph +@ stdcall iswprint() msvcrt.iswprint +@ stdcall iswspace() msvcrt.iswspace +@ stdcall memcmp() msvcrt.memcmp +@ stdcall memcpy() msvcrt.memcpy +@ stub memcpy_s +@ stdcall memmove() msvcrt.memmove +@ stub memmove_s +@ stdcall memset() msvcrt.memset +@ stub qsort_s +@ stub sprintf_s +@ stub sscanf_s +@ stub strcat_s +@ stdcall strchr() msvcrt.strchr +@ stdcall strcmp() msvcrt.strcmp +@ stub strcpy_s +@ stdcall strcspn() msvcrt.strcspn +@ stdcall strlen() msvcrt.strlen +@ stub strncat_s +@ stdcall strncmp() msvcrt.strncmp +@ stub strncpy_s +@ stub strnlen +@ stdcall strpbrk() msvcrt.strpbrk +@ stdcall strrchr() msvcrt.strrchr +@ stdcall strstr() msvcrt.strstr +@ stub strtok_s +@ stdcall strtol() msvcrt.strtol +@ stdcall strtoul() msvcrt.strtoul +@ stub swprintf_s +@ stdcall tolower() msvcrt.tolower +@ stdcall toupper() msvcrt.toupper +@ stdcall towlower() msvcrt.towlower +@ stdcall towupper() msvcrt.towupper +@ stub vsprintf_s +@ stub vswprintf_s +@ stub wcscat_s +@ stdcall wcschr() msvcrt.wcschr +@ stdcall wcscmp() msvcrt.wcscmp +@ stub wcscpy_s +@ stdcall wcscspn() msvcrt.wcscspn +@ stdcall wcslen() msvcrt.wcslen +@ stub wcsncat_s +@ stdcall wcsncmp() msvcrt.wcsncmp +@ stub wcsncpy_s +@ stub wcsnlen +@ stdcall wcspbrk() msvcrt.wcspbrk +@ stdcall wcsrchr() msvcrt.wcsrchr +@ stdcall wcsstr() msvcrt.wcsstr +@ stub wcstok_s +@ stdcall wcstol() msvcrt.wcstol +@ stdcall wcstoul() msvcrt.wcstoul diff --git a/dll/apisets/api-ms-win-core-crt-l2-1-0.spec b/dll/apisets/api-ms-win-core-crt-l2-1-0.spec new file mode 100644 index 0000000000..68cf57de66 --- /dev/null +++ b/dll/apisets/api-ms-win-core-crt-l2-1-0.spec @@ -0,0 +1,22 @@ + +# This file is autogenerated by update.py + +@ stub __dllonexit3 +@ stdcall __wgetmainargs() msvcrt.__wgetmainargs +@ stdcall _amsg_exit() msvcrt._amsg_exit +@ stdcall _c_exit() msvcrt._c_exit +@ stdcall _cexit() msvcrt._cexit +@ stdcall _exit() msvcrt._exit +@ stdcall _initterm() msvcrt._initterm +@ stub _initterm_e +@ stub _invalid_parameter +@ stdcall _onexit() msvcrt._onexit +@ stdcall _purecall() msvcrt._purecall +@ stdcall _time64() msvcrt._time64 +@ extern -arch=arm64,i386,arm atexit msvcrt._imp__atexit +@ extern -arch=x86_64 atexit msvcrt.__imp_atexit +@ stdcall exit() msvcrt.exit +@ stub hgets +@ stub hwprintf +@ stdcall time() msvcrt.time +@ stdcall wprintf() msvcrt.wprintf diff --git a/dll/apisets/api-ms-win-core-datetime-l1-1-0.spec b/dll/apisets/api-ms-win-core-datetime-l1-1-0.spec new file mode 100644 index 0000000000..23f50d0a64 --- /dev/null +++ b/dll/apisets/api-ms-win-core-datetime-l1-1-0.spec @@ -0,0 +1,7 @@ + +# This file is autogenerated by update.py + +@ stdcall GetDateFormatA() kernel32.GetDateFormatA +@ stdcall GetDateFormatW() kernel32.GetDateFormatW +@ stdcall GetTimeFormatA() kernel32.GetTimeFormatA +@ stdcall GetTimeFormatW() kernel32.GetTimeFormatW diff --git a/dll/apisets/api-ms-win-core-datetime-l1-1-1.spec b/dll/apisets/api-ms-win-core-datetime-l1-1-1.spec new file mode 100644 index 0000000000..0d4d62cca6 --- /dev/null +++ b/dll/apisets/api-ms-win-core-datetime-l1-1-1.spec @@ -0,0 +1,9 @@ + +# This file is autogenerated by update.py + +@ stdcall GetDateFormatA() kernel32.GetDateFormatA +@ stub GetDateFormatEx +@ stdcall GetDateFormatW() kernel32.GetDateFormatW +@ stdcall GetTimeFormatA() kernel32.GetTimeFormatA +@ stub GetTimeFormatEx +@ stdcall GetTimeFormatW() kernel32.GetTimeFormatW diff --git a/dll/apisets/api-ms-win-core-debug-l1-1-0.spec b/dll/apisets/api-ms-win-core-debug-l1-1-0.spec new file mode 100644 index 0000000000..4067846543 --- /dev/null +++ b/dll/apisets/api-ms-win-core-debug-l1-1-0.spec @@ -0,0 +1,7 @@ + +# This file is autogenerated by update.py + +@ stdcall DebugBreak() kernel32.DebugBreak +@ stdcall IsDebuggerPresent() kernel32.IsDebuggerPresent +@ stdcall OutputDebugStringA() kernel32.OutputDebugStringA +@ stdcall OutputDebugStringW() kernel32.OutputDebugStringW diff --git a/dll/apisets/api-ms-win-core-debug-l1-1-1.spec b/dll/apisets/api-ms-win-core-debug-l1-1-1.spec new file mode 100644 index 0000000000..e7c216006d --- /dev/null +++ b/dll/apisets/api-ms-win-core-debug-l1-1-1.spec @@ -0,0 +1,12 @@ + +# This file is autogenerated by update.py + +@ stdcall CheckRemoteDebuggerPresent() kernel32.CheckRemoteDebuggerPresent +@ stdcall ContinueDebugEvent() kernel32.ContinueDebugEvent +@ stdcall DebugActiveProcess() kernel32.DebugActiveProcess +@ stdcall DebugActiveProcessStop() kernel32.DebugActiveProcessStop +@ stdcall DebugBreak() kernel32.DebugBreak +@ stdcall IsDebuggerPresent() kernel32.IsDebuggerPresent +@ stdcall OutputDebugStringA() kernel32.OutputDebugStringA +@ stdcall OutputDebugStringW() kernel32.OutputDebugStringW +@ stdcall WaitForDebugEvent() kernel32.WaitForDebugEvent diff --git a/dll/apisets/api-ms-win-core-delayload-l1-1-0.spec b/dll/apisets/api-ms-win-core-delayload-l1-1-0.spec new file mode 100644 index 0000000000..61d02c0c4f --- /dev/null +++ b/dll/apisets/api-ms-win-core-delayload-l1-1-0.spec @@ -0,0 +1,4 @@ + +# This file is autogenerated by update.py + +@ stdcall DelayLoadFailureHook() kernel32.DelayLoadFailureHook diff --git a/dll/apisets/api-ms-win-core-delayload-l1-1-1.spec b/dll/apisets/api-ms-win-core-delayload-l1-1-1.spec new file mode 100644 index 0000000000..70ea23420b --- /dev/null +++ b/dll/apisets/api-ms-win-core-delayload-l1-1-1.spec @@ -0,0 +1,6 @@ + +# This file is autogenerated by update.py + +@ stdcall DelayLoadFailureHook() kernel32.DelayLoadFailureHook +@ stub ResolveDelayLoadedAPI +@ stub ResolveDelayLoadsFromDll diff --git a/dll/apisets/api-ms-win-core-errorhandling-l1-1-0.spec b/dll/apisets/api-ms-win-core-errorhandling-l1-1-0.spec new file mode 100644 index 0000000000..c04a904d7e --- /dev/null +++ b/dll/apisets/api-ms-win-core-errorhandling-l1-1-0.spec @@ -0,0 +1,10 @@ + +# This file is autogenerated by update.py + +@ stub GetErrorMode +@ stdcall GetLastError() kernel32.GetLastError +@ stdcall RaiseException() kernel32.RaiseException +@ stdcall SetErrorMode() kernel32.SetErrorMode +@ stdcall SetLastError() kernel32.SetLastError +@ stdcall SetUnhandledExceptionFilter() kernel32.SetUnhandledExceptionFilter +@ stdcall UnhandledExceptionFilter() kernel32.UnhandledExceptionFilter diff --git a/dll/apisets/api-ms-win-core-errorhandling-l1-1-1.spec b/dll/apisets/api-ms-win-core-errorhandling-l1-1-1.spec new file mode 100644 index 0000000000..1025891a94 --- /dev/null +++ b/dll/apisets/api-ms-win-core-errorhandling-l1-1-1.spec @@ -0,0 +1,15 @@ + +# This file is autogenerated by update.py + +@ stdcall AddVectoredContinueHandler() kernel32.AddVectoredContinueHandler +@ stdcall AddVectoredExceptionHandler() kernel32.AddVectoredExceptionHandler +@ stub GetErrorMode +@ stdcall GetLastError() kernel32.GetLastError +@ stdcall RaiseException() kernel32.RaiseException +@ stdcall RemoveVectoredContinueHandler() kernel32.RemoveVectoredContinueHandler +@ stdcall RemoveVectoredExceptionHandler() kernel32.RemoveVectoredExceptionHandler +@ stdcall RestoreLastError() kernel32.RestoreLastError +@ stdcall SetErrorMode() kernel32.SetErrorMode +@ stdcall SetLastError() kernel32.SetLastError +@ stdcall SetUnhandledExceptionFilter() kernel32.SetUnhandledExceptionFilter +@ stdcall UnhandledExceptionFilter() kernel32.UnhandledExceptionFilter diff --git a/dll/apisets/api-ms-win-core-errorhandling-l1-1-2.spec b/dll/apisets/api-ms-win-core-errorhandling-l1-1-2.spec new file mode 100644 index 0000000000..42eed5ebe4 --- /dev/null +++ b/dll/apisets/api-ms-win-core-errorhandling-l1-1-2.spec @@ -0,0 +1,16 @@ + +# This file is autogenerated by update.py + +@ stdcall AddVectoredContinueHandler() kernel32.AddVectoredContinueHandler +@ stdcall AddVectoredExceptionHandler() kernel32.AddVectoredExceptionHandler +@ stub GetErrorMode +@ stdcall GetLastError() kernel32.GetLastError +@ stdcall RaiseException() kernel32.RaiseException +@ stub RaiseFailFastException +@ stdcall RemoveVectoredContinueHandler() kernel32.RemoveVectoredContinueHandler +@ stdcall RemoveVectoredExceptionHandler() kernel32.RemoveVectoredExceptionHandler +@ stdcall RestoreLastError() kernel32.RestoreLastError +@ stdcall SetErrorMode() kernel32.SetErrorMode +@ stdcall SetLastError() kernel32.SetLastError +@ stdcall SetUnhandledExceptionFilter() kernel32.SetUnhandledExceptionFilter +@ stdcall UnhandledExceptionFilter() kernel32.UnhandledExceptionFilter diff --git a/dll/apisets/api-ms-win-core-errorhandling-l1-1-3.spec b/dll/apisets/api-ms-win-core-errorhandling-l1-1-3.spec new file mode 100644 index 0000000000..67d2a6e8c1 --- /dev/null +++ b/dll/apisets/api-ms-win-core-errorhandling-l1-1-3.spec @@ -0,0 +1,19 @@ + +# This file is autogenerated by update.py + +@ stdcall AddVectoredContinueHandler() kernel32.AddVectoredContinueHandler +@ stdcall AddVectoredExceptionHandler() kernel32.AddVectoredExceptionHandler +@ stdcall FatalAppExitA() kernel32.FatalAppExitA +@ stdcall FatalAppExitW() kernel32.FatalAppExitW +@ stub GetErrorMode +@ stdcall GetLastError() kernel32.GetLastError +@ stub GetThreadErrorMode +@ stdcall RaiseException() kernel32.RaiseException +@ stub RaiseFailFastException +@ stdcall RemoveVectoredContinueHandler() kernel32.RemoveVectoredContinueHandler +@ stdcall RemoveVectoredExceptionHandler() kernel32.RemoveVectoredExceptionHandler +@ stdcall SetErrorMode() kernel32.SetErrorMode +@ stdcall SetLastError() kernel32.SetLastError +@ stub SetThreadErrorMode +@ stdcall SetUnhandledExceptionFilter() kernel32.SetUnhandledExceptionFilter +@ stdcall UnhandledExceptionFilter() kernel32.UnhandledExceptionFilter diff --git a/dll/apisets/api-ms-win-core-fibers-l1-1-0.spec b/dll/apisets/api-ms-win-core-fibers-l1-1-0.spec new file mode 100644 index 0000000000..32edaf83d2 --- /dev/null +++ b/dll/apisets/api-ms-win-core-fibers-l1-1-0.spec @@ -0,0 +1,7 @@ + +# This file is autogenerated by update.py + +@ stub FlsAlloc +@ stub FlsFree +@ stub FlsGetValue +@ stub FlsSetValue diff --git a/dll/apisets/api-ms-win-core-fibers-l1-1-1.spec b/dll/apisets/api-ms-win-core-fibers-l1-1-1.spec new file mode 100644 index 0000000000..f29bdf3060 --- /dev/null +++ b/dll/apisets/api-ms-win-core-fibers-l1-1-1.spec @@ -0,0 +1,8 @@ + +# This file is autogenerated by update.py + +@ stub FlsAlloc +@ stub FlsFree +@ stub FlsGetValue +@ stub FlsSetValue +@ stub IsThreadAFiber diff --git a/dll/apisets/api-ms-win-core-file-l1-1-0.spec b/dll/apisets/api-ms-win-core-file-l1-1-0.spec new file mode 100644 index 0000000000..6471017a00 --- /dev/null +++ b/dll/apisets/api-ms-win-core-file-l1-1-0.spec @@ -0,0 +1,79 @@ + +# This file is autogenerated by update.py + +@ stdcall CompareFileTime() kernel32.CompareFileTime +@ stdcall CreateDirectoryA() kernel32.CreateDirectoryA +@ stdcall CreateDirectoryW() kernel32.CreateDirectoryW +@ stdcall CreateFileA() kernel32.CreateFileA +@ stdcall CreateFileW() kernel32.CreateFileW +@ stdcall DefineDosDeviceW() kernel32.DefineDosDeviceW +@ stdcall DeleteFileA() kernel32.DeleteFileA +@ stdcall DeleteFileW() kernel32.DeleteFileW +@ stdcall DeleteVolumeMountPointW() kernel32.DeleteVolumeMountPointW +@ stdcall FileTimeToLocalFileTime() kernel32.FileTimeToLocalFileTime +@ stdcall FileTimeToSystemTime() kernel32.FileTimeToSystemTime +@ stdcall FindClose() kernel32.FindClose +@ stdcall FindCloseChangeNotification() kernel32.FindCloseChangeNotification +@ stdcall FindFirstChangeNotificationA() kernel32.FindFirstChangeNotificationA +@ stdcall FindFirstChangeNotificationW() kernel32.FindFirstChangeNotificationW +@ stdcall FindFirstFileA() kernel32.FindFirstFileA +@ stdcall FindFirstFileExA() kernel32.FindFirstFileExA +@ stdcall FindFirstFileExW() kernel32.FindFirstFileExW +@ stdcall FindFirstFileW() kernel32.FindFirstFileW +@ stdcall FindFirstVolumeW() kernel32.FindFirstVolumeW +@ stdcall FindNextChangeNotification() kernel32.FindNextChangeNotification +@ stdcall FindNextFileA() kernel32.FindNextFileA +@ stdcall FindNextFileW() kernel32.FindNextFileW +@ stdcall FindNextVolumeW() kernel32.FindNextVolumeW +@ stdcall FindVolumeClose() kernel32.FindVolumeClose +@ stdcall FlushFileBuffers() kernel32.FlushFileBuffers +@ stdcall GetDiskFreeSpaceA() kernel32.GetDiskFreeSpaceA +@ stdcall GetDiskFreeSpaceExA() kernel32.GetDiskFreeSpaceExA +@ stdcall GetDiskFreeSpaceExW() kernel32.GetDiskFreeSpaceExW +@ stdcall GetDiskFreeSpaceW() kernel32.GetDiskFreeSpaceW +@ stdcall GetDriveTypeA() kernel32.GetDriveTypeA +@ stdcall GetDriveTypeW() kernel32.GetDriveTypeW +@ stdcall GetFileAttributesA() kernel32.GetFileAttributesA +@ stdcall GetFileAttributesExA() kernel32.GetFileAttributesExA +@ stdcall GetFileAttributesExW() kernel32.GetFileAttributesExW +@ stdcall GetFileAttributesW() kernel32.GetFileAttributesW +@ stdcall GetFileInformationByHandle() kernel32.GetFileInformationByHandle +@ stdcall GetFileSize() kernel32.GetFileSize +@ stdcall GetFileSizeEx() kernel32.GetFileSizeEx +@ stdcall GetFileTime() kernel32.GetFileTime +@ stdcall GetFileType() kernel32.GetFileType +@ stub GetFinalPathNameByHandleA +@ stub GetFinalPathNameByHandleW +@ stdcall GetFullPathNameA() kernel32.GetFullPathNameA +@ stdcall GetFullPathNameW() kernel32.GetFullPathNameW +@ stdcall GetLogicalDriveStringsW() kernel32.GetLogicalDriveStringsW +@ stdcall GetLogicalDrives() kernel32.GetLogicalDrives +@ stdcall GetLongPathNameA() kernel32.GetLongPathNameA +@ stdcall GetLongPathNameW() kernel32.GetLongPathNameW +@ stdcall GetShortPathNameW() kernel32.GetShortPathNameW +@ stdcall GetTempFileNameW() kernel32.GetTempFileNameW +@ stub GetVolumeInformationByHandleW +@ stdcall GetVolumeInformationW() kernel32.GetVolumeInformationW +@ stdcall GetVolumePathNameW() kernel32.GetVolumePathNameW +@ stdcall LocalFileTimeToFileTime() kernel32.LocalFileTimeToFileTime +@ stdcall LockFile() kernel32.LockFile +@ stdcall LockFileEx() kernel32.LockFileEx +@ stdcall QueryDosDeviceW() kernel32.QueryDosDeviceW +@ stdcall ReadFile() kernel32.ReadFile +@ stdcall ReadFileEx() kernel32.ReadFileEx +@ stdcall ReadFileScatter() kernel32.ReadFileScatter +@ stdcall RemoveDirectoryA() kernel32.RemoveDirectoryA +@ stdcall RemoveDirectoryW() kernel32.RemoveDirectoryW +@ stdcall SetEndOfFile() kernel32.SetEndOfFile +@ stdcall SetFileAttributesA() kernel32.SetFileAttributesA +@ stdcall SetFileAttributesW() kernel32.SetFileAttributesW +@ stub SetFileInformationByHandle +@ stdcall SetFilePointer() kernel32.SetFilePointer +@ stdcall SetFilePointerEx() kernel32.SetFilePointerEx +@ stdcall SetFileTime() kernel32.SetFileTime +@ stdcall SetFileValidData() kernel32.SetFileValidData +@ stdcall UnlockFile() kernel32.UnlockFile +@ stdcall UnlockFileEx() kernel32.UnlockFileEx +@ stdcall WriteFile() kernel32.WriteFile +@ stdcall WriteFileEx() kernel32.WriteFileEx +@ stdcall WriteFileGather() kernel32.WriteFileGather diff --git a/dll/apisets/api-ms-win-core-file-l1-2-0.spec b/dll/apisets/api-ms-win-core-file-l1-2-0.spec new file mode 100644 index 0000000000..4663596a46 --- /dev/null +++ b/dll/apisets/api-ms-win-core-file-l1-2-0.spec @@ -0,0 +1,82 @@ + +# This file is autogenerated by update.py + +@ stdcall CompareFileTime() kernel32.CompareFileTime +@ stdcall CreateDirectoryA() kernel32.CreateDirectoryA +@ stdcall CreateDirectoryW() kernel32.CreateDirectoryW +@ stub CreateFile2 +@ stdcall CreateFileA() kernel32.CreateFileA +@ stdcall CreateFileW() kernel32.CreateFileW +@ stdcall DefineDosDeviceW() kernel32.DefineDosDeviceW +@ stdcall DeleteFileA() kernel32.DeleteFileA +@ stdcall DeleteFileW() kernel32.DeleteFileW +@ stdcall DeleteVolumeMountPointW() kernel32.DeleteVolumeMountPointW +@ stdcall FileTimeToLocalFileTime() kernel32.FileTimeToLocalFileTime +@ stdcall FindClose() kernel32.FindClose +@ stdcall FindCloseChangeNotification() kernel32.FindCloseChangeNotification +@ stdcall FindFirstChangeNotificationA() kernel32.FindFirstChangeNotificationA +@ stdcall FindFirstChangeNotificationW() kernel32.FindFirstChangeNotificationW +@ stdcall FindFirstFileA() kernel32.FindFirstFileA +@ stdcall FindFirstFileExA() kernel32.FindFirstFileExA +@ stdcall FindFirstFileExW() kernel32.FindFirstFileExW +@ stdcall FindFirstFileW() kernel32.FindFirstFileW +@ stdcall FindFirstVolumeW() kernel32.FindFirstVolumeW +@ stdcall FindNextChangeNotification() kernel32.FindNextChangeNotification +@ stdcall FindNextFileA() kernel32.FindNextFileA +@ stdcall FindNextFileW() kernel32.FindNextFileW +@ stdcall FindNextVolumeW() kernel32.FindNextVolumeW +@ stdcall FindVolumeClose() kernel32.FindVolumeClose +@ stdcall FlushFileBuffers() kernel32.FlushFileBuffers +@ stdcall GetDiskFreeSpaceA() kernel32.GetDiskFreeSpaceA +@ stdcall GetDiskFreeSpaceExA() kernel32.GetDiskFreeSpaceExA +@ stdcall GetDiskFreeSpaceExW() kernel32.GetDiskFreeSpaceExW +@ stdcall GetDiskFreeSpaceW() kernel32.GetDiskFreeSpaceW +@ stdcall GetDriveTypeA() kernel32.GetDriveTypeA +@ stdcall GetDriveTypeW() kernel32.GetDriveTypeW +@ stdcall GetFileAttributesA() kernel32.GetFileAttributesA +@ stdcall GetFileAttributesExA() kernel32.GetFileAttributesExA +@ stdcall GetFileAttributesExW() kernel32.GetFileAttributesExW +@ stdcall GetFileAttributesW() kernel32.GetFileAttributesW +@ stdcall GetFileInformationByHandle() kernel32.GetFileInformationByHandle +@ stdcall GetFileSize() kernel32.GetFileSize +@ stdcall GetFileSizeEx() kernel32.GetFileSizeEx +@ stdcall GetFileTime() kernel32.GetFileTime +@ stdcall GetFileType() kernel32.GetFileType +@ stub GetFinalPathNameByHandleA +@ stub GetFinalPathNameByHandleW +@ stdcall GetFullPathNameA() kernel32.GetFullPathNameA +@ stdcall GetFullPathNameW() kernel32.GetFullPathNameW +@ stdcall GetLogicalDriveStringsW() kernel32.GetLogicalDriveStringsW +@ stdcall GetLogicalDrives() kernel32.GetLogicalDrives +@ stdcall GetLongPathNameA() kernel32.GetLongPathNameA +@ stdcall GetLongPathNameW() kernel32.GetLongPathNameW +@ stdcall GetShortPathNameW() kernel32.GetShortPathNameW +@ stdcall GetTempFileNameW() kernel32.GetTempFileNameW +@ stdcall GetTempPathW() kernel32.GetTempPathW +@ stub GetVolumeInformationByHandleW +@ stdcall GetVolumeInformationW() kernel32.GetVolumeInformationW +@ stdcall GetVolumeNameForVolumeMountPointW() kernel32.GetVolumeNameForVolumeMountPointW +@ stdcall GetVolumePathNameW() kernel32.GetVolumePathNameW +@ stdcall GetVolumePathNamesForVolumeNameW() kernel32.GetVolumePathNamesForVolumeNameW +@ stdcall LocalFileTimeToFileTime() kernel32.LocalFileTimeToFileTime +@ stdcall LockFile() kernel32.LockFile +@ stdcall LockFileEx() kernel32.LockFileEx +@ stdcall QueryDosDeviceW() kernel32.QueryDosDeviceW +@ stdcall ReadFile() kernel32.ReadFile +@ stdcall ReadFileEx() kernel32.ReadFileEx +@ stdcall ReadFileScatter() kernel32.ReadFileScatter +@ stdcall RemoveDirectoryA() kernel32.RemoveDirectoryA +@ stdcall RemoveDirectoryW() kernel32.RemoveDirectoryW +@ stdcall SetEndOfFile() kernel32.SetEndOfFile +@ stdcall SetFileAttributesA() kernel32.SetFileAttributesA +@ stdcall SetFileAttributesW() kernel32.SetFileAttributesW +@ stub SetFileInformationByHandle +@ stdcall SetFilePointer() kernel32.SetFilePointer +@ stdcall SetFilePointerEx() kernel32.SetFilePointerEx +@ stdcall SetFileTime() kernel32.SetFileTime +@ stdcall SetFileValidData() kernel32.SetFileValidData +@ stdcall UnlockFile() kernel32.UnlockFile +@ stdcall UnlockFileEx() kernel32.UnlockFileEx +@ stdcall WriteFile() kernel32.WriteFile +@ stdcall WriteFileEx() kernel32.WriteFileEx +@ stdcall WriteFileGather() kernel32.WriteFileGather diff --git a/dll/apisets/api-ms-win-core-file-l1-2-1.spec b/dll/apisets/api-ms-win-core-file-l1-2-1.spec new file mode 100644 index 0000000000..f0f066e401 --- /dev/null +++ b/dll/apisets/api-ms-win-core-file-l1-2-1.spec @@ -0,0 +1,85 @@ + +# This file is autogenerated by update.py + +@ stdcall CompareFileTime() kernel32.CompareFileTime +@ stdcall CreateDirectoryA() kernel32.CreateDirectoryA +@ stdcall CreateDirectoryW() kernel32.CreateDirectoryW +@ stub CreateFile2 +@ stdcall CreateFileA() kernel32.CreateFileA +@ stdcall CreateFileW() kernel32.CreateFileW +@ stdcall DefineDosDeviceW() kernel32.DefineDosDeviceW +@ stdcall DeleteFileA() kernel32.DeleteFileA +@ stdcall DeleteFileW() kernel32.DeleteFileW +@ stdcall DeleteVolumeMountPointW() kernel32.DeleteVolumeMountPointW +@ stdcall FileTimeToLocalFileTime() kernel32.FileTimeToLocalFileTime +@ stdcall FindClose() kernel32.FindClose +@ stdcall FindCloseChangeNotification() kernel32.FindCloseChangeNotification +@ stdcall FindFirstChangeNotificationA() kernel32.FindFirstChangeNotificationA +@ stdcall FindFirstChangeNotificationW() kernel32.FindFirstChangeNotificationW +@ stdcall FindFirstFileA() kernel32.FindFirstFileA +@ stdcall FindFirstFileExA() kernel32.FindFirstFileExA +@ stdcall FindFirstFileExW() kernel32.FindFirstFileExW +@ stdcall FindFirstFileW() kernel32.FindFirstFileW +@ stdcall FindFirstVolumeW() kernel32.FindFirstVolumeW +@ stdcall FindNextChangeNotification() kernel32.FindNextChangeNotification +@ stdcall FindNextFileA() kernel32.FindNextFileA +@ stdcall FindNextFileW() kernel32.FindNextFileW +@ stdcall FindNextVolumeW() kernel32.FindNextVolumeW +@ stdcall FindVolumeClose() kernel32.FindVolumeClose +@ stdcall FlushFileBuffers() kernel32.FlushFileBuffers +@ stdcall GetCompressedFileSizeA() kernel32.GetCompressedFileSizeA +@ stdcall GetCompressedFileSizeW() kernel32.GetCompressedFileSizeW +@ stdcall GetDiskFreeSpaceA() kernel32.GetDiskFreeSpaceA +@ stdcall GetDiskFreeSpaceExA() kernel32.GetDiskFreeSpaceExA +@ stdcall GetDiskFreeSpaceExW() kernel32.GetDiskFreeSpaceExW +@ stdcall GetDiskFreeSpaceW() kernel32.GetDiskFreeSpaceW +@ stdcall GetDriveTypeA() kernel32.GetDriveTypeA +@ stdcall GetDriveTypeW() kernel32.GetDriveTypeW +@ stdcall GetFileAttributesA() kernel32.GetFileAttributesA +@ stdcall GetFileAttributesExA() kernel32.GetFileAttributesExA +@ stdcall GetFileAttributesExW() kernel32.GetFileAttributesExW +@ stdcall GetFileAttributesW() kernel32.GetFileAttributesW +@ stdcall GetFileInformationByHandle() kernel32.GetFileInformationByHandle +@ stdcall GetFileSize() kernel32.GetFileSize +@ stdcall GetFileSizeEx() kernel32.GetFileSizeEx +@ stdcall GetFileTime() kernel32.GetFileTime +@ stdcall GetFileType() kernel32.GetFileType +@ stub GetFinalPathNameByHandleA +@ stub GetFinalPathNameByHandleW +@ stdcall GetFullPathNameA() kernel32.GetFullPathNameA +@ stdcall GetFullPathNameW() kernel32.GetFullPathNameW +@ stdcall GetLogicalDriveStringsW() kernel32.GetLogicalDriveStringsW +@ stdcall GetLogicalDrives() kernel32.GetLogicalDrives +@ stdcall GetLongPathNameA() kernel32.GetLongPathNameA +@ stdcall GetLongPathNameW() kernel32.GetLongPathNameW +@ stdcall GetShortPathNameW() kernel32.GetShortPathNameW +@ stdcall GetTempFileNameW() kernel32.GetTempFileNameW +@ stdcall GetTempPathW() kernel32.GetTempPathW +@ stub GetVolumeInformationByHandleW +@ stdcall GetVolumeInformationW() kernel32.GetVolumeInformationW +@ stdcall GetVolumeNameForVolumeMountPointW() kernel32.GetVolumeNameForVolumeMountPointW +@ stdcall GetVolumePathNameW() kernel32.GetVolumePathNameW +@ stdcall GetVolumePathNamesForVolumeNameW() kernel32.GetVolumePathNamesForVolumeNameW +@ stdcall LocalFileTimeToFileTime() kernel32.LocalFileTimeToFileTime +@ stdcall LockFile() kernel32.LockFile +@ stdcall LockFileEx() kernel32.LockFileEx +@ stdcall QueryDosDeviceW() kernel32.QueryDosDeviceW +@ stdcall ReadFile() kernel32.ReadFile +@ stdcall ReadFileEx() kernel32.ReadFileEx +@ stdcall ReadFileScatter() kernel32.ReadFileScatter +@ stdcall RemoveDirectoryA() kernel32.RemoveDirectoryA +@ stdcall RemoveDirectoryW() kernel32.RemoveDirectoryW +@ stdcall SetEndOfFile() kernel32.SetEndOfFile +@ stdcall SetFileAttributesA() kernel32.SetFileAttributesA +@ stdcall SetFileAttributesW() kernel32.SetFileAttributesW +@ stub SetFileInformationByHandle +@ stub SetFileIoOverlappedRange +@ stdcall SetFilePointer() kernel32.SetFilePointer +@ stdcall SetFilePointerEx() kernel32.SetFilePointerEx +@ stdcall SetFileTime() kernel32.SetFileTime +@ stdcall SetFileValidData() kernel32.SetFileValidData +@ stdcall UnlockFile() kernel32.UnlockFile +@ stdcall UnlockFileEx() kernel32.UnlockFileEx +@ stdcall WriteFile() kernel32.WriteFile +@ stdcall WriteFileEx() kernel32.WriteFileEx +@ stdcall WriteFileGather() kernel32.WriteFileGather diff --git a/dll/apisets/api-ms-win-core-file-l1-2-2.spec b/dll/apisets/api-ms-win-core-file-l1-2-2.spec new file mode 100644 index 0000000000..5795f87d4b --- /dev/null +++ b/dll/apisets/api-ms-win-core-file-l1-2-2.spec @@ -0,0 +1,13 @@ + +# This file is autogenerated by update.py + +@ stdcall AreFileApisANSI() kernel32.AreFileApisANSI +@ stub FindFirstFileNameW +@ stdcall FindFirstStreamW() kernel32.FindFirstStreamW +@ stub FindNextFileNameW +@ stdcall FindNextStreamW() kernel32.FindNextStreamW +@ stdcall GetTempFileNameA() kernel32.GetTempFileNameA +@ stdcall GetTempPathA() kernel32.GetTempPathA +@ stdcall GetVolumeInformationA() kernel32.GetVolumeInformationA +@ stdcall SetFileApisToANSI() kernel32.SetFileApisToANSI +@ stdcall SetFileApisToOEM() kernel32.SetFileApisToOEM diff --git a/dll/apisets/api-ms-win-core-file-l2-1-0.spec b/dll/apisets/api-ms-win-core-file-l2-1-0.spec new file mode 100644 index 0000000000..afc3180611 --- /dev/null +++ b/dll/apisets/api-ms-win-core-file-l2-1-0.spec @@ -0,0 +1,14 @@ + +# This file is autogenerated by update.py + +@ stub CopyFile2 +@ stdcall CopyFileExW() kernel32.CopyFileExW +@ stdcall CreateDirectoryExW() kernel32.CreateDirectoryExW +@ stdcall CreateHardLinkW() kernel32.CreateHardLinkW +@ stub CreateSymbolicLinkW +@ stdcall GetFileInformationByHandleEx() kernel32_vista.GetFileInformationByHandleEx +@ stdcall MoveFileExW() kernel32.MoveFileExW +@ stdcall MoveFileWithProgressW() kernel32.MoveFileWithProgressW +@ stdcall ReOpenFile() kernel32.ReOpenFile +@ stdcall ReadDirectoryChangesW() kernel32.ReadDirectoryChangesW +@ stdcall ReplaceFileW() kernel32.ReplaceFileW diff --git a/dll/apisets/api-ms-win-core-file-l2-1-1.spec b/dll/apisets/api-ms-win-core-file-l2-1-1.spec new file mode 100644 index 0000000000..de67d2d7ac --- /dev/null +++ b/dll/apisets/api-ms-win-core-file-l2-1-1.spec @@ -0,0 +1,15 @@ + +# This file is autogenerated by update.py + +@ stub CopyFile2 +@ stdcall CopyFileExW() kernel32.CopyFileExW +@ stdcall CreateDirectoryExW() kernel32.CreateDirectoryExW +@ stdcall CreateHardLinkW() kernel32.CreateHardLinkW +@ stub CreateSymbolicLinkW +@ stdcall GetFileInformationByHandleEx() kernel32_vista.GetFileInformationByHandleEx +@ stdcall MoveFileExW() kernel32.MoveFileExW +@ stdcall MoveFileWithProgressW() kernel32.MoveFileWithProgressW +@ stub OpenFileById +@ stdcall ReOpenFile() kernel32.ReOpenFile +@ stdcall ReadDirectoryChangesW() kernel32.ReadDirectoryChangesW +@ stdcall ReplaceFileW() kernel32.ReplaceFileW diff --git a/dll/apisets/api-ms-win-core-file-l2-1-2.spec b/dll/apisets/api-ms-win-core-file-l2-1-2.spec new file mode 100644 index 0000000000..6aaae9410f --- /dev/null +++ b/dll/apisets/api-ms-win-core-file-l2-1-2.spec @@ -0,0 +1,17 @@ + +# This file is autogenerated by update.py + +@ stub CopyFile2 +@ stdcall CopyFileExW() kernel32.CopyFileExW +@ stdcall CopyFileW() kernel32.CopyFileW +@ stdcall CreateDirectoryExW() kernel32.CreateDirectoryExW +@ stdcall CreateHardLinkA() kernel32.CreateHardLinkA +@ stdcall CreateHardLinkW() kernel32.CreateHardLinkW +@ stub CreateSymbolicLinkW +@ stdcall GetFileInformationByHandleEx() kernel32_vista.GetFileInformationByHandleEx +@ stdcall MoveFileExW() kernel32.MoveFileExW +@ stdcall MoveFileWithProgressW() kernel32.MoveFileWithProgressW +@ stub OpenFileById +@ stdcall ReadDirectoryChangesW() kernel32.ReadDirectoryChangesW +@ stdcall ReOpenFile() kernel32.ReOpenFile +@ stdcall ReplaceFileW() kernel32.ReplaceFileW diff --git a/dll/apisets/api-ms-win-core-handle-l1-1-0.spec b/dll/apisets/api-ms-win-core-handle-l1-1-0.spec new file mode 100644 index 0000000000..88fbc33d26 --- /dev/null +++ b/dll/apisets/api-ms-win-core-handle-l1-1-0.spec @@ -0,0 +1,7 @@ + +# This file is autogenerated by update.py + +@ stdcall CloseHandle() kernel32.CloseHandle +@ stdcall DuplicateHandle() kernel32.DuplicateHandle +@ stdcall GetHandleInformation() kernel32.GetHandleInformation +@ stdcall SetHandleInformation() kernel32.SetHandleInformation diff --git a/dll/apisets/api-ms-win-core-heap-l1-1-0.spec b/dll/apisets/api-ms-win-core-heap-l1-1-0.spec new file mode 100644 index 0000000000..a4af7df847 --- /dev/null +++ b/dll/apisets/api-ms-win-core-heap-l1-1-0.spec @@ -0,0 +1,19 @@ + +# This file is autogenerated by update.py + +@ stdcall GetProcessHeap() kernel32.GetProcessHeap +@ stdcall GetProcessHeaps() kernel32.GetProcessHeaps +@ stdcall HeapAlloc() kernel32.HeapAlloc +@ stdcall HeapCompact() kernel32.HeapCompact +@ stdcall HeapCreate() kernel32.HeapCreate +@ stdcall HeapDestroy() kernel32.HeapDestroy +@ stdcall HeapFree() kernel32.HeapFree +@ stdcall HeapLock() kernel32.HeapLock +@ stdcall HeapQueryInformation() kernel32.HeapQueryInformation +@ stdcall HeapReAlloc() kernel32.HeapReAlloc +@ stdcall HeapSetInformation() kernel32.HeapSetInformation +@ stdcall HeapSize() kernel32.HeapSize +@ stdcall HeapSummary() kernel32.HeapSummary +@ stdcall HeapUnlock() kernel32.HeapUnlock +@ stdcall HeapValidate() kernel32.HeapValidate +@ stdcall HeapWalk() kernel32.HeapWalk diff --git a/dll/apisets/api-ms-win-core-heap-l1-2-0.spec b/dll/apisets/api-ms-win-core-heap-l1-2-0.spec new file mode 100644 index 0000000000..7cafad2ab4 --- /dev/null +++ b/dll/apisets/api-ms-win-core-heap-l1-2-0.spec @@ -0,0 +1,18 @@ + +# This file is autogenerated by update.py + +@ stdcall GetProcessHeap() kernel32.GetProcessHeap +@ stdcall GetProcessHeaps() kernel32.GetProcessHeaps +@ stdcall HeapAlloc() kernel32.HeapAlloc +@ stdcall HeapCompact() kernel32.HeapCompact +@ stdcall HeapCreate() kernel32.HeapCreate +@ stdcall HeapDestroy() kernel32.HeapDestroy +@ stdcall HeapFree() kernel32.HeapFree +@ stdcall HeapLock() kernel32.HeapLock +@ stdcall HeapQueryInformation() kernel32.HeapQueryInformation +@ stdcall HeapReAlloc() kernel32.HeapReAlloc +@ stdcall HeapSetInformation() kernel32.HeapSetInformation +@ stdcall HeapSize() kernel32.HeapSize +@ stdcall HeapUnlock() kernel32.HeapUnlock +@ stdcall HeapValidate() kernel32.HeapValidate +@ stdcall HeapWalk() kernel32.HeapWalk diff --git a/dll/apisets/api-ms-win-core-heap-l2-1-0.spec b/dll/apisets/api-ms-win-core-heap-l2-1-0.spec new file mode 100644 index 0000000000..88385fea5f --- /dev/null +++ b/dll/apisets/api-ms-win-core-heap-l2-1-0.spec @@ -0,0 +1,10 @@ + +# This file is autogenerated by update.py + +@ stdcall GlobalAlloc() kernel32.GlobalAlloc +@ stdcall GlobalFree() kernel32.GlobalFree +@ stdcall LocalAlloc() kernel32.LocalAlloc +@ stdcall LocalFree() kernel32.LocalFree +@ stdcall LocalLock() kernel32.LocalLock +@ stdcall LocalReAlloc() kernel32.LocalReAlloc +@ stdcall LocalUnlock() kernel32.LocalUnlock diff --git a/dll/apisets/api-ms-win-core-heap-obsolete-l1-1-0.spec b/dll/apisets/api-ms-win-core-heap-obsolete-l1-1-0.spec new file mode 100644 index 0000000000..ea47c334a8 --- /dev/null +++ b/dll/apisets/api-ms-win-core-heap-obsolete-l1-1-0.spec @@ -0,0 +1,18 @@ + +# This file is autogenerated by update.py + +@ stdcall GlobalAlloc() kernel32.GlobalAlloc +@ stdcall GlobalFlags() kernel32.GlobalFlags +@ stdcall GlobalFree() kernel32.GlobalFree +@ stdcall GlobalHandle() kernel32.GlobalHandle +@ stdcall GlobalLock() kernel32.GlobalLock +@ stdcall GlobalReAlloc() kernel32.GlobalReAlloc +@ stdcall GlobalSize() kernel32.GlobalSize +@ stdcall GlobalUnlock() kernel32.GlobalUnlock +@ stdcall LocalAlloc() kernel32.LocalAlloc +@ stdcall LocalFlags() kernel32.LocalFlags +@ stdcall LocalFree() kernel32.LocalFree +@ stdcall LocalLock() kernel32.LocalLock +@ stdcall LocalReAlloc() kernel32.LocalReAlloc +@ stdcall LocalSize() kernel32.LocalSize +@ stdcall LocalUnlock() kernel32.LocalUnlock diff --git a/dll/apisets/api-ms-win-core-interlocked-l1-1-0.spec b/dll/apisets/api-ms-win-core-interlocked-l1-1-0.spec new file mode 100644 index 0000000000..8001f92ffb --- /dev/null +++ b/dll/apisets/api-ms-win-core-interlocked-l1-1-0.spec @@ -0,0 +1,15 @@ + +# This file is autogenerated by update.py + +@ stdcall InitializeSListHead() kernel32.InitializeSListHead +@ stdcall -arch=i386 InterlockedCompareExchange64() kernel32.InterlockedCompareExchange64 +@ stdcall -arch=i386 InterlockedCompareExchange() kernel32.InterlockedCompareExchange +@ stdcall -arch=i386 InterlockedDecrement() kernel32.InterlockedDecrement +@ stdcall -arch=i386 InterlockedExchange() kernel32.InterlockedExchange +@ stdcall -arch=i386 InterlockedExchangeAdd() kernel32.InterlockedExchangeAdd +@ stdcall InterlockedFlushSList() kernel32.InterlockedFlushSList +@ stdcall -arch=i386 InterlockedIncrement() kernel32.InterlockedIncrement +@ stdcall InterlockedPopEntrySList() kernel32.InterlockedPopEntrySList +@ stdcall InterlockedPushEntrySList() kernel32.InterlockedPushEntrySList +@ stub InterlockedPushListSList +@ stdcall QueryDepthSList() kernel32.QueryDepthSList diff --git a/dll/apisets/api-ms-win-core-interlocked-l1-2-0.spec b/dll/apisets/api-ms-win-core-interlocked-l1-2-0.spec new file mode 100644 index 0000000000..47f5d25b7f --- /dev/null +++ b/dll/apisets/api-ms-win-core-interlocked-l1-2-0.spec @@ -0,0 +1,15 @@ + +# This file is autogenerated by update.py + +@ stdcall InitializeSListHead() kernel32.InitializeSListHead +@ stdcall -arch=i386 InterlockedCompareExchange64() kernel32.InterlockedCompareExchange64 +@ stdcall -arch=i386 InterlockedCompareExchange() kernel32.InterlockedCompareExchange +@ stdcall -arch=i386 InterlockedDecrement() kernel32.InterlockedDecrement +@ stdcall -arch=i386 InterlockedExchange() kernel32.InterlockedExchange +@ stdcall -arch=i386 InterlockedExchangeAdd() kernel32.InterlockedExchangeAdd +@ stdcall InterlockedFlushSList() kernel32.InterlockedFlushSList +@ stdcall -arch=i386 InterlockedIncrement() kernel32.InterlockedIncrement +@ stdcall InterlockedPopEntrySList() kernel32.InterlockedPopEntrySList +@ stdcall InterlockedPushEntrySList() kernel32.InterlockedPushEntrySList +@ stub InterlockedPushListSListEx +@ stdcall QueryDepthSList() kernel32.QueryDepthSList diff --git a/dll/apisets/api-ms-win-core-io-l1-1-0.spec b/dll/apisets/api-ms-win-core-io-l1-1-0.spec new file mode 100644 index 0000000000..33581e7744 --- /dev/null +++ b/dll/apisets/api-ms-win-core-io-l1-1-0.spec @@ -0,0 +1,10 @@ + +# This file is autogenerated by update.py + +@ stub CancelIoEx +@ stdcall CreateIoCompletionPort() kernel32.CreateIoCompletionPort +@ stdcall DeviceIoControl() kernel32.DeviceIoControl +@ stdcall GetOverlappedResult() kernel32.GetOverlappedResult +@ stdcall GetQueuedCompletionStatus() kernel32.GetQueuedCompletionStatus +@ stub GetQueuedCompletionStatusEx +@ stdcall PostQueuedCompletionStatus() kernel32.PostQueuedCompletionStatus diff --git a/dll/apisets/api-ms-win-core-io-l1-1-1.spec b/dll/apisets/api-ms-win-core-io-l1-1-1.spec new file mode 100644 index 0000000000..aa4df20df3 --- /dev/null +++ b/dll/apisets/api-ms-win-core-io-l1-1-1.spec @@ -0,0 +1,13 @@ + +# This file is autogenerated by update.py + +@ stdcall CancelIo() kernel32.CancelIo +@ stub CancelIoEx +@ stub CancelSynchronousIo +@ stdcall CreateIoCompletionPort() kernel32.CreateIoCompletionPort +@ stdcall DeviceIoControl() kernel32.DeviceIoControl +@ stdcall GetOverlappedResult() kernel32.GetOverlappedResult +@ stub GetOverlappedResultEx +@ stdcall GetQueuedCompletionStatus() kernel32.GetQueuedCompletionStatus +@ stub GetQueuedCompletionStatusEx +@ stdcall PostQueuedCompletionStatus() kernel32.PostQueuedCompletionStatus diff --git a/dll/apisets/api-ms-win-core-job-l1-1-0.spec b/dll/apisets/api-ms-win-core-job-l1-1-0.spec new file mode 100644 index 0000000000..95601c26df --- /dev/null +++ b/dll/apisets/api-ms-win-core-job-l1-1-0.spec @@ -0,0 +1,4 @@ + +# This file is autogenerated by update.py + +@ stdcall IsProcessInJob() kernel32.IsProcessInJob diff --git a/dll/apisets/api-ms-win-core-job-l2-1-0.spec b/dll/apisets/api-ms-win-core-job-l2-1-0.spec new file mode 100644 index 0000000000..ea935a4251 --- /dev/null +++ b/dll/apisets/api-ms-win-core-job-l2-1-0.spec @@ -0,0 +1,9 @@ + +# This file is autogenerated by update.py + +@ stdcall AssignProcessToJobObject() kernel32.AssignProcessToJobObject +@ stdcall CreateJobObjectW() kernel32.CreateJobObjectW +@ stdcall OpenJobObjectW() kernel32.OpenJobObjectW +@ stdcall QueryInformationJobObject() kernel32.QueryInformationJobObject +@ stdcall SetInformationJobObject() kernel32.SetInformationJobObject +@ stdcall TerminateJobObject() kernel32.TerminateJobObject diff --git a/dll/apisets/api-ms-win-core-kernel32-legacy-l1-1-0.spec b/dll/apisets/api-ms-win-core-kernel32-legacy-l1-1-0.spec new file mode 100644 index 0000000000..80df9b0b58 --- /dev/null +++ b/dll/apisets/api-ms-win-core-kernel32-legacy-l1-1-0.spec @@ -0,0 +1,57 @@ + +# This file is autogenerated by update.py + +@ stdcall AddLocalAlternateComputerNameW() kernel32.AddLocalAlternateComputerNameW +@ stdcall BackupRead() kernel32.BackupRead +@ stdcall BackupWrite() kernel32.BackupWrite +@ stdcall BindIoCompletionCallback() kernel32.BindIoCompletionCallback +@ stdcall CopyFileA() kernel32.CopyFileA +@ stdcall CopyFileW() kernel32.CopyFileW +@ stdcall CreateFileMappingA() kernel32.CreateFileMappingA +@ stub CreateFileTransactedW +@ stdcall CreateMailslotA() kernel32.CreateMailslotA +@ stdcall CreateNamedPipeA() kernel32.CreateNamedPipeA +@ stdcall CreateSemaphoreW() kernel32.CreateSemaphoreW +@ stdcall DnsHostnameToComputerNameW() kernel32.DnsHostnameToComputerNameW +@ stdcall DosDateTimeToFileTime() kernel32.DosDateTimeToFileTime +@ stdcall FatalAppExitA() kernel32.FatalAppExitA +@ stdcall FatalAppExitW() kernel32.FatalAppExitW +@ stdcall FileTimeToDosDateTime() kernel32.FileTimeToDosDateTime +@ stdcall FindResourceA() kernel32.FindResourceA +@ stdcall FindResourceExA() kernel32.FindResourceExA +@ stdcall FindResourceW() kernel32.FindResourceW +@ stdcall GetComputerNameA() kernel32.GetComputerNameA +@ stdcall GetComputerNameW() kernel32.GetComputerNameW +@ stdcall GetConsoleWindow() kernel32.GetConsoleWindow +@ stub GetDurationFormatEx +@ stub GetMaximumProcessorGroupCount +@ stub GetNamedPipeClientProcessId +@ stub GetNamedPipeServerProcessId +@ stdcall GetShortPathNameA() kernel32.GetShortPathNameA +@ stdcall GetStartupInfoA() kernel32.GetStartupInfoA +@ stdcall GetStringTypeExA() kernel32.GetStringTypeExA +@ stdcall GetSystemPowerStatus() kernel32.GetSystemPowerStatus +@ stdcall GetSystemWow64DirectoryA() kernel32.GetSystemWow64DirectoryA +@ stdcall GetSystemWow64DirectoryW() kernel32.GetSystemWow64DirectoryW +@ stdcall GetTapeParameters() kernel32.GetTapeParameters +@ stdcall GetTempPathA() kernel32.GetTempPathA +@ stdcall GetThreadSelectorEntry() kernel32.GetThreadSelectorEntry +@ stdcall GlobalMemoryStatus() kernel32.GlobalMemoryStatus +@ stdcall LoadLibraryA() kernel32.LoadLibraryA +@ stdcall LoadLibraryW() kernel32.LoadLibraryW +@ stdcall MoveFileA() kernel32.MoveFileA +@ stdcall MoveFileExA() kernel32.MoveFileExA +@ stdcall MoveFileW() kernel32.MoveFileW +@ stdcall MulDiv() kernel32.MulDiv +@ stdcall OpenFile() kernel32.OpenFile +@ stdcall PulseEvent() kernel32.PulseEvent +@ stub RaiseFailFastException +@ stdcall RegisterWaitForSingleObject() kernel32.RegisterWaitForSingleObject +@ stdcall SetConsoleTitleA() kernel32.SetConsoleTitleA +@ stdcall SetFileCompletionNotificationModes() kernel32.SetFileCompletionNotificationModes +@ stdcall SetHandleCount() kernel32.SetHandleCount +@ stdcall SetMailslotInfo() kernel32.SetMailslotInfo +@ stdcall SetVolumeLabelW() kernel32.SetVolumeLabelW +@ stdcall UnregisterWait() kernel32.UnregisterWait +@ stdcall WTSGetActiveConsoleSessionId() kernel32.WTSGetActiveConsoleSessionId +@ stdcall WaitForMultipleObjects() kernel32.WaitForMultipleObjects diff --git a/dll/apisets/api-ms-win-core-kernel32-legacy-l1-1-1.spec b/dll/apisets/api-ms-win-core-kernel32-legacy-l1-1-1.spec new file mode 100644 index 0000000000..db7c170fe7 --- /dev/null +++ b/dll/apisets/api-ms-win-core-kernel32-legacy-l1-1-1.spec @@ -0,0 +1,72 @@ + +# This file is autogenerated by update.py + +@ stdcall AddLocalAlternateComputerNameW() kernel32.AddLocalAlternateComputerNameW +@ stdcall BackupRead() kernel32.BackupRead +@ stdcall BackupWrite() kernel32.BackupWrite +@ stdcall BindIoCompletionCallback() kernel32.BindIoCompletionCallback +@ stdcall CopyFileA() kernel32.CopyFileA +@ stdcall CopyFileW() kernel32.CopyFileW +@ stdcall CreateFileMappingA() kernel32.CreateFileMappingA +@ stub CreateFileTransactedW +@ stdcall CreateMailslotA() kernel32.CreateMailslotA +@ stdcall CreateNamedPipeA() kernel32.CreateNamedPipeA +@ stdcall CreateSemaphoreW() kernel32.CreateSemaphoreW +@ stdcall DnsHostnameToComputerNameW() kernel32.DnsHostnameToComputerNameW +@ stdcall DosDateTimeToFileTime() kernel32.DosDateTimeToFileTime +@ stdcall FatalAppExitA() kernel32.FatalAppExitA +@ stdcall FatalAppExitW() kernel32.FatalAppExitW +@ stdcall FileTimeToDosDateTime() kernel32.FileTimeToDosDateTime +@ stdcall FindFirstVolumeMountPointW() kernel32.FindFirstVolumeMountPointW +@ stdcall FindNextVolumeMountPointW() kernel32.FindNextVolumeMountPointW +@ stdcall FindResourceA() kernel32.FindResourceA +@ stdcall FindResourceExA() kernel32.FindResourceExA +@ stdcall FindResourceW() kernel32.FindResourceW +@ stdcall FindVolumeMountPointClose() kernel32.FindVolumeMountPointClose +@ stdcall GetComputerNameA() kernel32.GetComputerNameA +@ stdcall GetComputerNameW() kernel32.GetComputerNameW +@ stdcall GetConsoleWindow() kernel32.GetConsoleWindow +@ stub GetDurationFormatEx +@ stub GetFileAttributesTransactedW +@ stub GetFirmwareType +@ stub GetMaximumProcessorGroupCount +@ stub GetNamedPipeClientProcessId +@ stub GetNamedPipeServerProcessId +@ stub GetNumaAvailableMemoryNodeEx +@ stdcall GetNumaNodeProcessorMask() kernel32.GetNumaNodeProcessorMask +@ stub GetNumaProcessorNodeEx +@ stdcall GetShortPathNameA() kernel32.GetShortPathNameA +@ stdcall GetStartupInfoA() kernel32.GetStartupInfoA +@ stdcall GetStringTypeExA() kernel32.GetStringTypeExA +@ stdcall GetSystemPowerStatus() kernel32.GetSystemPowerStatus +@ stdcall GetSystemWow64DirectoryA() kernel32.GetSystemWow64DirectoryA +@ stdcall GetSystemWow64DirectoryW() kernel32.GetSystemWow64DirectoryW +@ stdcall GetTapeParameters() kernel32.GetTapeParameters +@ stdcall GetTempPathA() kernel32.GetTempPathA +@ stdcall GetThreadSelectorEntry() kernel32.GetThreadSelectorEntry +@ stdcall GlobalMemoryStatus() kernel32.GlobalMemoryStatus +@ stdcall LoadLibraryA() kernel32.LoadLibraryA +@ stdcall LoadLibraryW() kernel32.LoadLibraryW +@ stdcall MoveFileA() kernel32.MoveFileA +@ stdcall MoveFileExA() kernel32.MoveFileExA +@ stdcall MoveFileW() kernel32.MoveFileW +@ stdcall MulDiv() kernel32.MulDiv +@ stdcall OpenFile() kernel32.OpenFile +@ stub PowerClearRequest +@ stub PowerCreateRequest +@ stub PowerSetRequest +@ stdcall PulseEvent() kernel32.PulseEvent +@ stub RaiseFailFastException +@ stdcall RegisterWaitForSingleObject() kernel32.RegisterWaitForSingleObject +@ stdcall SetConsoleTitleA() kernel32.SetConsoleTitleA +@ stdcall SetDllDirectoryW() kernel32.SetDllDirectoryW +@ stdcall SetFileCompletionNotificationModes() kernel32.SetFileCompletionNotificationModes +@ stdcall SetHandleCount() kernel32.SetHandleCount +@ stdcall SetMailslotInfo() kernel32.SetMailslotInfo +@ stdcall SetThreadIdealProcessor() kernel32.SetThreadIdealProcessor +@ stdcall SetVolumeLabelW() kernel32.SetVolumeLabelW +@ stdcall SetVolumeMountPointW() kernel32.SetVolumeMountPointW +@ stdcall UnregisterWait() kernel32.UnregisterWait +@ stdcall VerifyVersionInfoW() kernel32.VerifyVersionInfoW +@ stdcall WaitForMultipleObjects() kernel32.WaitForMultipleObjects +@ stdcall WTSGetActiveConsoleSessionId() kernel32.WTSGetActiveConsoleSessionId diff --git a/dll/apisets/api-ms-win-core-kernel32-private-l1-1-1.spec b/dll/apisets/api-ms-win-core-kernel32-private-l1-1-1.spec new file mode 100644 index 0000000000..a1669aabdb --- /dev/null +++ b/dll/apisets/api-ms-win-core-kernel32-private-l1-1-1.spec @@ -0,0 +1,4 @@ + +# This file is autogenerated by update.py + +@ stdcall PrivCopyFileExW() kernel32.PrivCopyFileExW diff --git a/dll/apisets/api-ms-win-core-largeinteger-l1-1-0.spec b/dll/apisets/api-ms-win-core-largeinteger-l1-1-0.spec new file mode 100644 index 0000000000..9052764a57 --- /dev/null +++ b/dll/apisets/api-ms-win-core-largeinteger-l1-1-0.spec @@ -0,0 +1,4 @@ + +# This file is autogenerated by update.py + +@ stdcall MulDiv() kernel32.MulDiv diff --git a/dll/apisets/api-ms-win-core-libraryloader-l1-1-0.spec b/dll/apisets/api-ms-win-core-libraryloader-l1-1-0.spec new file mode 100644 index 0000000000..f31777fbf3 --- /dev/null +++ b/dll/apisets/api-ms-win-core-libraryloader-l1-1-0.spec @@ -0,0 +1,32 @@ + +# This file is autogenerated by update.py + +@ stub AddDllDirectory +@ stdcall DisableThreadLibraryCalls() kernel32.DisableThreadLibraryCalls +@ stub EnumResourceLanguagesExA +@ stub EnumResourceLanguagesExW +@ stub EnumResourceNamesExA +@ stub EnumResourceNamesExW +@ stub EnumResourceTypesExA +@ stub EnumResourceTypesExW +@ stdcall FindResourceExW() kernel32.FindResourceExW +@ stub FindStringOrdinal +@ stdcall FreeLibrary() kernel32.FreeLibrary +@ stdcall FreeLibraryAndExitThread() kernel32.FreeLibraryAndExitThread +@ stdcall FreeResource() kernel32.FreeResource +@ stdcall GetModuleFileNameA() kernel32.GetModuleFileNameA +@ stdcall GetModuleFileNameW() kernel32.GetModuleFileNameW +@ stdcall GetModuleHandleA() kernel32.GetModuleHandleA +@ stdcall GetModuleHandleExA() kernel32.GetModuleHandleExA +@ stdcall GetModuleHandleExW() kernel32.GetModuleHandleExW +@ stdcall GetModuleHandleW() kernel32.GetModuleHandleW +@ stdcall GetProcAddress() kernel32.GetProcAddress +@ stdcall LoadLibraryExA() kernel32.LoadLibraryExA +@ stdcall LoadLibraryExW() kernel32.LoadLibraryExW +@ stdcall LoadResource() kernel32.LoadResource +@ stdcall LoadStringA() user32.LoadStringA +@ stdcall LoadStringW() user32.LoadStringW +@ stdcall LockResource() kernel32.LockResource +@ stub RemoveDllDirectory +@ stub SetDefaultDllDirectories +@ stdcall SizeofResource() kernel32.SizeofResource diff --git a/dll/apisets/api-ms-win-core-libraryloader-l1-1-1.spec b/dll/apisets/api-ms-win-core-libraryloader-l1-1-1.spec new file mode 100644 index 0000000000..bebfc785ec --- /dev/null +++ b/dll/apisets/api-ms-win-core-libraryloader-l1-1-1.spec @@ -0,0 +1,33 @@ + +# This file is autogenerated by update.py + +@ stub AddDllDirectory +@ stdcall DisableThreadLibraryCalls() kernel32.DisableThreadLibraryCalls +@ stub EnumResourceLanguagesExA +@ stub EnumResourceLanguagesExW +@ stub EnumResourceNamesExA +@ stub EnumResourceNamesExW +@ stub EnumResourceTypesExA +@ stub EnumResourceTypesExW +@ stdcall FindResourceExW() kernel32.FindResourceExW +@ stub FindStringOrdinal +@ stdcall FreeLibrary() kernel32.FreeLibrary +@ stdcall FreeLibraryAndExitThread() kernel32.FreeLibraryAndExitThread +@ stdcall FreeResource() kernel32.FreeResource +@ stdcall GetModuleFileNameA() kernel32.GetModuleFileNameA +@ stdcall GetModuleFileNameW() kernel32.GetModuleFileNameW +@ stdcall GetModuleHandleA() kernel32.GetModuleHandleA +@ stdcall GetModuleHandleExA() kernel32.GetModuleHandleExA +@ stdcall GetModuleHandleExW() kernel32.GetModuleHandleExW +@ stdcall GetModuleHandleW() kernel32.GetModuleHandleW +@ stdcall GetProcAddress() kernel32.GetProcAddress +@ stdcall LoadLibraryExA() kernel32.LoadLibraryExA +@ stdcall LoadLibraryExW() kernel32.LoadLibraryExW +@ stdcall LoadResource() kernel32.LoadResource +@ stdcall LoadStringA() user32.LoadStringA +@ stdcall LoadStringW() user32.LoadStringW +@ stdcall LockResource() kernel32.LockResource +@ stub QueryOptionalDelayLoadedAPI +@ stub RemoveDllDirectory +@ stub SetDefaultDllDirectories +@ stdcall SizeofResource() kernel32.SizeofResource diff --git a/dll/apisets/api-ms-win-core-libraryloader-l1-2-0.spec b/dll/apisets/api-ms-win-core-libraryloader-l1-2-0.spec new file mode 100644 index 0000000000..f31777fbf3 --- /dev/null +++ b/dll/apisets/api-ms-win-core-libraryloader-l1-2-0.spec @@ -0,0 +1,32 @@ + +# This file is autogenerated by update.py + +@ stub AddDllDirectory +@ stdcall DisableThreadLibraryCalls() kernel32.DisableThreadLibraryCalls +@ stub EnumResourceLanguagesExA +@ stub EnumResourceLanguagesExW +@ stub EnumResourceNamesExA +@ stub EnumResourceNamesExW +@ stub EnumResourceTypesExA +@ stub EnumResourceTypesExW +@ stdcall FindResourceExW() kernel32.FindResourceExW +@ stub FindStringOrdinal +@ stdcall FreeLibrary() kernel32.FreeLibrary +@ stdcall FreeLibraryAndExitThread() kernel32.FreeLibraryAndExitThread +@ stdcall FreeResource() kernel32.FreeResource +@ stdcall GetModuleFileNameA() kernel32.GetModuleFileNameA +@ stdcall GetModuleFileNameW() kernel32.GetModuleFileNameW +@ stdcall GetModuleHandleA() kernel32.GetModuleHandleA +@ stdcall GetModuleHandleExA() kernel32.GetModuleHandleExA +@ stdcall GetModuleHandleExW() kernel32.GetModuleHandleExW +@ stdcall GetModuleHandleW() kernel32.GetModuleHandleW +@ stdcall GetProcAddress() kernel32.GetProcAddress +@ stdcall LoadLibraryExA() kernel32.LoadLibraryExA +@ stdcall LoadLibraryExW() kernel32.LoadLibraryExW +@ stdcall LoadResource() kernel32.LoadResource +@ stdcall LoadStringA() user32.LoadStringA +@ stdcall LoadStringW() user32.LoadStringW +@ stdcall LockResource() kernel32.LockResource +@ stub RemoveDllDirectory +@ stub SetDefaultDllDirectories +@ stdcall SizeofResource() kernel32.SizeofResource diff --git a/dll/apisets/api-ms-win-core-libraryloader-l1-2-1.spec b/dll/apisets/api-ms-win-core-libraryloader-l1-2-1.spec new file mode 100644 index 0000000000..6096285068 --- /dev/null +++ b/dll/apisets/api-ms-win-core-libraryloader-l1-2-1.spec @@ -0,0 +1,6 @@ + +# This file is autogenerated by update.py + +@ stdcall FindResourceW() kernel32.FindResourceW +@ stdcall LoadLibraryA() kernel32.LoadLibraryA +@ stdcall LoadLibraryW() kernel32.LoadLibraryW diff --git a/dll/apisets/api-ms-win-core-libraryloader-l1-2-2.spec b/dll/apisets/api-ms-win-core-libraryloader-l1-2-2.spec new file mode 100644 index 0000000000..f6c67e57df --- /dev/null +++ b/dll/apisets/api-ms-win-core-libraryloader-l1-2-2.spec @@ -0,0 +1,7 @@ + +# This file is autogenerated by update.py + +@ stdcall EnumResourceNamesW() kernel32.EnumResourceNamesW +@ stdcall FindResourceW() kernel32.FindResourceW +@ stdcall LoadLibraryA() kernel32.LoadLibraryA +@ stdcall LoadLibraryW() kernel32.LoadLibraryW diff --git a/dll/apisets/api-ms-win-core-localization-l1-1-0.spec b/dll/apisets/api-ms-win-core-localization-l1-1-0.spec new file mode 100644 index 0000000000..8b3256e975 --- /dev/null +++ b/dll/apisets/api-ms-win-core-localization-l1-1-0.spec @@ -0,0 +1,50 @@ + +# This file is autogenerated by update.py + +@ stdcall ConvertDefaultLocale() kernel32.ConvertDefaultLocale +@ stub FindNLSString +@ stub FindNLSStringEx +@ stdcall GetACP() kernel32.GetACP +@ stdcall GetCPFileNameFromRegistry() kernel32.GetCPFileNameFromRegistry +@ stdcall GetCPInfo() kernel32.GetCPInfo +@ stdcall GetCPInfoExW() kernel32.GetCPInfoExW +@ stub GetCalendarInfoEx +@ stdcall GetCalendarInfoW() kernel32.GetCalendarInfoW +@ stub GetFileMUIInfo +@ stub GetFileMUIPath +@ stub GetLocaleInfoEx +@ stdcall GetLocaleInfoW() kernel32.GetLocaleInfoW +@ stdcall GetNLSVersion() kernel32.GetNLSVersion +@ stub GetNLSVersionEx +@ stdcall GetOEMCP() kernel32.GetOEMCP +@ stub GetProcessPreferredUILanguages +@ stdcall GetSystemDefaultLCID() kernel32.GetSystemDefaultLCID +@ stdcall GetSystemDefaultLangID() kernel32.GetSystemDefaultLangID +@ stub GetSystemPreferredUILanguages +@ stdcall GetThreadLocale() kernel32.GetThreadLocale +@ stub GetThreadPreferredUILanguages +@ stub GetThreadUILanguage +@ stub GetUILanguageInfo +@ stdcall GetUserDefaultLCID() kernel32.GetUserDefaultLCID +@ stdcall GetUserDefaultLangID() kernel32.GetUserDefaultLangID +@ stub GetUserPreferredUILanguages +@ stdcall IsNLSDefinedString() kernel32.IsNLSDefinedString +@ stdcall IsValidCodePage() kernel32.IsValidCodePage +@ stdcall IsValidLanguageGroup() kernel32.IsValidLanguageGroup +@ stdcall IsValidLocale() kernel32.IsValidLocale +@ stub IsValidLocaleName +@ stub LCMapStringEx +@ stdcall LCMapStringW() kernel32.LCMapStringW +@ stub LocaleNameToLCID +@ stub NlsCheckPolicy +@ stub NlsEventDataDescCreate +@ stdcall NlsGetCacheUpdateCount() kernel32.NlsGetCacheUpdateCount +@ stub NlsUpdateLocale +@ stub NlsUpdateSystemLocale +@ stub NlsWriteEtwEvent +@ stub ResolveLocaleName +@ stdcall SetCalendarInfoW() kernel32.SetCalendarInfoW +@ stdcall SetLocaleInfoW() kernel32.SetLocaleInfoW +@ stdcall SetThreadLocale() kernel32.SetThreadLocale +@ stdcall VerLanguageNameA() kernel32.VerLanguageNameA +@ stdcall VerLanguageNameW() kernel32.VerLanguageNameW diff --git a/dll/apisets/api-ms-win-core-localization-l1-2-0.spec b/dll/apisets/api-ms-win-core-localization-l1-2-0.spec new file mode 100644 index 0000000000..a70119e521 --- /dev/null +++ b/dll/apisets/api-ms-win-core-localization-l1-2-0.spec @@ -0,0 +1,62 @@ + +# This file is autogenerated by update.py + +@ stdcall ConvertDefaultLocale() kernel32.ConvertDefaultLocale +@ stdcall EnumSystemGeoID() kernel32.EnumSystemGeoID +@ stdcall EnumSystemLocalesA() kernel32.EnumSystemLocalesA +@ stdcall EnumSystemLocalesW() kernel32.EnumSystemLocalesW +@ stub FindNLSString +@ stub FindNLSStringEx +@ stdcall FormatMessageA() kernel32.FormatMessageA +@ stdcall FormatMessageW() kernel32.FormatMessageW +@ stdcall GetACP() kernel32.GetACP +@ stdcall GetCPInfo() kernel32.GetCPInfo +@ stdcall GetCPInfoExW() kernel32.GetCPInfoExW +@ stub GetCalendarInfoEx +@ stdcall GetCalendarInfoW() kernel32.GetCalendarInfoW +@ stub GetFileMUIInfo +@ stub GetFileMUIPath +@ stdcall GetGeoInfoW() kernel32.GetGeoInfoW +@ stdcall GetLocaleInfoA() kernel32.GetLocaleInfoA +@ stub GetLocaleInfoEx +@ stdcall GetLocaleInfoW() kernel32.GetLocaleInfoW +@ stdcall GetNLSVersion() kernel32.GetNLSVersion +@ stub GetNLSVersionEx +@ stdcall GetOEMCP() kernel32.GetOEMCP +@ stub GetProcessPreferredUILanguages +@ stdcall GetSystemDefaultLCID() kernel32.GetSystemDefaultLCID +@ stdcall GetSystemDefaultLangID() kernel32.GetSystemDefaultLangID +@ stub GetSystemPreferredUILanguages +@ stdcall GetThreadLocale() kernel32.GetThreadLocale +@ stub GetThreadPreferredUILanguages +@ stub GetThreadUILanguage +@ stub GetUILanguageInfo +@ stdcall GetUserDefaultLCID() kernel32.GetUserDefaultLCID +@ stdcall GetUserDefaultLangID() kernel32.GetUserDefaultLangID +@ stub GetUserDefaultLocaleName +@ stdcall GetUserGeoID() kernel32.GetUserGeoID +@ stub GetUserPreferredUILanguages +@ stub IdnToAscii +@ stub IdnToUnicode +@ stdcall IsDBCSLeadByte() kernel32.IsDBCSLeadByte +@ stdcall IsDBCSLeadByteEx() kernel32.IsDBCSLeadByteEx +@ stdcall IsNLSDefinedString() kernel32.IsNLSDefinedString +@ stdcall IsValidCodePage() kernel32.IsValidCodePage +@ stdcall IsValidLanguageGroup() kernel32.IsValidLanguageGroup +@ stdcall IsValidLocale() kernel32.IsValidLocale +@ stub IsValidLocaleName +@ stub IsValidNLSVersion +@ stdcall LCMapStringA() kernel32.LCMapStringA +@ stub LCMapStringEx +@ stdcall LCMapStringW() kernel32.LCMapStringW +@ stub LocaleNameToLCID +@ stub ResolveLocaleName +@ stdcall SetCalendarInfoW() kernel32.SetCalendarInfoW +@ stdcall SetLocaleInfoW() kernel32.SetLocaleInfoW +@ stub SetProcessPreferredUILanguages +@ stdcall SetThreadLocale() kernel32.SetThreadLocale +@ stub SetThreadPreferredUILanguages +@ stdcall SetThreadUILanguage() kernel32.SetThreadUILanguage +@ stdcall SetUserGeoID() kernel32.SetUserGeoID +@ stdcall VerLanguageNameA() kernel32.VerLanguageNameA +@ stdcall VerLanguageNameW() kernel32.VerLanguageNameW diff --git a/dll/apisets/api-ms-win-core-localization-l1-2-1.spec b/dll/apisets/api-ms-win-core-localization-l1-2-1.spec new file mode 100644 index 0000000000..d3b3c6a041 --- /dev/null +++ b/dll/apisets/api-ms-win-core-localization-l1-2-1.spec @@ -0,0 +1,63 @@ + +# This file is autogenerated by update.py + +@ stdcall ConvertDefaultLocale() kernel32.ConvertDefaultLocale +@ stdcall EnumSystemGeoID() kernel32.EnumSystemGeoID +@ stdcall EnumSystemLocalesA() kernel32.EnumSystemLocalesA +@ stub EnumSystemLocalesEx +@ stdcall EnumSystemLocalesW() kernel32.EnumSystemLocalesW +@ stub FindNLSString +@ stub FindNLSStringEx +@ stdcall FormatMessageA() kernel32.FormatMessageA +@ stdcall FormatMessageW() kernel32.FormatMessageW +@ stdcall GetACP() kernel32.GetACP +@ stdcall GetCPInfo() kernel32.GetCPInfo +@ stdcall GetCPInfoExW() kernel32.GetCPInfoExW +@ stub GetCalendarInfoEx +@ stdcall GetCalendarInfoW() kernel32.GetCalendarInfoW +@ stub GetFileMUIInfo +@ stub GetFileMUIPath +@ stdcall GetGeoInfoW() kernel32.GetGeoInfoW +@ stdcall GetLocaleInfoA() kernel32.GetLocaleInfoA +@ stub GetLocaleInfoEx +@ stdcall GetLocaleInfoW() kernel32.GetLocaleInfoW +@ stdcall GetNLSVersion() kernel32.GetNLSVersion +@ stub GetNLSVersionEx +@ stdcall GetOEMCP() kernel32.GetOEMCP +@ stub GetProcessPreferredUILanguages +@ stdcall GetSystemDefaultLCID() kernel32.GetSystemDefaultLCID +@ stdcall GetSystemDefaultLangID() kernel32.GetSystemDefaultLangID +@ stub GetSystemPreferredUILanguages +@ stdcall GetThreadLocale() kernel32.GetThreadLocale +@ stub GetThreadPreferredUILanguages +@ stub GetThreadUILanguage +@ stub GetUILanguageInfo +@ stdcall GetUserDefaultLCID() kernel32.GetUserDefaultLCID +@ stdcall GetUserDefaultLangID() kernel32.GetUserDefaultLangID +@ stub GetUserDefaultLocaleName +@ stdcall GetUserGeoID() kernel32.GetUserGeoID +@ stub GetUserPreferredUILanguages +@ stub IdnToAscii +@ stub IdnToUnicode +@ stdcall IsDBCSLeadByte() kernel32.IsDBCSLeadByte +@ stdcall IsDBCSLeadByteEx() kernel32.IsDBCSLeadByteEx +@ stdcall IsNLSDefinedString() kernel32.IsNLSDefinedString +@ stdcall IsValidCodePage() kernel32.IsValidCodePage +@ stdcall IsValidLanguageGroup() kernel32.IsValidLanguageGroup +@ stdcall IsValidLocale() kernel32.IsValidLocale +@ stub IsValidLocaleName +@ stub IsValidNLSVersion +@ stdcall LCMapStringA() kernel32.LCMapStringA +@ stub LCMapStringEx +@ stdcall LCMapStringW() kernel32.LCMapStringW +@ stub LocaleNameToLCID +@ stub ResolveLocaleName +@ stdcall SetCalendarInfoW() kernel32.SetCalendarInfoW +@ stdcall SetLocaleInfoW() kernel32.SetLocaleInfoW +@ stub SetProcessPreferredUILanguages +@ stdcall SetThreadLocale() kernel32.SetThreadLocale +@ stub SetThreadPreferredUILanguages +@ stdcall SetThreadUILanguage() kernel32.SetThreadUILanguage +@ stdcall SetUserGeoID() kernel32.SetUserGeoID +@ stdcall VerLanguageNameA() kernel32.VerLanguageNameA +@ stdcall VerLanguageNameW() kernel32.VerLanguageNameW diff --git a/dll/apisets/api-ms-win-core-localization-l2-1-0.spec b/dll/apisets/api-ms-win-core-localization-l2-1-0.spec new file mode 100644 index 0000000000..7a169bccc4 --- /dev/null +++ b/dll/apisets/api-ms-win-core-localization-l2-1-0.spec @@ -0,0 +1,15 @@ + +# This file is autogenerated by update.py + +@ stub EnumCalendarInfoExEx +@ stdcall EnumCalendarInfoExW() kernel32.EnumCalendarInfoExW +@ stdcall EnumCalendarInfoW() kernel32.EnumCalendarInfoW +@ stub EnumDateFormatsExEx +@ stdcall EnumDateFormatsExW() kernel32.EnumDateFormatsExW +@ stdcall EnumDateFormatsW() kernel32.EnumDateFormatsW +@ stdcall EnumSystemCodePagesW() kernel32.EnumSystemCodePagesW +@ stub EnumTimeFormatsEx +@ stdcall EnumTimeFormatsW() kernel32.EnumTimeFormatsW +@ stub GetCurrencyFormatEx +@ stdcall GetCurrencyFormatW() kernel32.GetCurrencyFormatW +@ stub GetNumberFormatEx diff --git a/dll/apisets/api-ms-win-core-localization-obsolete-l1-1-0.spec b/dll/apisets/api-ms-win-core-localization-obsolete-l1-1-0.spec new file mode 100644 index 0000000000..39a1583b69 --- /dev/null +++ b/dll/apisets/api-ms-win-core-localization-obsolete-l1-1-0.spec @@ -0,0 +1,14 @@ + +# This file is autogenerated by update.py + +@ stdcall CompareStringA() kernel32.CompareStringA +@ stdcall EnumLanguageGroupLocalesW() kernel32.EnumLanguageGroupLocalesW +@ stdcall EnumSystemLanguageGroupsW() kernel32.EnumSystemLanguageGroupsW +@ stub EnumSystemLocalesEx +@ stdcall EnumUILanguagesW() kernel32.EnumUILanguagesW +@ stdcall GetNumberFormatW() kernel32.GetNumberFormatW +@ stdcall GetStringTypeA() kernel32.GetStringTypeA +@ stub GetSystemDefaultLocaleName +@ stdcall GetSystemDefaultUILanguage() kernel32.GetSystemDefaultUILanguage +@ stdcall GetUserDefaultUILanguage() kernel32.GetUserDefaultUILanguage +@ stub LCIDToLocaleName diff --git a/dll/apisets/api-ms-win-core-localization-obsolete-l1-2-0.spec b/dll/apisets/api-ms-win-core-localization-obsolete-l1-2-0.spec new file mode 100644 index 0000000000..64ee20c82f --- /dev/null +++ b/dll/apisets/api-ms-win-core-localization-obsolete-l1-2-0.spec @@ -0,0 +1,13 @@ + +# This file is autogenerated by update.py + +@ stdcall CompareStringA() kernel32.CompareStringA +@ stdcall EnumLanguageGroupLocalesW() kernel32.EnumLanguageGroupLocalesW +@ stdcall EnumSystemLanguageGroupsW() kernel32.EnumSystemLanguageGroupsW +@ stdcall EnumUILanguagesW() kernel32.EnumUILanguagesW +@ stdcall GetNumberFormatW() kernel32.GetNumberFormatW +@ stdcall GetStringTypeA() kernel32.GetStringTypeA +@ stub GetSystemDefaultLocaleName +@ stdcall GetSystemDefaultUILanguage() kernel32.GetSystemDefaultUILanguage +@ stdcall GetUserDefaultUILanguage() kernel32.GetUserDefaultUILanguage +@ stub LCIDToLocaleName diff --git a/dll/apisets/api-ms-win-core-localization-obsolete-l1-3-0.spec b/dll/apisets/api-ms-win-core-localization-obsolete-l1-3-0.spec new file mode 100644 index 0000000000..27805096c9 --- /dev/null +++ b/dll/apisets/api-ms-win-core-localization-obsolete-l1-3-0.spec @@ -0,0 +1,12 @@ + +# This file is autogenerated by update.py + +@ stdcall CompareStringA() kernel32.CompareStringA +@ stdcall EnumLanguageGroupLocalesW() kernel32.EnumLanguageGroupLocalesW +@ stdcall EnumSystemLanguageGroupsW() kernel32.EnumSystemLanguageGroupsW +@ stdcall EnumUILanguagesW() kernel32.EnumUILanguagesW +@ stdcall GetNumberFormatW() kernel32.GetNumberFormatW +@ stdcall GetStringTypeA() kernel32.GetStringTypeA +@ stub GetSystemDefaultLocaleName +@ stdcall GetSystemDefaultUILanguage() kernel32.GetSystemDefaultUILanguage +@ stdcall GetUserDefaultUILanguage() kernel32.GetUserDefaultUILanguage diff --git a/dll/apisets/api-ms-win-core-localization-private-l1-1-0.spec b/dll/apisets/api-ms-win-core-localization-private-l1-1-0.spec new file mode 100644 index 0000000000..4861f88bf4 --- /dev/null +++ b/dll/apisets/api-ms-win-core-localization-private-l1-1-0.spec @@ -0,0 +1,14 @@ + +# This file is autogenerated by update.py + +@ stdcall GetCPFileNameFromRegistry() kernel32.GetCPFileNameFromRegistry +@ stub LoadStringByReference +@ stub NlsCheckPolicy +@ stub NlsEventDataDescCreate +@ stdcall NlsGetCacheUpdateCount() kernel32.NlsGetCacheUpdateCount +@ stub NlsUpdateLocale +@ stub NlsUpdateSystemLocale +@ stub NlsWriteEtwEvent +@ stub _AddMUIStringToCache +@ stub _GetMUIStringFromCache +@ stub _OpenMuiStringCache diff --git a/dll/apisets/api-ms-win-core-localregistry-l1-1-0.spec b/dll/apisets/api-ms-win-core-localregistry-l1-1-0.spec new file mode 100644 index 0000000000..a68b3bf06d --- /dev/null +++ b/dll/apisets/api-ms-win-core-localregistry-l1-1-0.spec @@ -0,0 +1,43 @@ + +# This file is autogenerated by update.py + +@ stdcall RegCloseKey() advapi32.RegCloseKey +@ stdcall RegCreateKeyExA() advapi32.RegCreateKeyExA +@ stdcall RegCreateKeyExW() advapi32.RegCreateKeyExW +@ stdcall RegDeleteKeyExA() advapi32.RegDeleteKeyExA +@ stdcall RegDeleteKeyExW() advapi32.RegDeleteKeyExW +@ stdcall RegDeleteTreeA() advapi32_vista.RegDeleteTreeA +@ stdcall RegDeleteTreeW() advapi32_vista.RegDeleteTreeW +@ stdcall RegDeleteValueA() advapi32.RegDeleteValueA +@ stdcall RegDeleteValueW() advapi32.RegDeleteValueW +@ stub RegDisablePredefinedCacheEx +@ stdcall RegEnumKeyExA() advapi32.RegEnumKeyExA +@ stdcall RegEnumKeyExW() advapi32.RegEnumKeyExW +@ stdcall RegEnumValueA() advapi32.RegEnumValueA +@ stdcall RegEnumValueW() advapi32.RegEnumValueW +@ stdcall RegFlushKey() advapi32.RegFlushKey +@ stdcall RegGetKeySecurity() advapi32.RegGetKeySecurity +@ stdcall RegGetValueA() advapi32.RegGetValueA +@ stdcall RegGetValueW() advapi32.RegGetValueW +@ stdcall RegLoadKeyA() advapi32.RegLoadKeyA +@ stdcall RegLoadKeyW() advapi32.RegLoadKeyW +@ stub RegLoadMUIStringA +@ stub RegLoadMUIStringW +@ stdcall RegNotifyChangeKeyValue() advapi32.RegNotifyChangeKeyValue +@ stdcall RegOpenCurrentUser() advapi32.RegOpenCurrentUser +@ stdcall RegOpenKeyExA() advapi32.RegOpenKeyExA +@ stdcall RegOpenKeyExW() advapi32.RegOpenKeyExW +@ stdcall RegOpenUserClassesRoot() advapi32.RegOpenUserClassesRoot +@ stdcall RegQueryInfoKeyA() advapi32.RegQueryInfoKeyA +@ stdcall RegQueryInfoKeyW() advapi32.RegQueryInfoKeyW +@ stdcall RegQueryValueExA() advapi32.RegQueryValueExA +@ stdcall RegQueryValueExW() advapi32.RegQueryValueExW +@ stdcall RegRestoreKeyA() advapi32.RegRestoreKeyA +@ stdcall RegRestoreKeyW() advapi32.RegRestoreKeyW +@ stdcall RegSaveKeyExA() advapi32.RegSaveKeyExA +@ stdcall RegSaveKeyExW() advapi32.RegSaveKeyExW +@ stdcall RegSetKeySecurity() advapi32.RegSetKeySecurity +@ stdcall RegSetValueExA() advapi32.RegSetValueExA +@ stdcall RegSetValueExW() advapi32.RegSetValueExW +@ stdcall RegUnLoadKeyA() advapi32.RegUnLoadKeyA +@ stdcall RegUnLoadKeyW() advapi32.RegUnLoadKeyW diff --git a/dll/apisets/api-ms-win-core-memory-l1-1-0.spec b/dll/apisets/api-ms-win-core-memory-l1-1-0.spec new file mode 100644 index 0000000000..1e9b9fd64f --- /dev/null +++ b/dll/apisets/api-ms-win-core-memory-l1-1-0.spec @@ -0,0 +1,19 @@ + +# This file is autogenerated by update.py + +@ stdcall CreateFileMappingW() kernel32.CreateFileMappingW +@ stdcall FlushViewOfFile() kernel32.FlushViewOfFile +@ stdcall MapViewOfFile() kernel32.MapViewOfFile +@ stdcall MapViewOfFileEx() kernel32.MapViewOfFileEx +@ stdcall OpenFileMappingW() kernel32.OpenFileMappingW +@ stdcall ReadProcessMemory() kernel32.ReadProcessMemory +@ stdcall UnmapViewOfFile() kernel32.UnmapViewOfFile +@ stdcall VirtualAlloc() kernel32.VirtualAlloc +@ stdcall VirtualAllocEx() kernel32.VirtualAllocEx +@ stdcall VirtualFree() kernel32.VirtualFree +@ stdcall VirtualFreeEx() kernel32.VirtualFreeEx +@ stdcall VirtualProtect() kernel32.VirtualProtect +@ stdcall VirtualProtectEx() kernel32.VirtualProtectEx +@ stdcall VirtualQuery() kernel32.VirtualQuery +@ stdcall VirtualQueryEx() kernel32.VirtualQueryEx +@ stdcall WriteProcessMemory() kernel32.WriteProcessMemory diff --git a/dll/apisets/api-ms-win-core-memory-l1-1-1.spec b/dll/apisets/api-ms-win-core-memory-l1-1-1.spec new file mode 100644 index 0000000000..50494165c2 --- /dev/null +++ b/dll/apisets/api-ms-win-core-memory-l1-1-1.spec @@ -0,0 +1,35 @@ + +# This file is autogenerated by update.py + +@ stub CreateFileMappingFromApp +@ stub CreateFileMappingNumaW +@ stdcall CreateFileMappingW() kernel32.CreateFileMappingW +@ stdcall CreateMemoryResourceNotification() kernel32.CreateMemoryResourceNotification +@ stdcall FlushViewOfFile() kernel32.FlushViewOfFile +@ stdcall GetLargePageMinimum() kernel32.GetLargePageMinimum +@ stdcall GetProcessWorkingSetSizeEx() kernel32.GetProcessWorkingSetSizeEx +@ stdcall GetSystemFileCacheSize() kernel32.GetSystemFileCacheSize +@ stdcall GetWriteWatch() kernel32.GetWriteWatch +@ stdcall MapViewOfFile() kernel32.MapViewOfFile +@ stdcall MapViewOfFileEx() kernel32.MapViewOfFileEx +@ stub MapViewOfFileFromApp +@ stdcall OpenFileMappingW() kernel32.OpenFileMappingW +@ stub PrefetchVirtualMemory +@ stdcall QueryMemoryResourceNotification() kernel32.QueryMemoryResourceNotification +@ stdcall ReadProcessMemory() kernel32.ReadProcessMemory +@ stdcall ResetWriteWatch() kernel32.ResetWriteWatch +@ stdcall SetProcessWorkingSetSizeEx() kernel32.SetProcessWorkingSetSizeEx +@ stdcall SetSystemFileCacheSize() kernel32.SetSystemFileCacheSize +@ stdcall UnmapViewOfFile() kernel32.UnmapViewOfFile +@ stub UnmapViewOfFileEx +@ stdcall VirtualAlloc() kernel32.VirtualAlloc +@ stdcall VirtualAllocEx() kernel32.VirtualAllocEx +@ stdcall VirtualFree() kernel32.VirtualFree +@ stdcall VirtualFreeEx() kernel32.VirtualFreeEx +@ stdcall VirtualLock() kernel32.VirtualLock +@ stdcall VirtualProtect() kernel32.VirtualProtect +@ stdcall VirtualProtectEx() kernel32.VirtualProtectEx +@ stdcall VirtualQuery() kernel32.VirtualQuery +@ stdcall VirtualQueryEx() kernel32.VirtualQueryEx +@ stdcall VirtualUnlock() kernel32.VirtualUnlock +@ stdcall WriteProcessMemory() kernel32.WriteProcessMemory diff --git a/dll/apisets/api-ms-win-core-memory-l1-1-2.spec b/dll/apisets/api-ms-win-core-memory-l1-1-2.spec new file mode 100644 index 0000000000..dd9eb707c1 --- /dev/null +++ b/dll/apisets/api-ms-win-core-memory-l1-1-2.spec @@ -0,0 +1,42 @@ + +# This file is autogenerated by update.py + +@ stdcall AllocateUserPhysicalPages() kernel32.AllocateUserPhysicalPages +@ stub AllocateUserPhysicalPagesNuma +@ stub CreateFileMappingFromApp +@ stub CreateFileMappingNumaW +@ stdcall CreateFileMappingW() kernel32.CreateFileMappingW +@ stdcall CreateMemoryResourceNotification() kernel32.CreateMemoryResourceNotification +@ stdcall FlushViewOfFile() kernel32.FlushViewOfFile +@ stdcall FreeUserPhysicalPages() kernel32.FreeUserPhysicalPages +@ stdcall GetLargePageMinimum() kernel32.GetLargePageMinimum +@ stub GetMemoryErrorHandlingCapabilities +@ stdcall GetProcessWorkingSetSizeEx() kernel32.GetProcessWorkingSetSizeEx +@ stdcall GetSystemFileCacheSize() kernel32.GetSystemFileCacheSize +@ stdcall GetWriteWatch() kernel32.GetWriteWatch +@ stdcall MapUserPhysicalPages() kernel32.MapUserPhysicalPages +@ stdcall MapViewOfFile() kernel32.MapViewOfFile +@ stdcall MapViewOfFileEx() kernel32.MapViewOfFileEx +@ stub MapViewOfFileFromApp +@ stdcall OpenFileMappingW() kernel32.OpenFileMappingW +@ stub PrefetchVirtualMemory +@ stdcall QueryMemoryResourceNotification() kernel32.QueryMemoryResourceNotification +@ stdcall ReadProcessMemory() kernel32.ReadProcessMemory +@ stub RegisterBadMemoryNotification +@ stdcall ResetWriteWatch() kernel32.ResetWriteWatch +@ stdcall SetProcessWorkingSetSizeEx() kernel32.SetProcessWorkingSetSizeEx +@ stdcall SetSystemFileCacheSize() kernel32.SetSystemFileCacheSize +@ stdcall UnmapViewOfFile() kernel32.UnmapViewOfFile +@ stub UnmapViewOfFileEx +@ stub UnregisterBadMemoryNotification +@ stdcall VirtualAlloc() kernel32.VirtualAlloc +@ stdcall VirtualAllocEx() kernel32.VirtualAllocEx +@ stub VirtualAllocExNuma +@ stdcall VirtualFree() kernel32.VirtualFree +@ stdcall VirtualFreeEx() kernel32.VirtualFreeEx +@ stdcall VirtualLock() kernel32.VirtualLock +@ stdcall VirtualProtect() kernel32.VirtualProtect +@ stdcall VirtualProtectEx() kernel32.VirtualProtectEx +@ stdcall VirtualQuery() kernel32.VirtualQuery +@ stdcall VirtualUnlock() kernel32.VirtualUnlock +@ stdcall WriteProcessMemory() kernel32.WriteProcessMemory diff --git a/dll/apisets/api-ms-win-core-misc-l1-1-0.spec b/dll/apisets/api-ms-win-core-misc-l1-1-0.spec new file mode 100644 index 0000000000..60e46b71c0 --- /dev/null +++ b/dll/apisets/api-ms-win-core-misc-l1-1-0.spec @@ -0,0 +1,37 @@ + +# This file is autogenerated by update.py + +@ stdcall EnumSystemLocalesA() kernel32.EnumSystemLocalesA +@ stdcall FatalAppExitA() kernel32.FatalAppExitA +@ stdcall FatalAppExitW() kernel32.FatalAppExitW +@ stdcall FormatMessageA() kernel32.FormatMessageA +@ stdcall FormatMessageW() kernel32.FormatMessageW +@ stdcall GlobalAlloc() kernel32.GlobalAlloc +@ stdcall GlobalFree() kernel32.GlobalFree +@ stdcall IsProcessInJob() kernel32.IsProcessInJob +@ stdcall IsWow64Process() kernel32.IsWow64Process +@ stdcall LCMapStringA() kernel32.LCMapStringA +@ stdcall LocalAlloc() kernel32.LocalAlloc +@ stdcall LocalFree() kernel32.LocalFree +@ stdcall LocalLock() kernel32.LocalLock +@ stdcall LocalReAlloc() kernel32.LocalReAlloc +@ stdcall LocalUnlock() kernel32.LocalUnlock +@ stdcall NeedCurrentDirectoryForExePathA() kernel32.NeedCurrentDirectoryForExePathA +@ stdcall NeedCurrentDirectoryForExePathW() kernel32.NeedCurrentDirectoryForExePathW +@ stdcall PulseEvent() kernel32.PulseEvent +@ stdcall SetHandleCount() kernel32.SetHandleCount +@ stdcall Sleep() kernel32.Sleep +@ stdcall Wow64DisableWow64FsRedirection() kernel32.Wow64DisableWow64FsRedirection +@ stdcall Wow64RevertWow64FsRedirection() kernel32.Wow64RevertWow64FsRedirection +@ stdcall lstrcmp() kernel32.lstrcmp +@ stdcall lstrcmpA() kernel32.lstrcmpA +@ stdcall lstrcmpW() kernel32.lstrcmpW +@ stdcall lstrcmpi() kernel32.lstrcmpi +@ stdcall lstrcmpiA() kernel32.lstrcmpiA +@ stdcall lstrcmpiW() kernel32.lstrcmpiW +@ stdcall lstrcpyn() kernel32.lstrcpyn +@ stdcall lstrcpynA() kernel32.lstrcpynA +@ stdcall lstrcpynW() kernel32.lstrcpynW +@ stdcall lstrlen() kernel32.lstrlen +@ stdcall lstrlenA() kernel32.lstrlenA +@ stdcall lstrlenW() kernel32.lstrlenW diff --git a/dll/apisets/api-ms-win-core-namedpipe-l1-1-0.spec b/dll/apisets/api-ms-win-core-namedpipe-l1-1-0.spec new file mode 100644 index 0000000000..6023e5d1da --- /dev/null +++ b/dll/apisets/api-ms-win-core-namedpipe-l1-1-0.spec @@ -0,0 +1,14 @@ + +# This file is autogenerated by update.py + +@ stdcall ConnectNamedPipe() kernel32.ConnectNamedPipe +@ stdcall CreateNamedPipeW() kernel32.CreateNamedPipeW +@ stdcall CreatePipe() kernel32.CreatePipe +@ stdcall DisconnectNamedPipe() kernel32.DisconnectNamedPipe +@ stub GetNamedPipeAttribute +@ stub GetNamedPipeClientComputerNameW +@ stdcall ImpersonateNamedPipeClient() advapi32.ImpersonateNamedPipeClient +@ stdcall PeekNamedPipe() kernel32.PeekNamedPipe +@ stdcall SetNamedPipeHandleState() kernel32.SetNamedPipeHandleState +@ stdcall TransactNamedPipe() kernel32.TransactNamedPipe +@ stdcall WaitNamedPipeW() kernel32.WaitNamedPipeW diff --git a/dll/apisets/api-ms-win-core-namedpipe-l1-2-0.spec b/dll/apisets/api-ms-win-core-namedpipe-l1-2-0.spec new file mode 100644 index 0000000000..3b69555ca7 --- /dev/null +++ b/dll/apisets/api-ms-win-core-namedpipe-l1-2-0.spec @@ -0,0 +1,13 @@ + +# This file is autogenerated by update.py + +@ stdcall ConnectNamedPipe() kernel32.ConnectNamedPipe +@ stdcall CreateNamedPipeW() kernel32.CreateNamedPipeW +@ stdcall CreatePipe() kernel32.CreatePipe +@ stdcall DisconnectNamedPipe() kernel32.DisconnectNamedPipe +@ stub GetNamedPipeClientComputerNameW +@ stdcall ImpersonateNamedPipeClient() advapi32.ImpersonateNamedPipeClient +@ stdcall PeekNamedPipe() kernel32.PeekNamedPipe +@ stdcall SetNamedPipeHandleState() kernel32.SetNamedPipeHandleState +@ stdcall TransactNamedPipe() kernel32.TransactNamedPipe +@ stdcall WaitNamedPipeW() kernel32.WaitNamedPipeW diff --git a/dll/apisets/api-ms-win-core-namespace-l1-1-0.spec b/dll/apisets/api-ms-win-core-namespace-l1-1-0.spec new file mode 100644 index 0000000000..b12e1458d6 --- /dev/null +++ b/dll/apisets/api-ms-win-core-namespace-l1-1-0.spec @@ -0,0 +1,9 @@ + +# This file is autogenerated by update.py + +@ stub AddSIDToBoundaryDescriptor +@ stub ClosePrivateNamespace +@ stub CreateBoundaryDescriptorW +@ stub CreatePrivateNamespaceW +@ stub DeleteBoundaryDescriptor +@ stub OpenPrivateNamespaceW diff --git a/dll/apisets/api-ms-win-core-normalization-l1-1-0.spec b/dll/apisets/api-ms-win-core-normalization-l1-1-0.spec new file mode 100644 index 0000000000..e9423fb85d --- /dev/null +++ b/dll/apisets/api-ms-win-core-normalization-l1-1-0.spec @@ -0,0 +1,8 @@ + +# This file is autogenerated by update.py + +@ stub GetStringScripts +@ stub IdnToNameprepUnicode +@ stub IsNormalizedString +@ stub NormalizeString +@ stub VerifyScripts diff --git a/dll/apisets/api-ms-win-core-path-l1-1-0.spec b/dll/apisets/api-ms-win-core-path-l1-1-0.spec new file mode 100644 index 0000000000..75cfb62be5 --- /dev/null +++ b/dll/apisets/api-ms-win-core-path-l1-1-0.spec @@ -0,0 +1,25 @@ + +# This file is autogenerated by update.py + +@ stub PathAllocCanonicalize +@ stub PathAllocCombine +@ stub PathCchAddBackslash +@ stub PathCchAddBackslashEx +@ stub PathCchAddExtension +@ stub PathCchAppend +@ stub PathCchAppendEx +@ stub PathCchCanonicalize +@ stub PathCchCanonicalizeEx +@ stub PathCchCombine +@ stub PathCchCombineEx +@ stub PathCchFindExtension +@ stub PathCchIsRoot +@ stub PathCchRemoveBackslash +@ stub PathCchRemoveBackslashEx +@ stub PathCchRemoveExtension +@ stub PathCchRemoveFileSpec +@ stub PathCchRenameExtension +@ stub PathCchSkipRoot +@ stub PathCchStripPrefix +@ stub PathCchStripToRoot +@ stub PathIsUNCEx diff --git a/dll/apisets/api-ms-win-core-privateprofile-l1-1-1.spec b/dll/apisets/api-ms-win-core-privateprofile-l1-1-1.spec new file mode 100644 index 0000000000..e2280b70c2 --- /dev/null +++ b/dll/apisets/api-ms-win-core-privateprofile-l1-1-1.spec @@ -0,0 +1,5 @@ + +# This file is autogenerated by update.py + +@ stdcall GetPrivateProfileSectionA() kernel32.GetPrivateProfileSectionA +@ stdcall WritePrivateProfileSectionW() kernel32.WritePrivateProfileSectionW diff --git a/dll/apisets/api-ms-win-core-processenvironment-l1-1-0.spec b/dll/apisets/api-ms-win-core-processenvironment-l1-1-0.spec new file mode 100644 index 0000000000..b96c3ec557 --- /dev/null +++ b/dll/apisets/api-ms-win-core-processenvironment-l1-1-0.spec @@ -0,0 +1,25 @@ + +# This file is autogenerated by update.py + +@ stdcall ExpandEnvironmentStringsA() kernel32.ExpandEnvironmentStringsA +@ stdcall ExpandEnvironmentStringsW() kernel32.ExpandEnvironmentStringsW +@ stdcall FreeEnvironmentStringsA() kernel32.FreeEnvironmentStringsA +@ stdcall FreeEnvironmentStringsW() kernel32.FreeEnvironmentStringsW +@ stdcall GetCommandLineA() kernel32.GetCommandLineA +@ stdcall GetCommandLineW() kernel32.GetCommandLineW +@ stdcall GetCurrentDirectoryA() kernel32.GetCurrentDirectoryA +@ stdcall GetCurrentDirectoryW() kernel32.GetCurrentDirectoryW +@ stdcall GetEnvironmentStrings() kernel32.GetEnvironmentStrings +@ stdcall GetEnvironmentStringsA() kernel32.GetEnvironmentStringsA +@ stdcall GetEnvironmentStringsW() kernel32.GetEnvironmentStringsW +@ stdcall GetEnvironmentVariableA() kernel32.GetEnvironmentVariableA +@ stdcall GetEnvironmentVariableW() kernel32.GetEnvironmentVariableW +@ stdcall GetStdHandle() kernel32.GetStdHandle +@ stdcall SearchPathW() kernel32.SearchPathW +@ stdcall SetCurrentDirectoryA() kernel32.SetCurrentDirectoryA +@ stdcall SetCurrentDirectoryW() kernel32.SetCurrentDirectoryW +@ stdcall SetEnvironmentStringsW() kernel32.SetEnvironmentStringsW +@ stdcall SetEnvironmentVariableA() kernel32.SetEnvironmentVariableA +@ stdcall SetEnvironmentVariableW() kernel32.SetEnvironmentVariableW +@ stdcall SetStdHandle() kernel32.SetStdHandle +@ stub SetStdHandleEx diff --git a/dll/apisets/api-ms-win-core-processenvironment-l1-2-0.spec b/dll/apisets/api-ms-win-core-processenvironment-l1-2-0.spec new file mode 100644 index 0000000000..8d5d686f87 --- /dev/null +++ b/dll/apisets/api-ms-win-core-processenvironment-l1-2-0.spec @@ -0,0 +1,27 @@ + +# This file is autogenerated by update.py + +@ stdcall ExpandEnvironmentStringsA() kernel32.ExpandEnvironmentStringsA +@ stdcall ExpandEnvironmentStringsW() kernel32.ExpandEnvironmentStringsW +@ stdcall FreeEnvironmentStringsA() kernel32.FreeEnvironmentStringsA +@ stdcall FreeEnvironmentStringsW() kernel32.FreeEnvironmentStringsW +@ stdcall GetCommandLineA() kernel32.GetCommandLineA +@ stdcall GetCommandLineW() kernel32.GetCommandLineW +@ stdcall GetCurrentDirectoryA() kernel32.GetCurrentDirectoryA +@ stdcall GetCurrentDirectoryW() kernel32.GetCurrentDirectoryW +@ stdcall GetEnvironmentStrings() kernel32.GetEnvironmentStrings +@ stdcall GetEnvironmentStringsW() kernel32.GetEnvironmentStringsW +@ stdcall GetEnvironmentVariableA() kernel32.GetEnvironmentVariableA +@ stdcall GetEnvironmentVariableW() kernel32.GetEnvironmentVariableW +@ stdcall GetStdHandle() kernel32.GetStdHandle +@ stdcall NeedCurrentDirectoryForExePathA() kernel32.NeedCurrentDirectoryForExePathA +@ stdcall NeedCurrentDirectoryForExePathW() kernel32.NeedCurrentDirectoryForExePathW +@ stdcall SearchPathA() kernel32.SearchPathA +@ stdcall SearchPathW() kernel32.SearchPathW +@ stdcall SetCurrentDirectoryA() kernel32.SetCurrentDirectoryA +@ stdcall SetCurrentDirectoryW() kernel32.SetCurrentDirectoryW +@ stdcall SetEnvironmentStringsW() kernel32.SetEnvironmentStringsW +@ stdcall SetEnvironmentVariableA() kernel32.SetEnvironmentVariableA +@ stdcall SetEnvironmentVariableW() kernel32.SetEnvironmentVariableW +@ stdcall SetStdHandle() kernel32.SetStdHandle +@ stub SetStdHandleEx diff --git a/dll/apisets/api-ms-win-core-processthreads-l1-1-0.spec b/dll/apisets/api-ms-win-core-processthreads-l1-1-0.spec new file mode 100644 index 0000000000..c810e44f75 --- /dev/null +++ b/dll/apisets/api-ms-win-core-processthreads-l1-1-0.spec @@ -0,0 +1,52 @@ + +# This file is autogenerated by update.py + +@ stdcall CreateProcessA() kernel32.CreateProcessA +@ stdcall CreateProcessAsUserW() advapi32.CreateProcessAsUserW +@ stdcall CreateProcessW() kernel32.CreateProcessW +@ stdcall CreateRemoteThread() kernel32.CreateRemoteThread +@ stub CreateRemoteThreadEx +@ stdcall CreateThread() kernel32.CreateThread +@ stub DeleteProcThreadAttributeList +@ stdcall ExitProcess() kernel32.ExitProcess +@ stdcall ExitThread() kernel32.ExitThread +@ stub FlushProcessWriteBuffers +@ stdcall GetCurrentProcess() kernel32.GetCurrentProcess +@ stdcall GetCurrentProcessId() kernel32.GetCurrentProcessId +@ stdcall GetCurrentThread() kernel32.GetCurrentThread +@ stdcall GetCurrentThreadId() kernel32.GetCurrentThreadId +@ stdcall GetExitCodeProcess() kernel32.GetExitCodeProcess +@ stdcall GetExitCodeThread() kernel32.GetExitCodeThread +@ stdcall GetPriorityClass() kernel32.GetPriorityClass +@ stdcall GetProcessId() kernel32.GetProcessId +@ stdcall GetProcessIdOfThread() kernel32.GetProcessIdOfThread +@ stdcall GetProcessTimes() kernel32.GetProcessTimes +@ stdcall GetProcessVersion() kernel32.GetProcessVersion +@ stdcall GetStartupInfoW() kernel32.GetStartupInfoW +@ stdcall GetThreadId() kernel32.GetThreadId +@ stdcall GetThreadPriority() kernel32.GetThreadPriority +@ stdcall GetThreadPriorityBoost() kernel32.GetThreadPriorityBoost +@ stub InitializeProcThreadAttributeList +@ stdcall OpenProcessToken() advapi32.OpenProcessToken +@ stdcall OpenThread() kernel32.OpenThread +@ stdcall OpenThreadToken() advapi32.OpenThreadToken +@ stdcall ProcessIdToSessionId() kernel32.ProcessIdToSessionId +@ stub QueryProcessAffinityUpdateMode +@ stdcall QueueUserAPC() kernel32.QueueUserAPC +@ stdcall ResumeThread() kernel32.ResumeThread +@ stdcall SetPriorityClass() kernel32.SetPriorityClass +@ stub SetProcessAffinityUpdateMode +@ stdcall SetProcessShutdownParameters() kernel32.SetProcessShutdownParameters +@ stdcall SetThreadPriority() kernel32.SetThreadPriority +@ stdcall SetThreadPriorityBoost() kernel32.SetThreadPriorityBoost +@ stdcall SetThreadStackGuarantee() kernel32.SetThreadStackGuarantee +@ stdcall SetThreadToken() advapi32.SetThreadToken +@ stdcall SuspendThread() kernel32.SuspendThread +@ stdcall SwitchToThread() kernel32.SwitchToThread +@ stdcall TerminateProcess() kernel32.TerminateProcess +@ stdcall TerminateThread() kernel32.TerminateThread +@ stdcall TlsAlloc() kernel32.TlsAlloc +@ stdcall TlsFree() kernel32.TlsFree +@ stdcall TlsGetValue() kernel32.TlsGetValue +@ stdcall TlsSetValue() kernel32.TlsSetValue +@ stub UpdateProcThreadAttribute diff --git a/dll/apisets/api-ms-win-core-processthreads-l1-1-1.spec b/dll/apisets/api-ms-win-core-processthreads-l1-1-1.spec new file mode 100644 index 0000000000..649b11b6f1 --- /dev/null +++ b/dll/apisets/api-ms-win-core-processthreads-l1-1-1.spec @@ -0,0 +1,66 @@ + +# This file is autogenerated by update.py + +@ stdcall CreateProcessA() kernel32.CreateProcessA +@ stdcall CreateProcessAsUserW() advapi32.CreateProcessAsUserW +@ stdcall CreateProcessW() kernel32.CreateProcessW +@ stdcall CreateRemoteThread() kernel32.CreateRemoteThread +@ stub CreateRemoteThreadEx +@ stdcall CreateThread() kernel32.CreateThread +@ stub DeleteProcThreadAttributeList +@ stdcall ExitProcess() kernel32.ExitProcess +@ stdcall ExitThread() kernel32.ExitThread +@ stdcall FlushInstructionCache() kernel32.FlushInstructionCache +@ stub FlushProcessWriteBuffers +@ stdcall GetCurrentProcess() kernel32.GetCurrentProcess +@ stdcall GetCurrentProcessId() kernel32.GetCurrentProcessId +@ stdcall GetCurrentProcessorNumber() kernel32.GetCurrentProcessorNumber +@ stub GetCurrentProcessorNumberEx +@ stdcall GetCurrentThread() kernel32.GetCurrentThread +@ stdcall GetCurrentThreadId() kernel32.GetCurrentThreadId +@ stub GetCurrentThreadStackLimits +@ stdcall GetExitCodeProcess() kernel32.GetExitCodeProcess +@ stdcall GetExitCodeThread() kernel32.GetExitCodeThread +@ stdcall GetPriorityClass() kernel32.GetPriorityClass +@ stdcall GetProcessHandleCount() kernel32.GetProcessHandleCount +@ stdcall GetProcessId() kernel32.GetProcessId +@ stdcall GetProcessIdOfThread() kernel32.GetProcessIdOfThread +@ stub GetProcessMitigationPolicy +@ stdcall GetProcessTimes() kernel32.GetProcessTimes +@ stdcall GetProcessVersion() kernel32.GetProcessVersion +@ stdcall GetStartupInfoW() kernel32.GetStartupInfoW +@ stdcall GetThreadContext() kernel32.GetThreadContext +@ stdcall GetThreadId() kernel32.GetThreadId +@ stub GetThreadIdealProcessorEx +@ stdcall GetThreadPriority() kernel32.GetThreadPriority +@ stdcall GetThreadPriorityBoost() kernel32.GetThreadPriorityBoost +@ stdcall GetThreadTimes() kernel32.GetThreadTimes +@ stub InitializeProcThreadAttributeList +@ stdcall IsProcessorFeaturePresent() kernel32.IsProcessorFeaturePresent +@ stdcall OpenProcess() kernel32.OpenProcess +@ stdcall OpenProcessToken() advapi32.OpenProcessToken +@ stdcall OpenThread() kernel32.OpenThread +@ stdcall OpenThreadToken() advapi32.OpenThreadToken +@ stdcall ProcessIdToSessionId() kernel32.ProcessIdToSessionId +@ stub QueryProcessAffinityUpdateMode +@ stdcall QueueUserAPC() kernel32.QueueUserAPC +@ stdcall ResumeThread() kernel32.ResumeThread +@ stdcall SetPriorityClass() kernel32.SetPriorityClass +@ stub SetProcessAffinityUpdateMode +@ stub SetProcessMitigationPolicy +@ stdcall SetProcessShutdownParameters() kernel32.SetProcessShutdownParameters +@ stdcall SetThreadContext() kernel32.SetThreadContext +@ stub SetThreadIdealProcessorEx +@ stdcall SetThreadPriority() kernel32.SetThreadPriority +@ stdcall SetThreadPriorityBoost() kernel32.SetThreadPriorityBoost +@ stdcall SetThreadStackGuarantee() kernel32.SetThreadStackGuarantee +@ stdcall SetThreadToken() advapi32.SetThreadToken +@ stdcall SuspendThread() kernel32.SuspendThread +@ stdcall SwitchToThread() kernel32.SwitchToThread +@ stdcall TerminateProcess() kernel32.TerminateProcess +@ stdcall TerminateThread() kernel32.TerminateThread +@ stdcall TlsAlloc() kernel32.TlsAlloc +@ stdcall TlsFree() kernel32.TlsFree +@ stdcall TlsGetValue() kernel32.TlsGetValue +@ stdcall TlsSetValue() kernel32.TlsSetValue +@ stub UpdateProcThreadAttribute diff --git a/dll/apisets/api-ms-win-core-processthreads-l1-1-2.spec b/dll/apisets/api-ms-win-core-processthreads-l1-1-2.spec new file mode 100644 index 0000000000..791a0ae08f --- /dev/null +++ b/dll/apisets/api-ms-win-core-processthreads-l1-1-2.spec @@ -0,0 +1,73 @@ + +# This file is autogenerated by update.py + +@ stdcall CreateProcessA() kernel32.CreateProcessA +@ stdcall CreateProcessAsUserW() advapi32.CreateProcessAsUserW +@ stdcall CreateProcessW() kernel32.CreateProcessW +@ stdcall CreateRemoteThread() kernel32.CreateRemoteThread +@ stub CreateRemoteThreadEx +@ stdcall CreateThread() kernel32.CreateThread +@ stub DeleteProcThreadAttributeList +@ stdcall ExitProcess() kernel32.ExitProcess +@ stdcall ExitThread() kernel32.ExitThread +@ stdcall FlushInstructionCache() kernel32.FlushInstructionCache +@ stub FlushProcessWriteBuffers +@ stdcall GetCurrentProcess() kernel32.GetCurrentProcess +@ stdcall GetCurrentProcessId() kernel32.GetCurrentProcessId +@ stdcall GetCurrentProcessorNumber() kernel32.GetCurrentProcessorNumber +@ stub GetCurrentProcessorNumberEx +@ stdcall GetCurrentThread() kernel32.GetCurrentThread +@ stdcall GetCurrentThreadId() kernel32.GetCurrentThreadId +@ stub GetCurrentThreadStackLimits +@ stdcall GetExitCodeProcess() kernel32.GetExitCodeProcess +@ stdcall GetExitCodeThread() kernel32.GetExitCodeThread +@ stdcall GetPriorityClass() kernel32.GetPriorityClass +@ stdcall GetProcessHandleCount() kernel32.GetProcessHandleCount +@ stdcall GetProcessId() kernel32.GetProcessId +@ stdcall GetProcessIdOfThread() kernel32.GetProcessIdOfThread +@ stub GetProcessMitigationPolicy +@ stdcall GetProcessPriorityBoost() kernel32.GetProcessPriorityBoost +@ stdcall GetProcessTimes() kernel32.GetProcessTimes +@ stdcall GetProcessVersion() kernel32.GetProcessVersion +@ stdcall GetStartupInfoW() kernel32.GetStartupInfoW +@ stdcall GetSystemTimes() kernel32.GetSystemTimes +@ stdcall GetThreadContext() kernel32.GetThreadContext +@ stdcall GetThreadIOPendingFlag() kernel32.GetThreadIOPendingFlag +@ stdcall GetThreadId() kernel32.GetThreadId +@ stub GetThreadIdealProcessorEx +@ stub GetThreadInformation +@ stdcall GetThreadPriority() kernel32.GetThreadPriority +@ stdcall GetThreadPriorityBoost() kernel32.GetThreadPriorityBoost +@ stdcall GetThreadTimes() kernel32.GetThreadTimes +@ stub InitializeProcThreadAttributeList +@ stub IsProcessCritical +@ stdcall IsProcessorFeaturePresent() kernel32.IsProcessorFeaturePresent +@ stdcall OpenProcess() kernel32.OpenProcess +@ stdcall OpenProcessToken() advapi32.OpenProcessToken +@ stdcall OpenThread() kernel32.OpenThread +@ stdcall OpenThreadToken() advapi32.OpenThreadToken +@ stdcall ProcessIdToSessionId() kernel32.ProcessIdToSessionId +@ stub QueryProcessAffinityUpdateMode +@ stdcall QueueUserAPC() kernel32.QueueUserAPC +@ stdcall ResumeThread() kernel32.ResumeThread +@ stdcall SetPriorityClass() kernel32.SetPriorityClass +@ stub SetProcessAffinityUpdateMode +@ stub SetProcessMitigationPolicy +@ stdcall SetProcessPriorityBoost() kernel32.SetProcessPriorityBoost +@ stdcall SetProcessShutdownParameters() kernel32.SetProcessShutdownParameters +@ stdcall SetThreadContext() kernel32.SetThreadContext +@ stub SetThreadIdealProcessorEx +@ stub SetThreadInformation +@ stdcall SetThreadPriority() kernel32.SetThreadPriority +@ stdcall SetThreadPriorityBoost() kernel32.SetThreadPriorityBoost +@ stdcall SetThreadStackGuarantee() kernel32.SetThreadStackGuarantee +@ stdcall SetThreadToken() advapi32.SetThreadToken +@ stdcall SuspendThread() kernel32.SuspendThread +@ stdcall SwitchToThread() kernel32.SwitchToThread +@ stdcall TerminateProcess() kernel32.TerminateProcess +@ stdcall TerminateThread() kernel32.TerminateThread +@ stdcall TlsAlloc() kernel32.TlsAlloc +@ stdcall TlsFree() kernel32.TlsFree +@ stdcall TlsGetValue() kernel32.TlsGetValue +@ stdcall TlsSetValue() kernel32.TlsSetValue +@ stub UpdateProcThreadAttribute diff --git a/dll/apisets/api-ms-win-core-processtopology-obsolete-l1-1-0.spec b/dll/apisets/api-ms-win-core-processtopology-obsolete-l1-1-0.spec new file mode 100644 index 0000000000..bebb4073fe --- /dev/null +++ b/dll/apisets/api-ms-win-core-processtopology-obsolete-l1-1-0.spec @@ -0,0 +1,8 @@ + +# This file is autogenerated by update.py + +@ stub GetActiveProcessorCount +@ stdcall GetProcessAffinityMask() kernel32.GetProcessAffinityMask +@ stdcall GetProcessIoCounters() kernel32.GetProcessIoCounters +@ stdcall SetProcessAffinityMask() kernel32.SetProcessAffinityMask +@ stdcall SetThreadAffinityMask() kernel32.SetThreadAffinityMask diff --git a/dll/apisets/api-ms-win-core-profile-l1-1-0.spec b/dll/apisets/api-ms-win-core-profile-l1-1-0.spec new file mode 100644 index 0000000000..2e34a98711 --- /dev/null +++ b/dll/apisets/api-ms-win-core-profile-l1-1-0.spec @@ -0,0 +1,5 @@ + +# This file is autogenerated by update.py + +@ stdcall QueryPerformanceCounter() kernel32.QueryPerformanceCounter +@ stdcall QueryPerformanceFrequency() kernel32.QueryPerformanceFrequency diff --git a/dll/apisets/api-ms-win-core-psapi-ansi-l1-1-0.spec b/dll/apisets/api-ms-win-core-psapi-ansi-l1-1-0.spec new file mode 100644 index 0000000000..67db1f1a20 --- /dev/null +++ b/dll/apisets/api-ms-win-core-psapi-ansi-l1-1-0.spec @@ -0,0 +1,9 @@ + +# This file is autogenerated by update.py + +@ stub K32EnumPageFilesA +@ stub K32GetDeviceDriverBaseNameA +@ stub K32GetDeviceDriverFileNameA +@ stub K32GetMappedFileNameA +@ stub K32GetProcessImageFileNameA +@ stub QueryFullProcessImageNameA diff --git a/dll/apisets/api-ms-win-core-psapi-l1-1-0.spec b/dll/apisets/api-ms-win-core-psapi-l1-1-0.spec new file mode 100644 index 0000000000..4ca5b2330c --- /dev/null +++ b/dll/apisets/api-ms-win-core-psapi-l1-1-0.spec @@ -0,0 +1,19 @@ + +# This file is autogenerated by update.py + +@ stub K32EmptyWorkingSet +@ stub K32EnumDeviceDrivers +@ stub K32EnumPageFilesW +@ stub K32EnumProcesses +@ stub K32GetDeviceDriverBaseNameW +@ stub K32GetDeviceDriverFileNameW +@ stub K32GetMappedFileNameW +@ stub K32GetPerformanceInfo +@ stub K32GetProcessImageFileNameW +@ stub K32GetProcessMemoryInfo +@ stub K32GetWsChanges +@ stub K32GetWsChangesEx +@ stub K32InitializeProcessForWsWatch +@ stub K32QueryWorkingSet +@ stub K32QueryWorkingSetEx +@ stub QueryFullProcessImageNameW diff --git a/dll/apisets/api-ms-win-core-psapi-obsolete-l1-1-0.spec b/dll/apisets/api-ms-win-core-psapi-obsolete-l1-1-0.spec new file mode 100644 index 0000000000..0c2cacfd54 --- /dev/null +++ b/dll/apisets/api-ms-win-core-psapi-obsolete-l1-1-0.spec @@ -0,0 +1,10 @@ + +# This file is autogenerated by update.py + +@ stub K32EnumProcessModules +@ stub K32EnumProcessModulesEx +@ stub K32GetModuleBaseNameA +@ stub K32GetModuleBaseNameW +@ stub K32GetModuleFileNameExA +@ stub K32GetModuleFileNameExW +@ stub K32GetModuleInformation diff --git a/dll/apisets/api-ms-win-core-quirks-l1-1-0.spec b/dll/apisets/api-ms-win-core-quirks-l1-1-0.spec new file mode 100644 index 0000000000..d8c37fb310 --- /dev/null +++ b/dll/apisets/api-ms-win-core-quirks-l1-1-0.spec @@ -0,0 +1,11 @@ + +# This file is autogenerated by update.py + +@ stub QuirkGetData +@ stub QuirkGetData2 +@ stub QuirkIsEnabled +@ stub QuirkIsEnabled2 +@ stub QuirkIsEnabled3 +@ stub QuirkIsEnabledForPackage +@ stub QuirkIsEnabledForPackage2 +@ stub QuirkIsEnabledForProcess diff --git a/dll/apisets/api-ms-win-core-realtime-l1-1-0.spec b/dll/apisets/api-ms-win-core-realtime-l1-1-0.spec new file mode 100644 index 0000000000..9fac9e04be --- /dev/null +++ b/dll/apisets/api-ms-win-core-realtime-l1-1-0.spec @@ -0,0 +1,8 @@ + +# This file is autogenerated by update.py + +@ stub QueryIdleProcessorCycleTime +@ stub QueryIdleProcessorCycleTimeEx +@ stub QueryProcessCycleTime +@ stub QueryThreadCycleTime +@ stub QueryUnbiasedInterruptTime diff --git a/dll/apisets/api-ms-win-core-registry-l1-1-0.spec b/dll/apisets/api-ms-win-core-registry-l1-1-0.spec new file mode 100644 index 0000000000..28bb717638 --- /dev/null +++ b/dll/apisets/api-ms-win-core-registry-l1-1-0.spec @@ -0,0 +1,46 @@ + +# This file is autogenerated by update.py + +@ stdcall RegCloseKey() advapi32.RegCloseKey +@ stub RegCopyTreeW +@ stdcall RegCreateKeyExA() advapi32.RegCreateKeyExA +@ stdcall RegCreateKeyExW() advapi32.RegCreateKeyExW +@ stdcall RegDeleteKeyExA() advapi32.RegDeleteKeyExA +@ stdcall RegDeleteKeyExW() advapi32.RegDeleteKeyExW +@ stdcall RegDeleteTreeA() advapi32_vista.RegDeleteTreeA +@ stdcall RegDeleteTreeW() advapi32_vista.RegDeleteTreeW +@ stdcall RegDeleteValueA() advapi32.RegDeleteValueA +@ stdcall RegDeleteValueW() advapi32.RegDeleteValueW +@ stub RegDisablePredefinedCacheEx +@ stdcall RegEnumKeyExA() advapi32.RegEnumKeyExA +@ stdcall RegEnumKeyExW() advapi32.RegEnumKeyExW +@ stdcall RegEnumValueA() advapi32.RegEnumValueA +@ stdcall RegEnumValueW() advapi32.RegEnumValueW +@ stdcall RegFlushKey() advapi32.RegFlushKey +@ stdcall RegGetKeySecurity() advapi32.RegGetKeySecurity +@ stdcall RegGetValueA() advapi32.RegGetValueA +@ stdcall RegGetValueW() advapi32.RegGetValueW +@ stub RegLoadAppKeyA +@ stub RegLoadAppKeyW +@ stdcall RegLoadKeyA() advapi32.RegLoadKeyA +@ stdcall RegLoadKeyW() advapi32.RegLoadKeyW +@ stub RegLoadMUIStringA +@ stub RegLoadMUIStringW +@ stdcall RegNotifyChangeKeyValue() advapi32.RegNotifyChangeKeyValue +@ stdcall RegOpenCurrentUser() advapi32.RegOpenCurrentUser +@ stdcall RegOpenKeyExA() advapi32.RegOpenKeyExA +@ stdcall RegOpenKeyExW() advapi32.RegOpenKeyExW +@ stdcall RegOpenUserClassesRoot() advapi32.RegOpenUserClassesRoot +@ stdcall RegQueryInfoKeyA() advapi32.RegQueryInfoKeyA +@ stdcall RegQueryInfoKeyW() advapi32.RegQueryInfoKeyW +@ stdcall RegQueryValueExA() advapi32.RegQueryValueExA +@ stdcall RegQueryValueExW() advapi32.RegQueryValueExW +@ stdcall RegRestoreKeyA() advapi32.RegRestoreKeyA +@ stdcall RegRestoreKeyW() advapi32.RegRestoreKeyW +@ stdcall RegSaveKeyExA() advapi32.RegSaveKeyExA +@ stdcall RegSaveKeyExW() advapi32.RegSaveKeyExW +@ stdcall RegSetKeySecurity() advapi32.RegSetKeySecurity +@ stdcall RegSetValueExA() advapi32.RegSetValueExA +@ stdcall RegSetValueExW() advapi32.RegSetValueExW +@ stdcall RegUnLoadKeyA() advapi32.RegUnLoadKeyA +@ stdcall RegUnLoadKeyW() advapi32.RegUnLoadKeyW diff --git a/dll/apisets/api-ms-win-core-registry-l2-1-0.spec b/dll/apisets/api-ms-win-core-registry-l2-1-0.spec new file mode 100644 index 0000000000..89e642feaa --- /dev/null +++ b/dll/apisets/api-ms-win-core-registry-l2-1-0.spec @@ -0,0 +1,36 @@ + +# This file is autogenerated by update.py + +@ stdcall RegConnectRegistryA() advapi32.RegConnectRegistryA +@ stdcall RegConnectRegistryW() advapi32.RegConnectRegistryW +@ stub RegCopyTreeA +@ stdcall RegCreateKeyA() advapi32.RegCreateKeyA +@ stub RegCreateKeyTransactedA +@ stub RegCreateKeyTransactedW +@ stdcall RegCreateKeyW() advapi32.RegCreateKeyW +@ stdcall RegDeleteKeyA() advapi32.RegDeleteKeyA +@ stub RegDeleteKeyTransactedA +@ stub RegDeleteKeyTransactedW +@ stub RegDeleteKeyValueA +@ stub RegDeleteKeyValueW +@ stdcall RegDeleteKeyW() advapi32.RegDeleteKeyW +@ stdcall RegDisablePredefinedCache() advapi32.RegDisablePredefinedCache +@ stdcall RegEnumKeyA() advapi32.RegEnumKeyA +@ stdcall RegEnumKeyW() advapi32.RegEnumKeyW +@ stdcall RegOpenKeyA() advapi32.RegOpenKeyA +@ stub RegOpenKeyTransactedA +@ stub RegOpenKeyTransactedW +@ stdcall RegOpenKeyW() advapi32.RegOpenKeyW +@ stdcall RegOverridePredefKey() advapi32.RegOverridePredefKey +@ stdcall RegQueryMultipleValuesA() advapi32.RegQueryMultipleValuesA +@ stdcall RegQueryMultipleValuesW() advapi32.RegQueryMultipleValuesW +@ stdcall RegQueryValueA() advapi32.RegQueryValueA +@ stdcall RegQueryValueW() advapi32.RegQueryValueW +@ stdcall RegReplaceKeyA() advapi32.RegReplaceKeyA +@ stdcall RegReplaceKeyW() advapi32.RegReplaceKeyW +@ stdcall RegSaveKeyA() advapi32.RegSaveKeyA +@ stdcall RegSaveKeyW() advapi32.RegSaveKeyW +@ stub RegSetKeyValueA +@ stdcall RegSetKeyValueW() advapi32_vista.RegSetKeyValueW +@ stdcall RegSetValueA() advapi32.RegSetValueA +@ stdcall RegSetValueW() advapi32.RegSetValueW diff --git a/dll/apisets/api-ms-win-core-registryuserspecific-l1-1-0.spec b/dll/apisets/api-ms-win-core-registryuserspecific-l1-1-0.spec new file mode 100644 index 0000000000..4bf478001c --- /dev/null +++ b/dll/apisets/api-ms-win-core-registryuserspecific-l1-1-0.spec @@ -0,0 +1,28 @@ + +# This file is autogenerated by update.py + +@ stdcall SHRegCloseUSKey() shlwapi.SHRegCloseUSKey +@ stdcall SHRegCreateUSKeyA() shlwapi.SHRegCreateUSKeyA +@ stdcall SHRegCreateUSKeyW() shlwapi.SHRegCreateUSKeyW +@ stdcall SHRegDeleteEmptyUSKeyA() shlwapi.SHRegDeleteEmptyUSKeyA +@ stdcall SHRegDeleteEmptyUSKeyW() shlwapi.SHRegDeleteEmptyUSKeyW +@ stdcall SHRegDeleteUSValueA() shlwapi.SHRegDeleteUSValueA +@ stdcall SHRegDeleteUSValueW() shlwapi.SHRegDeleteUSValueW +@ stdcall SHRegEnumUSKeyA() shlwapi.SHRegEnumUSKeyA +@ stdcall SHRegEnumUSKeyW() shlwapi.SHRegEnumUSKeyW +@ stdcall SHRegEnumUSValueA() shlwapi.SHRegEnumUSValueA +@ stdcall SHRegEnumUSValueW() shlwapi.SHRegEnumUSValueW +@ stdcall SHRegGetBoolUSValueA() shlwapi.SHRegGetBoolUSValueA +@ stdcall SHRegGetBoolUSValueW() shlwapi.SHRegGetBoolUSValueW +@ stdcall SHRegGetUSValueA() shlwapi.SHRegGetUSValueA +@ stdcall SHRegGetUSValueW() shlwapi.SHRegGetUSValueW +@ stdcall SHRegOpenUSKeyA() shlwapi.SHRegOpenUSKeyA +@ stdcall SHRegOpenUSKeyW() shlwapi.SHRegOpenUSKeyW +@ stdcall SHRegQueryInfoUSKeyA() shlwapi.SHRegQueryInfoUSKeyA +@ stdcall SHRegQueryInfoUSKeyW() shlwapi.SHRegQueryInfoUSKeyW +@ stdcall SHRegQueryUSValueA() shlwapi.SHRegQueryUSValueA +@ stdcall SHRegQueryUSValueW() shlwapi.SHRegQueryUSValueW +@ stdcall SHRegSetUSValueA() shlwapi.SHRegSetUSValueA +@ stdcall SHRegSetUSValueW() shlwapi.SHRegSetUSValueW +@ stdcall SHRegWriteUSValueA() shlwapi.SHRegWriteUSValueA +@ stdcall SHRegWriteUSValueW() shlwapi.SHRegWriteUSValueW diff --git a/dll/apisets/api-ms-win-core-rtlsupport-l1-1-0.spec b/dll/apisets/api-ms-win-core-rtlsupport-l1-1-0.spec new file mode 100644 index 0000000000..ff395a693d --- /dev/null +++ b/dll/apisets/api-ms-win-core-rtlsupport-l1-1-0.spec @@ -0,0 +1,18 @@ + +# This file is autogenerated by update.py + +@ stdcall -arch=x86_64 RtlAddFunctionTable() ntdll.RtlAddFunctionTable +@ stdcall RtlCaptureContext() ntdll.RtlCaptureContext +@ stdcall RtlCaptureStackBackTrace() ntdll.RtlCaptureStackBackTrace +@ stdcall RtlCompareMemory() ntdll.RtlCompareMemory +@ stdcall -arch=x86_64 RtlCopyMemory() kernel32.RtlCopyMemory +@ stdcall -arch=x86_64 RtlDeleteFunctionTable() ntdll.RtlDeleteFunctionTable +@ stdcall RtlFillMemory() ntdll.RtlFillMemory +@ stdcall -arch=x86_64 RtlInstallFunctionTableCallback() ntdll.RtlInstallFunctionTableCallback +@ stdcall -arch=x86_64 RtlLookupFunctionEntry() ntdll.RtlLookupFunctionEntry +@ stdcall RtlPcToFileHeader() ntdll.RtlPcToFileHeader +@ stdcall RtlRaiseException() ntdll.RtlRaiseException +@ stdcall -arch=x86_64 RtlRestoreContext() ntdll.RtlRestoreContext +@ stdcall RtlUnwind() ntdll.RtlUnwind +@ stdcall -arch=x86_64 RtlUnwindEx() ntdll.RtlUnwindEx +@ stdcall -arch=x86_64 RtlVirtualUnwind() ntdll.RtlVirtualUnwind diff --git a/dll/apisets/api-ms-win-core-rtlsupport-l1-2-0.spec b/dll/apisets/api-ms-win-core-rtlsupport-l1-2-0.spec new file mode 100644 index 0000000000..c0ea5eafb6 --- /dev/null +++ b/dll/apisets/api-ms-win-core-rtlsupport-l1-2-0.spec @@ -0,0 +1,9 @@ + +# This file is autogenerated by update.py + +@ stdcall RtlCaptureContext() ntdll.RtlCaptureContext +@ stdcall RtlCaptureStackBackTrace() ntdll.RtlCaptureStackBackTrace +@ stdcall RtlCompareMemory() ntdll.RtlCompareMemory +@ stdcall RtlPcToFileHeader() ntdll.RtlPcToFileHeader +@ stdcall RtlRaiseException() ntdll.RtlRaiseException +@ stdcall RtlUnwind() ntdll.RtlUnwind diff --git a/dll/apisets/api-ms-win-core-shlwapi-legacy-l1-1-0.spec b/dll/apisets/api-ms-win-core-shlwapi-legacy-l1-1-0.spec new file mode 100644 index 0000000000..6669b2c6f1 --- /dev/null +++ b/dll/apisets/api-ms-win-core-shlwapi-legacy-l1-1-0.spec @@ -0,0 +1,91 @@ + +# This file is autogenerated by update.py + +@ stdcall IsCharBlankW() shlwapi.IsCharBlankW +@ stdcall IsCharCntrlW() shlwapi.IsCharCntrlW +@ stdcall IsCharDigitW() shlwapi.IsCharDigitW +@ stdcall IsCharPunctW() shlwapi.IsCharPunctW +@ stdcall IsCharSpaceA() shlwapi.IsCharSpaceA +@ stdcall IsCharSpaceW() shlwapi.IsCharSpaceW +@ stdcall IsCharXDigitW() shlwapi.IsCharXDigitW +@ stdcall PathAddBackslashA() shlwapi.PathAddBackslashA +@ stdcall PathAddBackslashW() shlwapi.PathAddBackslashW +@ stdcall PathAddExtensionA() shlwapi.PathAddExtensionA +@ stdcall PathAddExtensionW() shlwapi.PathAddExtensionW +@ stdcall PathAppendA() shlwapi.PathAppendA +@ stdcall PathAppendW() shlwapi.PathAppendW +@ stdcall PathCanonicalizeA() shlwapi.PathCanonicalizeA +@ stdcall PathCanonicalizeW() shlwapi.PathCanonicalizeW +@ stdcall PathCombineA() shlwapi.PathCombineA +@ stdcall PathCombineW() shlwapi.PathCombineW +@ stdcall PathCommonPrefixA() shlwapi.PathCommonPrefixA +@ stdcall PathCommonPrefixW() shlwapi.PathCommonPrefixW +@ stdcall PathFileExistsA() shlwapi.PathFileExistsA +@ stdcall PathFileExistsW() shlwapi.PathFileExistsW +@ stdcall PathFindExtensionA() shlwapi.PathFindExtensionA +@ stdcall PathFindExtensionW() shlwapi.PathFindExtensionW +@ stdcall PathFindFileNameA() shlwapi.PathFindFileNameA +@ stdcall PathFindFileNameW() shlwapi.PathFindFileNameW +@ stdcall PathFindNextComponentA() shlwapi.PathFindNextComponentA +@ stdcall PathFindNextComponentW() shlwapi.PathFindNextComponentW +@ stdcall PathGetArgsA() shlwapi.PathGetArgsA +@ stdcall PathGetArgsW() shlwapi.PathGetArgsW +@ stdcall PathGetCharTypeA() shlwapi.PathGetCharTypeA +@ stdcall PathGetCharTypeW() shlwapi.PathGetCharTypeW +@ stdcall PathGetDriveNumberA() shlwapi.PathGetDriveNumberA +@ stdcall PathGetDriveNumberW() shlwapi.PathGetDriveNumberW +@ stdcall PathIsFileSpecA() shlwapi.PathIsFileSpecA +@ stdcall PathIsFileSpecW() shlwapi.PathIsFileSpecW +@ stdcall PathIsLFNFileSpecA() shlwapi.PathIsLFNFileSpecA +@ stdcall PathIsLFNFileSpecW() shlwapi.PathIsLFNFileSpecW +@ stdcall PathIsPrefixA() shlwapi.PathIsPrefixA +@ stdcall PathIsPrefixW() shlwapi.PathIsPrefixW +@ stdcall PathIsRelativeA() shlwapi.PathIsRelativeA +@ stdcall PathIsRelativeW() shlwapi.PathIsRelativeW +@ stdcall PathIsRootA() shlwapi.PathIsRootA +@ stdcall PathIsRootW() shlwapi.PathIsRootW +@ stdcall PathIsSameRootA() shlwapi.PathIsSameRootA +@ stdcall PathIsSameRootW() shlwapi.PathIsSameRootW +@ stdcall PathIsUNCA() shlwapi.PathIsUNCA +@ stdcall PathIsUNCServerA() shlwapi.PathIsUNCServerA +@ stdcall PathIsUNCServerShareA() shlwapi.PathIsUNCServerShareA +@ stdcall PathIsUNCServerShareW() shlwapi.PathIsUNCServerShareW +@ stdcall PathIsUNCServerW() shlwapi.PathIsUNCServerW +@ stdcall PathIsUNCW() shlwapi.PathIsUNCW +@ stdcall PathIsValidCharA() shlwapi.PathIsValidCharA +@ stdcall PathIsValidCharW() shlwapi.PathIsValidCharW +@ stdcall PathMatchSpecA() shlwapi.PathMatchSpecA +@ stub PathMatchSpecExA +@ stub PathMatchSpecExW +@ stdcall PathMatchSpecW() shlwapi.PathMatchSpecW +@ stdcall PathParseIconLocationA() shlwapi.PathParseIconLocationA +@ stdcall PathParseIconLocationW() shlwapi.PathParseIconLocationW +@ stdcall PathQuoteSpacesA() shlwapi.PathQuoteSpacesA +@ stdcall PathQuoteSpacesW() shlwapi.PathQuoteSpacesW +@ stdcall PathRelativePathToA() shlwapi.PathRelativePathToA +@ stdcall PathRelativePathToW() shlwapi.PathRelativePathToW +@ stdcall PathRemoveBackslashA() shlwapi.PathRemoveBackslashA +@ stdcall PathRemoveBackslashW() shlwapi.PathRemoveBackslashW +@ stdcall PathRemoveBlanksA() shlwapi.PathRemoveBlanksA +@ stdcall PathRemoveBlanksW() shlwapi.PathRemoveBlanksW +@ stdcall PathRemoveExtensionA() shlwapi.PathRemoveExtensionA +@ stdcall PathRemoveExtensionW() shlwapi.PathRemoveExtensionW +@ stdcall PathRemoveFileSpecA() shlwapi.PathRemoveFileSpecA +@ stdcall PathRemoveFileSpecW() shlwapi.PathRemoveFileSpecW +@ stdcall PathRenameExtensionA() shlwapi.PathRenameExtensionA +@ stdcall PathRenameExtensionW() shlwapi.PathRenameExtensionW +@ stdcall PathSearchAndQualifyA() shlwapi.PathSearchAndQualifyA +@ stdcall PathSearchAndQualifyW() shlwapi.PathSearchAndQualifyW +@ stdcall PathSkipRootA() shlwapi.PathSkipRootA +@ stdcall PathSkipRootW() shlwapi.PathSkipRootW +@ stdcall PathStripPathA() shlwapi.PathStripPathA +@ stdcall PathStripPathW() shlwapi.PathStripPathW +@ stdcall PathStripToRootA() shlwapi.PathStripToRootA +@ stdcall PathStripToRootW() shlwapi.PathStripToRootW +@ stdcall PathUnExpandEnvStringsA() shlwapi.PathUnExpandEnvStringsA +@ stdcall PathUnExpandEnvStringsW() shlwapi.PathUnExpandEnvStringsW +@ stdcall PathUnquoteSpacesA() shlwapi.PathUnquoteSpacesA +@ stdcall PathUnquoteSpacesW() shlwapi.PathUnquoteSpacesW +@ stdcall SHExpandEnvironmentStringsA() shlwapi.SHExpandEnvironmentStringsA +@ stdcall SHExpandEnvironmentStringsW() shlwapi.SHExpandEnvironmentStringsW +@ stdcall SHTruncateString() shlwapi.SHTruncateString diff --git a/dll/apisets/api-ms-win-core-shlwapi-obsolete-l1-1-0.spec b/dll/apisets/api-ms-win-core-shlwapi-obsolete-l1-1-0.spec new file mode 100644 index 0000000000..b499089d8d --- /dev/null +++ b/dll/apisets/api-ms-win-core-shlwapi-obsolete-l1-1-0.spec @@ -0,0 +1,64 @@ + +# This file is autogenerated by update.py + +@ stdcall QISearch() shlwapi.QISearch +@ stdcall SHLoadIndirectString() shlwapi.SHLoadIndirectString +@ stdcall StrCSpnA() shlwapi.StrCSpnA +@ stdcall StrCSpnIA() shlwapi.StrCSpnIA +@ stdcall StrCSpnIW() shlwapi.StrCSpnIW +@ stdcall StrCSpnW() shlwapi.StrCSpnW +@ stdcall StrCatBuffA() shlwapi.StrCatBuffA +@ stdcall StrCatBuffW() shlwapi.StrCatBuffW +@ stdcall StrCatChainW() shlwapi.StrCatChainW +@ stdcall StrChrA() shlwapi.StrChrA +@ stdcall StrChrIA() shlwapi.StrChrIA +@ stdcall StrChrIW() shlwapi.StrChrIW +@ stdcall StrChrNIW() shlwapi.StrChrNIW +@ stdcall StrChrNW() shlwapi.StrChrNW +@ stdcall StrChrW() shlwapi.StrChrW +@ stdcall StrCmpCA() shlwapi.StrCmpCA +@ stdcall StrCmpCW() shlwapi.StrCmpCW +@ stdcall StrCmpICA() shlwapi.StrCmpICA +@ stdcall StrCmpICW() shlwapi.StrCmpICW +@ stdcall StrCmpIW() shlwapi.StrCmpIW +@ stdcall StrCmpLogicalW() shlwapi.StrCmpLogicalW +@ stdcall StrCmpNA() shlwapi.StrCmpNA +@ stdcall StrCmpNCA() shlwapi.StrCmpNCA +@ stdcall StrCmpNCW() shlwapi.StrCmpNCW +@ stdcall StrCmpNIA() shlwapi.StrCmpNIA +@ stdcall StrCmpNICA() shlwapi.StrCmpNICA +@ stdcall StrCmpNICW() shlwapi.StrCmpNICW +@ stdcall StrCmpNIW() shlwapi.StrCmpNIW +@ stdcall StrCmpNW() shlwapi.StrCmpNW +@ stdcall StrCmpW() shlwapi.StrCmpW +@ stdcall StrCpyNW() shlwapi.StrCpyNW +@ stdcall StrCpyNXA() shlwapi.StrCpyNXA +@ stdcall StrCpyNXW() shlwapi.StrCpyNXW +@ stdcall StrDupA() shlwapi.StrDupA +@ stdcall StrDupW() shlwapi.StrDupW +@ stdcall StrIsIntlEqualA() shlwapi.StrIsIntlEqualA +@ stdcall StrIsIntlEqualW() shlwapi.StrIsIntlEqualW +@ stdcall StrPBrkA() shlwapi.StrPBrkA +@ stdcall StrPBrkW() shlwapi.StrPBrkW +@ stdcall StrRChrA() shlwapi.StrRChrA +@ stdcall StrRChrIA() shlwapi.StrRChrIA +@ stdcall StrRChrIW() shlwapi.StrRChrIW +@ stdcall StrRChrW() shlwapi.StrRChrW +@ stdcall StrRStrIA() shlwapi.StrRStrIA +@ stdcall StrRStrIW() shlwapi.StrRStrIW +@ stdcall StrSpnA() shlwapi.StrSpnA +@ stdcall StrSpnW() shlwapi.StrSpnW +@ stdcall StrStrA() shlwapi.StrStrA +@ stdcall StrStrIA() shlwapi.StrStrIA +@ stdcall StrStrIW() shlwapi.StrStrIW +@ stdcall StrStrNIW() shlwapi.StrStrNIW +@ stdcall StrStrNW() shlwapi.StrStrNW +@ stdcall StrStrW() shlwapi.StrStrW +@ stdcall StrToInt64ExA() shlwapi.StrToInt64ExA +@ stdcall StrToInt64ExW() shlwapi.StrToInt64ExW +@ stdcall StrToIntA() shlwapi.StrToIntA +@ stdcall StrToIntExA() shlwapi.StrToIntExA +@ stdcall StrToIntExW() shlwapi.StrToIntExW +@ stdcall StrToIntW() shlwapi.StrToIntW +@ stdcall StrTrimA() shlwapi.StrTrimA +@ stdcall StrTrimW() shlwapi.StrTrimW diff --git a/dll/apisets/api-ms-win-core-shlwapi-obsolete-l1-2-0.spec b/dll/apisets/api-ms-win-core-shlwapi-obsolete-l1-2-0.spec new file mode 100644 index 0000000000..03826ce314 --- /dev/null +++ b/dll/apisets/api-ms-win-core-shlwapi-obsolete-l1-2-0.spec @@ -0,0 +1,61 @@ + +# This file is autogenerated by update.py + +@ stdcall QISearch() shlwapi.QISearch +@ stdcall StrCatBuffA() shlwapi.StrCatBuffA +@ stdcall StrCatBuffW() shlwapi.StrCatBuffW +@ stdcall StrCatChainW() shlwapi.StrCatChainW +@ stdcall StrChrA() shlwapi.StrChrA +@ stdcall StrChrIA() shlwapi.StrChrIA +@ stdcall StrChrIW() shlwapi.StrChrIW +@ stdcall StrChrNIW() shlwapi.StrChrNIW +@ stdcall StrChrNW() shlwapi.StrChrNW +@ stdcall StrChrW() shlwapi.StrChrW +@ stdcall StrCmpCA() shlwapi.StrCmpCA +@ stdcall StrCmpCW() shlwapi.StrCmpCW +@ stdcall StrCmpICA() shlwapi.StrCmpICA +@ stdcall StrCmpICW() shlwapi.StrCmpICW +@ stdcall StrCmpIW() shlwapi.StrCmpIW +@ stdcall StrCmpLogicalW() shlwapi.StrCmpLogicalW +@ stdcall StrCmpNA() shlwapi.StrCmpNA +@ stdcall StrCmpNCA() shlwapi.StrCmpNCA +@ stdcall StrCmpNCW() shlwapi.StrCmpNCW +@ stdcall StrCmpNIA() shlwapi.StrCmpNIA +@ stdcall StrCmpNICA() shlwapi.StrCmpNICA +@ stdcall StrCmpNICW() shlwapi.StrCmpNICW +@ stdcall StrCmpNIW() shlwapi.StrCmpNIW +@ stdcall StrCmpNW() shlwapi.StrCmpNW +@ stdcall StrCmpW() shlwapi.StrCmpW +@ stdcall StrCpyNW() shlwapi.StrCpyNW +@ stdcall StrCSpnA() shlwapi.StrCSpnA +@ stdcall StrCSpnIA() shlwapi.StrCSpnIA +@ stdcall StrCSpnIW() shlwapi.StrCSpnIW +@ stdcall StrCSpnW() shlwapi.StrCSpnW +@ stdcall StrDupA() shlwapi.StrDupA +@ stdcall StrDupW() shlwapi.StrDupW +@ stdcall StrIsIntlEqualA() shlwapi.StrIsIntlEqualA +@ stdcall StrIsIntlEqualW() shlwapi.StrIsIntlEqualW +@ stdcall StrPBrkA() shlwapi.StrPBrkA +@ stdcall StrPBrkW() shlwapi.StrPBrkW +@ stdcall StrRChrA() shlwapi.StrRChrA +@ stdcall StrRChrIA() shlwapi.StrRChrIA +@ stdcall StrRChrIW() shlwapi.StrRChrIW +@ stdcall StrRChrW() shlwapi.StrRChrW +@ stdcall StrRStrIA() shlwapi.StrRStrIA +@ stdcall StrRStrIW() shlwapi.StrRStrIW +@ stdcall StrSpnA() shlwapi.StrSpnA +@ stdcall StrSpnW() shlwapi.StrSpnW +@ stdcall StrStrA() shlwapi.StrStrA +@ stdcall StrStrIA() shlwapi.StrStrIA +@ stdcall StrStrIW() shlwapi.StrStrIW +@ stdcall StrStrNIW() shlwapi.StrStrNIW +@ stdcall StrStrNW() shlwapi.StrStrNW +@ stdcall StrStrW() shlwapi.StrStrW +@ stdcall StrToInt64ExA() shlwapi.StrToInt64ExA +@ stdcall StrToInt64ExW() shlwapi.StrToInt64ExW +@ stdcall StrToIntA() shlwapi.StrToIntA +@ stdcall StrToIntExA() shlwapi.StrToIntExA +@ stdcall StrToIntExW() shlwapi.StrToIntExW +@ stdcall StrToIntW() shlwapi.StrToIntW +@ stdcall StrTrimA() shlwapi.StrTrimA +@ stdcall StrTrimW() shlwapi.StrTrimW diff --git a/dll/apisets/api-ms-win-core-shutdown-l1-1-0.spec b/dll/apisets/api-ms-win-core-shutdown-l1-1-0.spec new file mode 100644 index 0000000000..7990761f7e --- /dev/null +++ b/dll/apisets/api-ms-win-core-shutdown-l1-1-0.spec @@ -0,0 +1,5 @@ + +# This file is autogenerated by update.py + +@ stdcall AbortSystemShutdownW() advapi32.AbortSystemShutdownW +@ stdcall InitiateSystemShutdownExW() advapi32.InitiateSystemShutdownExW diff --git a/dll/apisets/api-ms-win-core-sidebyside-l1-1-0.spec b/dll/apisets/api-ms-win-core-sidebyside-l1-1-0.spec new file mode 100644 index 0000000000..8d76eb782a --- /dev/null +++ b/dll/apisets/api-ms-win-core-sidebyside-l1-1-0.spec @@ -0,0 +1,14 @@ + +# This file is autogenerated by update.py + +@ stdcall ActivateActCtx() kernel32.ActivateActCtx +@ stdcall AddRefActCtx() kernel32.AddRefActCtx +@ stdcall CreateActCtxW() kernel32.CreateActCtxW +@ stdcall DeactivateActCtx() kernel32.DeactivateActCtx +@ stdcall FindActCtxSectionGuid() kernel32.FindActCtxSectionGuid +@ stdcall FindActCtxSectionStringW() kernel32.FindActCtxSectionStringW +@ stdcall GetCurrentActCtx() kernel32.GetCurrentActCtx +@ stub QueryActCtxSettingsW +@ stdcall QueryActCtxW() kernel32.QueryActCtxW +@ stdcall ReleaseActCtx() kernel32.ReleaseActCtx +@ stdcall ZombifyActCtx() kernel32.ZombifyActCtx diff --git a/dll/apisets/api-ms-win-core-string-l1-1-0.spec b/dll/apisets/api-ms-win-core-string-l1-1-0.spec new file mode 100644 index 0000000000..6ccfec6250 --- /dev/null +++ b/dll/apisets/api-ms-win-core-string-l1-1-0.spec @@ -0,0 +1,11 @@ + +# This file is autogenerated by update.py + +@ stub CompareStringEx +@ stub CompareStringOrdinal +@ stdcall CompareStringW() kernel32.CompareStringW +@ stdcall FoldStringW() kernel32.FoldStringW +@ stdcall GetStringTypeExW() kernel32.GetStringTypeExW +@ stdcall GetStringTypeW() kernel32.GetStringTypeW +@ stdcall MultiByteToWideChar() kernel32.MultiByteToWideChar +@ stdcall WideCharToMultiByte() kernel32.WideCharToMultiByte diff --git a/dll/apisets/api-ms-win-core-string-l2-1-0.spec b/dll/apisets/api-ms-win-core-string-l2-1-0.spec new file mode 100644 index 0000000000..6c3ea35a1a --- /dev/null +++ b/dll/apisets/api-ms-win-core-string-l2-1-0.spec @@ -0,0 +1,13 @@ + +# This file is autogenerated by update.py + +@ stdcall CharLowerBuffW() user32.CharLowerBuffW +@ stdcall CharLowerW() user32.CharLowerW +@ stdcall CharNextW() user32.CharNextW +@ stdcall CharPrevW() user32.CharPrevW +@ stdcall CharUpperBuffW() user32.CharUpperBuffW +@ stdcall CharUpperW() user32.CharUpperW +@ stdcall IsCharAlphaNumericW() user32.IsCharAlphaNumericW +@ stdcall IsCharAlphaW() user32.IsCharAlphaW +@ stdcall IsCharLowerW() user32.IsCharLowerW +@ stdcall IsCharUpperW() user32.IsCharUpperW diff --git a/dll/apisets/api-ms-win-core-string-obsolete-l1-1-0.spec b/dll/apisets/api-ms-win-core-string-obsolete-l1-1-0.spec new file mode 100644 index 0000000000..d7fa689dc6 --- /dev/null +++ b/dll/apisets/api-ms-win-core-string-obsolete-l1-1-0.spec @@ -0,0 +1,13 @@ + +# This file is autogenerated by update.py + +@ stdcall lstrcatW() kernel32.lstrcatW +@ stdcall lstrcmpA() kernel32.lstrcmpA +@ stdcall lstrcmpW() kernel32.lstrcmpW +@ stdcall lstrcmpiA() kernel32.lstrcmpiA +@ stdcall lstrcmpiW() kernel32.lstrcmpiW +@ stdcall lstrcpyW() kernel32.lstrcpyW +@ stdcall lstrcpynA() kernel32.lstrcpynA +@ stdcall lstrcpynW() kernel32.lstrcpynW +@ stdcall lstrlenA() kernel32.lstrlenA +@ stdcall lstrlenW() kernel32.lstrlenW diff --git a/dll/apisets/api-ms-win-core-stringansi-l1-1-0.spec b/dll/apisets/api-ms-win-core-stringansi-l1-1-0.spec new file mode 100644 index 0000000000..981a196b8d --- /dev/null +++ b/dll/apisets/api-ms-win-core-stringansi-l1-1-0.spec @@ -0,0 +1,15 @@ + +# This file is autogenerated by update.py + +@ stdcall CharLowerA() user32.CharLowerA +@ stdcall CharLowerBuffA() user32.CharLowerBuffA +@ stdcall CharNextA() user32.CharNextA +@ stdcall CharNextExA() user32.CharNextExA +@ stdcall CharPrevA() user32.CharPrevA +@ stdcall CharPrevExA() user32.CharPrevExA +@ stdcall CharUpperA() user32.CharUpperA +@ stdcall CharUpperBuffA() user32.CharUpperBuffA +@ stdcall IsCharAlphaA() user32.IsCharAlphaA +@ stdcall IsCharAlphaNumericA() user32.IsCharAlphaNumericA +@ stdcall IsCharLowerA() user32.IsCharLowerA +@ stdcall IsCharUpperA() user32.IsCharUpperA diff --git a/dll/apisets/api-ms-win-core-synch-ansi-l1-1-0.spec b/dll/apisets/api-ms-win-core-synch-ansi-l1-1-0.spec new file mode 100644 index 0000000000..676d1ddd19 --- /dev/null +++ b/dll/apisets/api-ms-win-core-synch-ansi-l1-1-0.spec @@ -0,0 +1,10 @@ + +# This file is autogenerated by update.py + +@ stdcall CreateSemaphoreA() kernel32.CreateSemaphoreA +@ stub CreateSemaphoreExA +@ stdcall CreateWaitableTimerA() kernel32.CreateWaitableTimerA +@ stub CreateWaitableTimerExA +@ stdcall OpenMutexA() kernel32.OpenMutexA +@ stdcall OpenSemaphoreA() kernel32.OpenSemaphoreA +@ stdcall OpenWaitableTimerA() kernel32.OpenWaitableTimerA diff --git a/dll/apisets/api-ms-win-core-synch-l1-1-0.spec b/dll/apisets/api-ms-win-core-synch-l1-1-0.spec new file mode 100644 index 0000000000..ab22da2ec4 --- /dev/null +++ b/dll/apisets/api-ms-win-core-synch-l1-1-0.spec @@ -0,0 +1,45 @@ + +# This file is autogenerated by update.py + +@ stdcall AcquireSRWLockExclusive() kernel32_vista.AcquireSRWLockExclusive +@ stdcall AcquireSRWLockShared() kernel32_vista.AcquireSRWLockShared +@ stdcall CancelWaitableTimer() kernel32.CancelWaitableTimer +@ stdcall CreateEventA() kernel32.CreateEventA +@ stub CreateEventExA +@ stub CreateEventExW +@ stdcall CreateEventW() kernel32.CreateEventW +@ stdcall CreateMutexA() kernel32.CreateMutexA +@ stub CreateMutexExA +@ stub CreateMutexExW +@ stdcall CreateMutexW() kernel32.CreateMutexW +@ stub CreateSemaphoreExW +@ stub CreateWaitableTimerExW +@ stdcall DeleteCriticalSection() kernel32.DeleteCriticalSection +@ stdcall EnterCriticalSection() kernel32.EnterCriticalSection +@ stdcall InitializeCriticalSection() kernel32.InitializeCriticalSection +@ stdcall InitializeCriticalSectionAndSpinCount() kernel32.InitializeCriticalSectionAndSpinCount +@ stub InitializeCriticalSectionEx +@ stdcall InitializeSRWLock() kernel32_vista.InitializeSRWLock +@ stdcall LeaveCriticalSection() kernel32.LeaveCriticalSection +@ stdcall OpenEventA() kernel32.OpenEventA +@ stdcall OpenEventW() kernel32.OpenEventW +@ stdcall OpenMutexW() kernel32.OpenMutexW +@ stdcall OpenProcess() kernel32.OpenProcess +@ stdcall OpenSemaphoreW() kernel32.OpenSemaphoreW +@ stdcall OpenWaitableTimerW() kernel32.OpenWaitableTimerW +@ stdcall ReleaseMutex() kernel32.ReleaseMutex +@ stdcall ReleaseSRWLockExclusive() kernel32_vista.ReleaseSRWLockExclusive +@ stdcall ReleaseSRWLockShared() kernel32_vista.ReleaseSRWLockShared +@ stdcall ReleaseSemaphore() kernel32.ReleaseSemaphore +@ stdcall ResetEvent() kernel32.ResetEvent +@ stdcall SetCriticalSectionSpinCount() kernel32.SetCriticalSectionSpinCount +@ stdcall SetEvent() kernel32.SetEvent +@ stdcall SetWaitableTimer() kernel32.SetWaitableTimer +@ stub SetWaitableTimerEx +@ stdcall SleepEx() kernel32.SleepEx +@ stub TryAcquireSRWLockExclusive +@ stub TryAcquireSRWLockShared +@ stdcall TryEnterCriticalSection() kernel32.TryEnterCriticalSection +@ stdcall WaitForMultipleObjectsEx() kernel32.WaitForMultipleObjectsEx +@ stdcall WaitForSingleObject() kernel32.WaitForSingleObject +@ stdcall WaitForSingleObjectEx() kernel32.WaitForSingleObjectEx diff --git a/dll/apisets/api-ms-win-core-synch-l1-2-0.spec b/dll/apisets/api-ms-win-core-synch-l1-2-0.spec new file mode 100644 index 0000000000..78f9a6137c --- /dev/null +++ b/dll/apisets/api-ms-win-core-synch-l1-2-0.spec @@ -0,0 +1,61 @@ + +# This file is autogenerated by update.py + +@ stdcall AcquireSRWLockExclusive() kernel32_vista.AcquireSRWLockExclusive +@ stdcall AcquireSRWLockShared() kernel32_vista.AcquireSRWLockShared +@ stdcall CancelWaitableTimer() kernel32.CancelWaitableTimer +@ stdcall CreateEventA() kernel32.CreateEventA +@ stub CreateEventExA +@ stub CreateEventExW +@ stdcall CreateEventW() kernel32.CreateEventW +@ stdcall CreateMutexA() kernel32.CreateMutexA +@ stub CreateMutexExA +@ stub CreateMutexExW +@ stdcall CreateMutexW() kernel32.CreateMutexW +@ stub CreateSemaphoreExW +@ stub CreateWaitableTimerExW +@ stdcall DeleteCriticalSection() kernel32.DeleteCriticalSection +@ stub DeleteSynchronizationBarrier +@ stdcall EnterCriticalSection() kernel32.EnterCriticalSection +@ stub EnterSynchronizationBarrier +@ stub InitOnceBeginInitialize +@ stub InitOnceComplete +@ stdcall InitOnceExecuteOnce() kernel32_vista.InitOnceExecuteOnce +@ stub InitOnceInitialize +@ stdcall InitializeConditionVariable() kernel32_vista.InitializeConditionVariable +@ stdcall InitializeCriticalSection() kernel32.InitializeCriticalSection +@ stdcall InitializeCriticalSectionAndSpinCount() kernel32.InitializeCriticalSectionAndSpinCount +@ stub InitializeCriticalSectionEx +@ stdcall InitializeSRWLock() kernel32_vista.InitializeSRWLock +@ stub InitializeSynchronizationBarrier +@ stdcall LeaveCriticalSection() kernel32.LeaveCriticalSection +@ stdcall OpenEventA() kernel32.OpenEventA +@ stdcall OpenEventW() kernel32.OpenEventW +@ stdcall OpenMutexW() kernel32.OpenMutexW +@ stdcall OpenSemaphoreW() kernel32.OpenSemaphoreW +@ stdcall OpenWaitableTimerW() kernel32.OpenWaitableTimerW +@ stdcall ReleaseMutex() kernel32.ReleaseMutex +@ stdcall ReleaseSRWLockExclusive() kernel32_vista.ReleaseSRWLockExclusive +@ stdcall ReleaseSRWLockShared() kernel32_vista.ReleaseSRWLockShared +@ stdcall ReleaseSemaphore() kernel32.ReleaseSemaphore +@ stdcall ResetEvent() kernel32.ResetEvent +@ stdcall SetCriticalSectionSpinCount() kernel32.SetCriticalSectionSpinCount +@ stdcall SetEvent() kernel32.SetEvent +@ stdcall SetWaitableTimer() kernel32.SetWaitableTimer +@ stub SetWaitableTimerEx +@ stdcall SignalObjectAndWait() kernel32.SignalObjectAndWait +@ stdcall Sleep() kernel32.Sleep +@ stdcall SleepConditionVariableCS() kernel32_vista.SleepConditionVariableCS +@ stdcall SleepConditionVariableSRW() kernel32_vista.SleepConditionVariableSRW +@ stdcall SleepEx() kernel32.SleepEx +@ stub TryAcquireSRWLockExclusive +@ stub TryAcquireSRWLockShared +@ stdcall TryEnterCriticalSection() kernel32.TryEnterCriticalSection +@ stdcall WaitForMultipleObjectsEx() kernel32.WaitForMultipleObjectsEx +@ stdcall WaitForSingleObject() kernel32.WaitForSingleObject +@ stdcall WaitForSingleObjectEx() kernel32.WaitForSingleObjectEx +@ stub WaitOnAddress +@ stdcall WakeAllConditionVariable() kernel32_vista.WakeAllConditionVariable +@ stub WakeByAddressAll +@ stub WakeByAddressSingle +@ stdcall WakeConditionVariable() kernel32_vista.WakeConditionVariable diff --git a/dll/apisets/api-ms-win-core-synch-l1-2-1.spec b/dll/apisets/api-ms-win-core-synch-l1-2-1.spec new file mode 100644 index 0000000000..37270fd434 --- /dev/null +++ b/dll/apisets/api-ms-win-core-synch-l1-2-1.spec @@ -0,0 +1,64 @@ + +# This file is autogenerated by update.py + +@ stdcall AcquireSRWLockExclusive() kernel32_vista.AcquireSRWLockExclusive +@ stdcall AcquireSRWLockShared() kernel32_vista.AcquireSRWLockShared +@ stdcall CancelWaitableTimer() kernel32.CancelWaitableTimer +@ stdcall CreateEventA() kernel32.CreateEventA +@ stub CreateEventExA +@ stub CreateEventExW +@ stdcall CreateEventW() kernel32.CreateEventW +@ stdcall CreateMutexA() kernel32.CreateMutexA +@ stub CreateMutexExA +@ stub CreateMutexExW +@ stdcall CreateMutexW() kernel32.CreateMutexW +@ stub CreateSemaphoreExW +@ stdcall CreateSemaphoreW() kernel32.CreateSemaphoreW +@ stub CreateWaitableTimerExW +@ stdcall CreateWaitableTimerW() kernel32.CreateWaitableTimerW +@ stdcall DeleteCriticalSection() kernel32.DeleteCriticalSection +@ stub DeleteSynchronizationBarrier +@ stdcall EnterCriticalSection() kernel32.EnterCriticalSection +@ stub EnterSynchronizationBarrier +@ stdcall InitializeConditionVariable() kernel32_vista.InitializeConditionVariable +@ stdcall InitializeCriticalSection() kernel32.InitializeCriticalSection +@ stdcall InitializeCriticalSectionAndSpinCount() kernel32.InitializeCriticalSectionAndSpinCount +@ stub InitializeCriticalSectionEx +@ stdcall InitializeSRWLock() kernel32_vista.InitializeSRWLock +@ stub InitializeSynchronizationBarrier +@ stub InitOnceBeginInitialize +@ stub InitOnceComplete +@ stdcall InitOnceExecuteOnce() kernel32_vista.InitOnceExecuteOnce +@ stub InitOnceInitialize +@ stdcall LeaveCriticalSection() kernel32.LeaveCriticalSection +@ stdcall OpenEventA() kernel32.OpenEventA +@ stdcall OpenEventW() kernel32.OpenEventW +@ stdcall OpenMutexW() kernel32.OpenMutexW +@ stdcall OpenSemaphoreW() kernel32.OpenSemaphoreW +@ stdcall OpenWaitableTimerW() kernel32.OpenWaitableTimerW +@ stdcall ReleaseMutex() kernel32.ReleaseMutex +@ stdcall ReleaseSemaphore() kernel32.ReleaseSemaphore +@ stdcall ReleaseSRWLockExclusive() kernel32_vista.ReleaseSRWLockExclusive +@ stdcall ReleaseSRWLockShared() kernel32_vista.ReleaseSRWLockShared +@ stdcall ResetEvent() kernel32.ResetEvent +@ stdcall SetCriticalSectionSpinCount() kernel32.SetCriticalSectionSpinCount +@ stdcall SetEvent() kernel32.SetEvent +@ stdcall SetWaitableTimer() kernel32.SetWaitableTimer +@ stub SetWaitableTimerEx +@ stdcall SignalObjectAndWait() kernel32.SignalObjectAndWait +@ stdcall Sleep() kernel32.Sleep +@ stdcall SleepConditionVariableCS() kernel32_vista.SleepConditionVariableCS +@ stdcall SleepConditionVariableSRW() kernel32_vista.SleepConditionVariableSRW +@ stdcall SleepEx() kernel32.SleepEx +@ stub TryAcquireSRWLockExclusive +@ stub TryAcquireSRWLockShared +@ stdcall TryEnterCriticalSection() kernel32.TryEnterCriticalSection +@ stdcall WaitForMultipleObjects() kernel32.WaitForMultipleObjects +@ stdcall WaitForMultipleObjectsEx() kernel32.WaitForMultipleObjectsEx +@ stdcall WaitForSingleObject() kernel32.WaitForSingleObject +@ stdcall WaitForSingleObjectEx() kernel32.WaitForSingleObjectEx +@ stub WaitOnAddress +@ stdcall WakeAllConditionVariable() kernel32_vista.WakeAllConditionVariable +@ stub WakeByAddressAll +@ stub WakeByAddressSingle +@ stdcall WakeConditionVariable() kernel32_vista.WakeConditionVariable diff --git a/dll/apisets/api-ms-win-core-sysinfo-l1-1-0.spec b/dll/apisets/api-ms-win-core-sysinfo-l1-1-0.spec new file mode 100644 index 0000000000..c236b11d63 --- /dev/null +++ b/dll/apisets/api-ms-win-core-sysinfo-l1-1-0.spec @@ -0,0 +1,31 @@ + +# This file is autogenerated by update.py + +@ stdcall GetComputerNameExA() kernel32.GetComputerNameExA +@ stdcall GetComputerNameExW() kernel32.GetComputerNameExW +@ stub GetDynamicTimeZoneInformation +@ stdcall GetLocalTime() kernel32.GetLocalTime +@ stdcall GetLogicalProcessorInformation() kernel32.GetLogicalProcessorInformation +@ stub GetLogicalProcessorInformationEx +@ stdcall GetSystemDirectoryA() kernel32.GetSystemDirectoryA +@ stdcall GetSystemDirectoryW() kernel32.GetSystemDirectoryW +@ stdcall GetSystemInfo() kernel32.GetSystemInfo +@ stdcall GetSystemTime() kernel32.GetSystemTime +@ stdcall GetSystemTimeAdjustment() kernel32.GetSystemTimeAdjustment +@ stdcall GetSystemTimeAsFileTime() kernel32.GetSystemTimeAsFileTime +@ stdcall GetSystemWindowsDirectoryA() kernel32.GetSystemWindowsDirectoryA +@ stdcall GetSystemWindowsDirectoryW() kernel32.GetSystemWindowsDirectoryW +@ stdcall GetTickCount64() kernel32_vista.GetTickCount64 +@ stdcall GetTickCount() kernel32.GetTickCount +@ stdcall GetTimeZoneInformation() kernel32.GetTimeZoneInformation +@ stub GetTimeZoneInformationForYear +@ stdcall GetVersion() kernel32.GetVersion +@ stdcall GetVersionExA() kernel32.GetVersionExA +@ stdcall GetVersionExW() kernel32.GetVersionExW +@ stdcall GetWindowsDirectoryA() kernel32.GetWindowsDirectoryA +@ stdcall GetWindowsDirectoryW() kernel32.GetWindowsDirectoryW +@ stdcall GlobalMemoryStatusEx() kernel32.GlobalMemoryStatusEx +@ stdcall SetLocalTime() kernel32.SetLocalTime +@ stdcall SystemTimeToFileTime() kernel32.SystemTimeToFileTime +@ stdcall SystemTimeToTzSpecificLocalTime() kernel32.SystemTimeToTzSpecificLocalTime +@ stdcall TzSpecificLocalTimeToSystemTime() kernel32.TzSpecificLocalTimeToSystemTime diff --git a/dll/apisets/api-ms-win-core-sysinfo-l1-2-0.spec b/dll/apisets/api-ms-win-core-sysinfo-l1-2-0.spec new file mode 100644 index 0000000000..ade8822cd6 --- /dev/null +++ b/dll/apisets/api-ms-win-core-sysinfo-l1-2-0.spec @@ -0,0 +1,34 @@ + +# This file is autogenerated by update.py + +@ stdcall EnumSystemFirmwareTables() kernel32.EnumSystemFirmwareTables +@ stdcall GetComputerNameExA() kernel32.GetComputerNameExA +@ stdcall GetComputerNameExW() kernel32.GetComputerNameExW +@ stdcall GetLocalTime() kernel32.GetLocalTime +@ stdcall GetLogicalProcessorInformation() kernel32.GetLogicalProcessorInformation +@ stub GetLogicalProcessorInformationEx +@ stdcall GetNativeSystemInfo() kernel32.GetNativeSystemInfo +@ stub GetOsSafeBootMode +@ stub GetProductInfo +@ stdcall GetSystemDirectoryA() kernel32.GetSystemDirectoryA +@ stdcall GetSystemDirectoryW() kernel32.GetSystemDirectoryW +@ stdcall GetSystemFirmwareTable() kernel32.GetSystemFirmwareTable +@ stdcall GetSystemInfo() kernel32.GetSystemInfo +@ stdcall GetSystemTime() kernel32.GetSystemTime +@ stdcall GetSystemTimeAdjustment() kernel32.GetSystemTimeAdjustment +@ stdcall GetSystemTimeAsFileTime() kernel32.GetSystemTimeAsFileTime +@ stub GetSystemTimePreciseAsFileTime +@ stdcall GetSystemWindowsDirectoryA() kernel32.GetSystemWindowsDirectoryA +@ stdcall GetSystemWindowsDirectoryW() kernel32.GetSystemWindowsDirectoryW +@ stdcall GetTickCount() kernel32.GetTickCount +@ stdcall GetTickCount64() kernel32_vista.GetTickCount64 +@ stdcall GetVersion() kernel32.GetVersion +@ stdcall GetVersionExA() kernel32.GetVersionExA +@ stdcall GetVersionExW() kernel32.GetVersionExW +@ stdcall GetWindowsDirectoryA() kernel32.GetWindowsDirectoryA +@ stdcall GetWindowsDirectoryW() kernel32.GetWindowsDirectoryW +@ stdcall GlobalMemoryStatusEx() kernel32.GlobalMemoryStatusEx +@ stdcall SetComputerNameExW() kernel32.SetComputerNameExW +@ stdcall SetLocalTime() kernel32.SetLocalTime +@ stdcall SetSystemTime() kernel32.SetSystemTime +@ stdcall VerSetConditionMask() kernel32.VerSetConditionMask diff --git a/dll/apisets/api-ms-win-core-sysinfo-l1-2-1.spec b/dll/apisets/api-ms-win-core-sysinfo-l1-2-1.spec new file mode 100644 index 0000000000..d0e19b6b74 --- /dev/null +++ b/dll/apisets/api-ms-win-core-sysinfo-l1-2-1.spec @@ -0,0 +1,39 @@ + +# This file is autogenerated by update.py + +@ stub DnsHostnameToComputerNameExW +@ stdcall EnumSystemFirmwareTables() kernel32.EnumSystemFirmwareTables +@ stdcall GetComputerNameExA() kernel32.GetComputerNameExA +@ stdcall GetComputerNameExW() kernel32.GetComputerNameExW +@ stdcall GetLocalTime() kernel32.GetLocalTime +@ stdcall GetLogicalProcessorInformation() kernel32.GetLogicalProcessorInformation +@ stub GetLogicalProcessorInformationEx +@ stdcall GetNativeSystemInfo() kernel32.GetNativeSystemInfo +@ stub GetOsSafeBootMode +@ stub GetPhysicallyInstalledSystemMemory +@ stub GetProductInfo +@ stdcall GetSystemDirectoryA() kernel32.GetSystemDirectoryA +@ stdcall GetSystemDirectoryW() kernel32.GetSystemDirectoryW +@ stdcall GetSystemFirmwareTable() kernel32.GetSystemFirmwareTable +@ stdcall GetSystemInfo() kernel32.GetSystemInfo +@ stdcall GetSystemTime() kernel32.GetSystemTime +@ stdcall GetSystemTimeAdjustment() kernel32.GetSystemTimeAdjustment +@ stdcall GetSystemTimeAsFileTime() kernel32.GetSystemTimeAsFileTime +@ stub GetSystemTimePreciseAsFileTime +@ stdcall GetSystemWindowsDirectoryA() kernel32.GetSystemWindowsDirectoryA +@ stdcall GetSystemWindowsDirectoryW() kernel32.GetSystemWindowsDirectoryW +@ stdcall GetTickCount64() kernel32_vista.GetTickCount64 +@ stdcall GetTickCount() kernel32.GetTickCount +@ stdcall GetVersion() kernel32.GetVersion +@ stdcall GetVersionExA() kernel32.GetVersionExA +@ stdcall GetVersionExW() kernel32.GetVersionExW +@ stdcall GetWindowsDirectoryA() kernel32.GetWindowsDirectoryA +@ stdcall GetWindowsDirectoryW() kernel32.GetWindowsDirectoryW +@ stdcall GlobalMemoryStatusEx() kernel32.GlobalMemoryStatusEx +@ stub InstallELAMCertificateInfo +@ stub SetComputerNameEx2W +@ stdcall SetComputerNameExW() kernel32.SetComputerNameExW +@ stdcall SetLocalTime() kernel32.SetLocalTime +@ stdcall SetSystemTime() kernel32.SetSystemTime +@ stdcall SetSystemTimeAdjustment() kernel32.SetSystemTimeAdjustment +@ stdcall VerSetConditionMask() kernel32.VerSetConditionMask diff --git a/dll/apisets/api-ms-win-core-threadpool-l1-1-0.spec b/dll/apisets/api-ms-win-core-threadpool-l1-1-0.spec new file mode 100644 index 0000000000..9f3119366e --- /dev/null +++ b/dll/apisets/api-ms-win-core-threadpool-l1-1-0.spec @@ -0,0 +1,45 @@ + +# This file is autogenerated by update.py + +@ stub CallbackMayRunLong +@ stub CancelThreadpoolIo +@ stdcall ChangeTimerQueueTimer() kernel32.ChangeTimerQueueTimer +@ stub CloseThreadpool +@ stub CloseThreadpoolCleanupGroup +@ stub CloseThreadpoolCleanupGroupMembers +@ stub CloseThreadpoolIo +@ stub CloseThreadpoolTimer +@ stub CloseThreadpoolWait +@ stub CloseThreadpoolWork +@ stub CreateThreadpool +@ stub CreateThreadpoolCleanupGroup +@ stub CreateThreadpoolIo +@ stub CreateThreadpoolTimer +@ stub CreateThreadpoolWait +@ stub CreateThreadpoolWork +@ stdcall CreateTimerQueue() kernel32.CreateTimerQueue +@ stdcall CreateTimerQueueTimer() kernel32.CreateTimerQueueTimer +@ stdcall DeleteTimerQueueEx() kernel32.DeleteTimerQueueEx +@ stdcall DeleteTimerQueueTimer() kernel32.DeleteTimerQueueTimer +@ stub DisassociateCurrentThreadFromCallback +@ stub FreeLibraryWhenCallbackReturns +@ stub IsThreadpoolTimerSet +@ stub LeaveCriticalSectionWhenCallbackReturns +@ stub QueryThreadpoolStackInformation +@ stdcall RegisterWaitForSingleObjectEx() kernel32.RegisterWaitForSingleObjectEx +@ stub ReleaseMutexWhenCallbackReturns +@ stub ReleaseSemaphoreWhenCallbackReturns +@ stub SetEventWhenCallbackReturns +@ stub SetThreadpoolStackInformation +@ stub SetThreadpoolThreadMaximum +@ stub SetThreadpoolThreadMinimum +@ stub SetThreadpoolTimer +@ stub SetThreadpoolWait +@ stub StartThreadpoolIo +@ stub SubmitThreadpoolWork +@ stub TrySubmitThreadpoolCallback +@ stdcall UnregisterWaitEx() kernel32.UnregisterWaitEx +@ stub WaitForThreadpoolIoCallbacks +@ stub WaitForThreadpoolTimerCallbacks +@ stub WaitForThreadpoolWaitCallbacks +@ stub WaitForThreadpoolWorkCallbacks diff --git a/dll/apisets/api-ms-win-core-threadpool-l1-2-0.spec b/dll/apisets/api-ms-win-core-threadpool-l1-2-0.spec new file mode 100644 index 0000000000..7ff5a8214c --- /dev/null +++ b/dll/apisets/api-ms-win-core-threadpool-l1-2-0.spec @@ -0,0 +1,40 @@ + +# This file is autogenerated by update.py + +@ stub CallbackMayRunLong +@ stub CancelThreadpoolIo +@ stub CloseThreadpool +@ stub CloseThreadpoolCleanupGroup +@ stub CloseThreadpoolCleanupGroupMembers +@ stub CloseThreadpoolIo +@ stub CloseThreadpoolTimer +@ stub CloseThreadpoolWait +@ stub CloseThreadpoolWork +@ stub CreateThreadpool +@ stub CreateThreadpoolCleanupGroup +@ stub CreateThreadpoolIo +@ stub CreateThreadpoolTimer +@ stub CreateThreadpoolWait +@ stub CreateThreadpoolWork +@ stub DisassociateCurrentThreadFromCallback +@ stub FreeLibraryWhenCallbackReturns +@ stub IsThreadpoolTimerSet +@ stub LeaveCriticalSectionWhenCallbackReturns +@ stub QueryThreadpoolStackInformation +@ stub ReleaseMutexWhenCallbackReturns +@ stub ReleaseSemaphoreWhenCallbackReturns +@ stub SetEventWhenCallbackReturns +@ stub SetThreadpoolStackInformation +@ stub SetThreadpoolThreadMaximum +@ stub SetThreadpoolThreadMinimum +@ stub SetThreadpoolTimer +@ stub SetThreadpoolTimerEx +@ stub SetThreadpoolWait +@ stub SetThreadpoolWaitEx +@ stub StartThreadpoolIo +@ stub SubmitThreadpoolWork +@ stub TrySubmitThreadpoolCallback +@ stub WaitForThreadpoolIoCallbacks +@ stub WaitForThreadpoolTimerCallbacks +@ stub WaitForThreadpoolWaitCallbacks +@ stub WaitForThreadpoolWorkCallbacks diff --git a/dll/apisets/api-ms-win-core-threadpool-legacy-l1-1-0.spec b/dll/apisets/api-ms-win-core-threadpool-legacy-l1-1-0.spec new file mode 100644 index 0000000000..e01181b635 --- /dev/null +++ b/dll/apisets/api-ms-win-core-threadpool-legacy-l1-1-0.spec @@ -0,0 +1,10 @@ + +# This file is autogenerated by update.py + +@ stdcall ChangeTimerQueueTimer() kernel32.ChangeTimerQueueTimer +@ stdcall CreateTimerQueue() kernel32.CreateTimerQueue +@ stdcall CreateTimerQueueTimer() kernel32.CreateTimerQueueTimer +@ stdcall DeleteTimerQueueEx() kernel32.DeleteTimerQueueEx +@ stdcall DeleteTimerQueueTimer() kernel32.DeleteTimerQueueTimer +@ stdcall QueueUserWorkItem() kernel32.QueueUserWorkItem +@ stdcall UnregisterWaitEx() kernel32.UnregisterWaitEx diff --git a/dll/apisets/api-ms-win-core-threadpool-private-l1-1-0.spec b/dll/apisets/api-ms-win-core-threadpool-private-l1-1-0.spec new file mode 100644 index 0000000000..ff7e02b644 --- /dev/null +++ b/dll/apisets/api-ms-win-core-threadpool-private-l1-1-0.spec @@ -0,0 +1,4 @@ + +# This file is autogenerated by update.py + +@ stdcall RegisterWaitForSingleObjectEx() kernel32.RegisterWaitForSingleObjectEx diff --git a/dll/apisets/api-ms-win-core-timezone-l1-1-0.spec b/dll/apisets/api-ms-win-core-timezone-l1-1-0.spec new file mode 100644 index 0000000000..11fea2dae1 --- /dev/null +++ b/dll/apisets/api-ms-win-core-timezone-l1-1-0.spec @@ -0,0 +1,16 @@ + +# This file is autogenerated by update.py + +@ stub EnumDynamicTimeZoneInformation +@ stdcall FileTimeToSystemTime() kernel32.FileTimeToSystemTime +@ stub GetDynamicTimeZoneInformation +@ stub GetDynamicTimeZoneInformationEffectiveYears +@ stdcall GetTimeZoneInformation() kernel32.GetTimeZoneInformation +@ stub GetTimeZoneInformationForYear +@ stub SetDynamicTimeZoneInformation +@ stdcall SetTimeZoneInformation() kernel32.SetTimeZoneInformation +@ stdcall SystemTimeToFileTime() kernel32.SystemTimeToFileTime +@ stdcall SystemTimeToTzSpecificLocalTime() kernel32.SystemTimeToTzSpecificLocalTime +@ stub SystemTimeToTzSpecificLocalTimeEx +@ stdcall TzSpecificLocalTimeToSystemTime() kernel32.TzSpecificLocalTimeToSystemTime +@ stub TzSpecificLocalTimeToSystemTimeEx diff --git a/dll/apisets/api-ms-win-core-toolhelp-l1-1-0.spec b/dll/apisets/api-ms-win-core-toolhelp-l1-1-0.spec new file mode 100644 index 0000000000..52bfb9eaa7 --- /dev/null +++ b/dll/apisets/api-ms-win-core-toolhelp-l1-1-0.spec @@ -0,0 +1,10 @@ + +# This file is autogenerated by update.py + +@ stdcall CreateToolhelp32Snapshot() kernel32.CreateToolhelp32Snapshot +@ stdcall Module32FirstW() kernel32.Module32FirstW +@ stdcall Module32NextW() kernel32.Module32NextW +@ stdcall Process32FirstW() kernel32.Process32FirstW +@ stdcall Process32NextW() kernel32.Process32NextW +@ stdcall Thread32First() kernel32.Thread32First +@ stdcall Thread32Next() kernel32.Thread32Next diff --git a/dll/apisets/api-ms-win-core-url-l1-1-0.spec b/dll/apisets/api-ms-win-core-url-l1-1-0.spec new file mode 100644 index 0000000000..501d58afbc --- /dev/null +++ b/dll/apisets/api-ms-win-core-url-l1-1-0.spec @@ -0,0 +1,41 @@ + +# This file is autogenerated by update.py + +@ stdcall GetAcceptLanguagesA() shlwapi.GetAcceptLanguagesA +@ stdcall GetAcceptLanguagesW() shlwapi.GetAcceptLanguagesW +@ stdcall HashData() shlwapi.HashData +@ stdcall IsInternetESCEnabled() shlwapi.IsInternetESCEnabled +@ stdcall ParseURLA() shlwapi.ParseURLA +@ stdcall ParseURLW() shlwapi.ParseURLW +@ stdcall PathCreateFromUrlA() shlwapi.PathCreateFromUrlA +@ stub PathCreateFromUrlAlloc +@ stdcall PathCreateFromUrlW() shlwapi.PathCreateFromUrlW +@ stdcall PathIsURLA() shlwapi.PathIsURLA +@ stdcall PathIsURLW() shlwapi.PathIsURLW +@ stdcall UrlApplySchemeA() shlwapi.UrlApplySchemeA +@ stdcall UrlApplySchemeW() shlwapi.UrlApplySchemeW +@ stdcall UrlCanonicalizeA() shlwapi.UrlCanonicalizeA +@ stdcall UrlCanonicalizeW() shlwapi.UrlCanonicalizeW +@ stdcall UrlCombineA() shlwapi.UrlCombineA +@ stdcall UrlCombineW() shlwapi.UrlCombineW +@ stdcall UrlCompareA() shlwapi.UrlCompareA +@ stdcall UrlCompareW() shlwapi.UrlCompareW +@ stdcall UrlCreateFromPathA() shlwapi.UrlCreateFromPathA +@ stdcall UrlCreateFromPathW() shlwapi.UrlCreateFromPathW +@ stdcall UrlEscapeA() shlwapi.UrlEscapeA +@ stdcall UrlEscapeW() shlwapi.UrlEscapeW +@ stdcall UrlFixupW() shlwapi.UrlFixupW +@ stdcall UrlGetLocationA() shlwapi.UrlGetLocationA +@ stdcall UrlGetLocationW() shlwapi.UrlGetLocationW +@ stdcall UrlGetPartA() shlwapi.UrlGetPartA +@ stdcall UrlGetPartW() shlwapi.UrlGetPartW +@ stdcall UrlHashA() shlwapi.UrlHashA +@ stdcall UrlHashW() shlwapi.UrlHashW +@ stdcall UrlIsA() shlwapi.UrlIsA +@ stdcall UrlIsNoHistoryA() shlwapi.UrlIsNoHistoryA +@ stdcall UrlIsNoHistoryW() shlwapi.UrlIsNoHistoryW +@ stdcall UrlIsOpaqueA() shlwapi.UrlIsOpaqueA +@ stdcall UrlIsOpaqueW() shlwapi.UrlIsOpaqueW +@ stdcall UrlIsW() shlwapi.UrlIsW +@ stdcall UrlUnescapeA() shlwapi.UrlUnescapeA +@ stdcall UrlUnescapeW() shlwapi.UrlUnescapeW diff --git a/dll/apisets/api-ms-win-core-util-l1-1-0.spec b/dll/apisets/api-ms-win-core-util-l1-1-0.spec new file mode 100644 index 0000000000..feee38ae2f --- /dev/null +++ b/dll/apisets/api-ms-win-core-util-l1-1-0.spec @@ -0,0 +1,8 @@ + +# This file is autogenerated by update.py + +@ stdcall Beep() kernel32.Beep +@ stdcall DecodePointer() kernel32.DecodePointer +@ stdcall DecodeSystemPointer() kernel32.DecodeSystemPointer +@ stdcall EncodePointer() kernel32.EncodePointer +@ stdcall EncodeSystemPointer() kernel32.EncodeSystemPointer diff --git a/dll/apisets/api-ms-win-core-version-l1-1-0.spec b/dll/apisets/api-ms-win-core-version-l1-1-0.spec new file mode 100644 index 0000000000..a43103f5f6 --- /dev/null +++ b/dll/apisets/api-ms-win-core-version-l1-1-0.spec @@ -0,0 +1,7 @@ + +# This file is autogenerated by update.py + +@ stdcall GetFileVersionInfoExW() version.GetFileVersionInfoExW +@ stdcall GetFileVersionInfoSizeExW() version.GetFileVersionInfoSizeExW +@ stdcall VerFindFileW() version.VerFindFileW +@ stdcall VerQueryValueW() version.VerQueryValueW diff --git a/dll/apisets/api-ms-win-core-version-l1-1-1.spec b/dll/apisets/api-ms-win-core-version-l1-1-1.spec new file mode 100644 index 0000000000..53e0faa705 --- /dev/null +++ b/dll/apisets/api-ms-win-core-version-l1-1-1.spec @@ -0,0 +1,9 @@ + +# This file is autogenerated by update.py + +@ stdcall GetFileVersionInfoExW() version.GetFileVersionInfoExW +@ stdcall GetFileVersionInfoSizeExW() version.GetFileVersionInfoSizeExW +@ stdcall GetFileVersionInfoSizeW() version.GetFileVersionInfoSizeW +@ stdcall GetFileVersionInfoW() version.GetFileVersionInfoW +@ stdcall VerFindFileW() version.VerFindFileW +@ stdcall VerQueryValueW() version.VerQueryValueW diff --git a/dll/apisets/api-ms-win-core-version-private-l1-1-0.spec b/dll/apisets/api-ms-win-core-version-private-l1-1-0.spec new file mode 100644 index 0000000000..52ccd7391e --- /dev/null +++ b/dll/apisets/api-ms-win-core-version-private-l1-1-0.spec @@ -0,0 +1,4 @@ + +# This file is autogenerated by update.py + +@ stub GetFileVersionInfoByHandle diff --git a/dll/apisets/api-ms-win-core-versionansi-l1-1-0.spec b/dll/apisets/api-ms-win-core-versionansi-l1-1-0.spec new file mode 100644 index 0000000000..14bc1af983 --- /dev/null +++ b/dll/apisets/api-ms-win-core-versionansi-l1-1-0.spec @@ -0,0 +1,7 @@ + +# This file is autogenerated by update.py + +@ stdcall GetFileVersionInfoExA() version.GetFileVersionInfoExA +@ stdcall GetFileVersionInfoSizeExA() version.GetFileVersionInfoSizeExA +@ stdcall VerFindFileA() version.VerFindFileA +@ stdcall VerQueryValueA() version.VerQueryValueA diff --git a/dll/apisets/api-ms-win-core-windowserrorreporting-l1-1-0.spec b/dll/apisets/api-ms-win-core-windowserrorreporting-l1-1-0.spec new file mode 100644 index 0000000000..14aaaaea5c --- /dev/null +++ b/dll/apisets/api-ms-win-core-windowserrorreporting-l1-1-0.spec @@ -0,0 +1,13 @@ + +# This file is autogenerated by update.py + +@ stub GetApplicationRecoveryCallback +@ stub GetApplicationRestartSettings +@ stub WerRegisterFile +@ stub WerRegisterMemoryBlock +@ stub WerRegisterRuntimeExceptionModule +@ stub WerUnregisterFile +@ stub WerUnregisterMemoryBlock +@ stub WerUnregisterRuntimeExceptionModule +@ stub WerpNotifyLoadStringResource +@ stub WerpNotifyUseStringResource diff --git a/dll/apisets/api-ms-win-core-winrt-error-l1-1-0.spec b/dll/apisets/api-ms-win-core-winrt-error-l1-1-0.spec new file mode 100644 index 0000000000..385e7648ae --- /dev/null +++ b/dll/apisets/api-ms-win-core-winrt-error-l1-1-0.spec @@ -0,0 +1,14 @@ + +# This file is autogenerated by update.py + +@ stub GetRestrictedErrorInfo +@ stub RoCaptureErrorContext +@ stub RoFailFastWithErrorContext +@ stub RoGetErrorReportingFlags +@ stub RoOriginateError +@ stub RoOriginateErrorW +@ stub RoResolveRestrictedErrorInfoReference +@ stub RoSetErrorReportingFlags +@ stub RoTransformError +@ stub RoTransformErrorW +@ stub SetRestrictedErrorInfo diff --git a/dll/apisets/api-ms-win-core-winrt-error-l1-1-1.spec b/dll/apisets/api-ms-win-core-winrt-error-l1-1-1.spec new file mode 100644 index 0000000000..9edd8aba28 --- /dev/null +++ b/dll/apisets/api-ms-win-core-winrt-error-l1-1-1.spec @@ -0,0 +1,22 @@ + +# This file is autogenerated by update.py + +@ stub GetRestrictedErrorInfo +@ stub IsErrorPropagationEnabled +@ stub RoCaptureErrorContext +@ stub RoClearError +@ stub RoFailFastWithErrorContext +@ stub RoGetErrorReportingFlags +@ stub RoGetMatchingRestrictedErrorInfo +@ stub RoInspectCapturedStackBackTrace +@ stub RoInspectThreadErrorInfo +@ stub RoOriginateError +@ stub RoOriginateErrorW +@ stub RoOriginateLanguageException +@ stub RoReportFailedDelegate +@ stub RoReportUnhandledError +@ stub RoResolveRestrictedErrorInfoReference +@ stub RoSetErrorReportingFlags +@ stub RoTransformError +@ stub RoTransformErrorW +@ stub SetRestrictedErrorInfo diff --git a/dll/apisets/api-ms-win-core-winrt-errorprivate-l1-1-1.spec b/dll/apisets/api-ms-win-core-winrt-errorprivate-l1-1-1.spec new file mode 100644 index 0000000000..93d26890d1 --- /dev/null +++ b/dll/apisets/api-ms-win-core-winrt-errorprivate-l1-1-1.spec @@ -0,0 +1,5 @@ + +# This file is autogenerated by update.py + +@ stub RoFailFastWithErrorContextInternal +@ stub RoReportCapabilityCheckFailure diff --git a/dll/apisets/api-ms-win-core-winrt-l1-1-0.spec b/dll/apisets/api-ms-win-core-winrt-l1-1-0.spec new file mode 100644 index 0000000000..5d906d8bd6 --- /dev/null +++ b/dll/apisets/api-ms-win-core-winrt-l1-1-0.spec @@ -0,0 +1,12 @@ + +# This file is autogenerated by update.py + +@ stub RoActivateInstance +@ stub RoGetActivationFactory +@ stub RoGetApartmentIdentifier +@ stub RoInitialize +@ stub RoRegisterActivationFactories +@ stub RoRegisterForApartmentShutdown +@ stub RoRevokeActivationFactories +@ stub RoUninitialize +@ stub RoUnregisterForApartmentShutdown diff --git a/dll/apisets/api-ms-win-core-winrt-registration-l1-1-0.spec b/dll/apisets/api-ms-win-core-winrt-registration-l1-1-0.spec new file mode 100644 index 0000000000..4355e8142c --- /dev/null +++ b/dll/apisets/api-ms-win-core-winrt-registration-l1-1-0.spec @@ -0,0 +1,5 @@ + +# This file is autogenerated by update.py + +@ stub RoGetActivatableClassRegistration +@ stub RoGetServerActivatableClasses diff --git a/dll/apisets/api-ms-win-core-winrt-roparameterizediid-l1-1-0.spec b/dll/apisets/api-ms-win-core-winrt-roparameterizediid-l1-1-0.spec new file mode 100644 index 0000000000..652d573ef9 --- /dev/null +++ b/dll/apisets/api-ms-win-core-winrt-roparameterizediid-l1-1-0.spec @@ -0,0 +1,6 @@ + +# This file is autogenerated by update.py + +@ stub RoFreeParameterizedTypeExtra +@ stub RoGetParameterizedTypeInstanceIID +@ stub RoParameterizedTypeExtraGetTypeSignature diff --git a/dll/apisets/api-ms-win-core-winrt-string-l1-1-0.spec b/dll/apisets/api-ms-win-core-winrt-string-l1-1-0.spec new file mode 100644 index 0000000000..2872b42693 --- /dev/null +++ b/dll/apisets/api-ms-win-core-winrt-string-l1-1-0.spec @@ -0,0 +1,30 @@ + +# This file is autogenerated by update.py + +@ stub HSTRING_UserFree +@ stub HSTRING_UserFree64 +@ stub HSTRING_UserMarshal +@ stub HSTRING_UserMarshal64 +@ stub HSTRING_UserSize +@ stub HSTRING_UserSize64 +@ stub HSTRING_UserUnmarshal +@ stub HSTRING_UserUnmarshal64 +@ stub WindowsCompareStringOrdinal +@ stub WindowsConcatString +@ stub WindowsCreateString +@ stub WindowsCreateStringReference +@ stub WindowsDeleteString +@ stub WindowsDeleteStringBuffer +@ stub WindowsDuplicateString +@ stub WindowsGetStringLen +@ stub WindowsGetStringRawBuffer +@ stub WindowsInspectString +@ stub WindowsIsStringEmpty +@ stub WindowsPreallocateStringBuffer +@ stub WindowsPromoteStringBuffer +@ stub WindowsReplaceString +@ stub WindowsStringHasEmbeddedNull +@ stub WindowsSubstring +@ stub WindowsSubstringWithSpecifiedLength +@ stub WindowsTrimStringEnd +@ stub WindowsTrimStringStart diff --git a/dll/apisets/api-ms-win-core-wow64-l1-1-0.spec b/dll/apisets/api-ms-win-core-wow64-l1-1-0.spec new file mode 100644 index 0000000000..d60f708911 --- /dev/null +++ b/dll/apisets/api-ms-win-core-wow64-l1-1-0.spec @@ -0,0 +1,6 @@ + +# This file is autogenerated by update.py + +@ stdcall IsWow64Process() kernel32.IsWow64Process +@ stdcall Wow64DisableWow64FsRedirection() kernel32.Wow64DisableWow64FsRedirection +@ stdcall Wow64RevertWow64FsRedirection() kernel32.Wow64RevertWow64FsRedirection diff --git a/dll/apisets/api-ms-win-core-wow64-l1-1-1.spec b/dll/apisets/api-ms-win-core-wow64-l1-1-1.spec new file mode 100644 index 0000000000..5b07c9acb5 --- /dev/null +++ b/dll/apisets/api-ms-win-core-wow64-l1-1-1.spec @@ -0,0 +1,8 @@ + +# This file is autogenerated by update.py + +@ stdcall GetSystemWow64DirectoryA() kernel32.GetSystemWow64DirectoryA +@ stdcall GetSystemWow64DirectoryW() kernel32.GetSystemWow64DirectoryW +@ stdcall IsWow64Process() kernel32.IsWow64Process +@ stdcall Wow64DisableWow64FsRedirection() kernel32.Wow64DisableWow64FsRedirection +@ stdcall Wow64RevertWow64FsRedirection() kernel32.Wow64RevertWow64FsRedirection diff --git a/dll/apisets/api-ms-win-core-xstate-l1-1-0.spec b/dll/apisets/api-ms-win-core-xstate-l1-1-0.spec new file mode 100644 index 0000000000..bdf3100375 --- /dev/null +++ b/dll/apisets/api-ms-win-core-xstate-l1-1-0.spec @@ -0,0 +1,11 @@ + +# This file is autogenerated by update.py + +@ stub RtlCopyExtendedContext +@ stub RtlGetEnabledExtendedFeatures +@ stub RtlGetExtendedContextLength +@ stub RtlGetExtendedFeaturesMask +@ stub RtlInitializeExtendedContext +@ stub RtlLocateExtendedFeature +@ stub RtlLocateLegacyContext +@ stub RtlSetExtendedFeaturesMask diff --git a/dll/apisets/api-ms-win-core-xstate-l2-1-0.spec b/dll/apisets/api-ms-win-core-xstate-l2-1-0.spec new file mode 100644 index 0000000000..f267bfcb81 --- /dev/null +++ b/dll/apisets/api-ms-win-core-xstate-l2-1-0.spec @@ -0,0 +1,9 @@ + +# This file is autogenerated by update.py + +@ stub CopyContext +@ stub GetEnabledXStateFeatures +@ stub GetXStateFeaturesMask +@ stub InitializeContext +@ stub LocateXStateFeature +@ stub SetXStateFeaturesMask diff --git a/dll/apisets/api-ms-win-crt-conio-l1-1-0.spec b/dll/apisets/api-ms-win-crt-conio-l1-1-0.spec new file mode 100644 index 0000000000..0cdf860e80 --- /dev/null +++ b/dll/apisets/api-ms-win-crt-conio-l1-1-0.spec @@ -0,0 +1,33 @@ + +# This file is autogenerated by update.py + +@ stub __conio_common_vcprintf +@ stub __conio_common_vcprintf_p +@ stub __conio_common_vcprintf_s +@ stub __conio_common_vcscanf +@ stub __conio_common_vcwprintf +@ stub __conio_common_vcwprintf_p +@ stub __conio_common_vcwprintf_s +@ stub __conio_common_vcwscanf +@ stdcall _cgets() msvcrt._cgets +@ stub _cgets_s +@ stub _cgetws +@ stub _cgetws_s +@ stdcall _cputs() msvcrt._cputs +@ stub _cputws +@ stdcall _getch() msvcrt._getch +@ stub _getch_nolock +@ stdcall _getche() msvcrt._getche +@ stub _getche_nolock +@ stub _getwch +@ stub _getwch_nolock +@ stub _getwche +@ stub _getwche_nolock +@ stdcall _putch() msvcrt._putch +@ stub _putch_nolock +@ stdcall _putwch() msvcrt._putwch +@ stub _putwch_nolock +@ stdcall _ungetch() msvcrt._ungetch +@ stub _ungetch_nolock +@ stub _ungetwch +@ stub _ungetwch_nolock diff --git a/dll/apisets/api-ms-win-crt-convert-l1-1-0.spec b/dll/apisets/api-ms-win-crt-convert-l1-1-0.spec new file mode 100644 index 0000000000..3eb2e391e3 --- /dev/null +++ b/dll/apisets/api-ms-win-crt-convert-l1-1-0.spec @@ -0,0 +1,125 @@ + +# This file is autogenerated by update.py + +@ stdcall __toascii() msvcrt.__toascii +@ stdcall _atodbl() msvcrt._atodbl +@ stub _atodbl_l +@ stub _atof_l +@ stub _atoflt +@ stub _atoflt_l +@ stdcall _atoi64() msvcrt._atoi64 +@ stub _atoi64_l +@ stub _atoi_l +@ stub _atol_l +@ stdcall _atoldbl() msvcrt._atoldbl +@ stub _atoldbl_l +@ stub _atoll_l +@ stdcall _ecvt() msvcrt._ecvt +@ stub _ecvt_s +@ stdcall _fcvt() msvcrt._fcvt +@ stub _fcvt_s +@ stdcall _gcvt() msvcrt._gcvt +@ stub _gcvt_s +@ stdcall _i64toa() msvcrt._i64toa +@ stub _i64toa_s +@ stdcall _i64tow() msvcrt._i64tow +@ stub _i64tow_s +@ stdcall _itoa() msvcrt._itoa +@ stub _itoa_s +@ stdcall _itow() msvcrt._itow +@ stub _itow_s +@ stdcall _ltoa() msvcrt._ltoa +@ stub _ltoa_s +@ stdcall _ltow() msvcrt._ltow +@ stub _ltow_s +@ stub _strtod_l +@ stub _strtof_l +@ stdcall _strtoi64() msvcrt._strtoi64 +@ stub _strtoi64_l +@ stub _strtoimax_l +@ stub _strtol_l +@ stub _strtold_l +@ stub _strtoll_l +@ stdcall _strtoui64() msvcrt._strtoui64 +@ stub _strtoui64_l +@ stub _strtoul_l +@ stub _strtoull_l +@ stub _strtoumax_l +@ stdcall _ui64toa() msvcrt._ui64toa +@ stub _ui64toa_s +@ stdcall _ui64tow() msvcrt._ui64tow +@ stub _ui64tow_s +@ stdcall _ultoa() msvcrt._ultoa +@ stub _ultoa_s +@ stdcall _ultow() msvcrt._ultow +@ stub _ultow_s +@ stub _wcstod_l +@ stub _wcstof_l +@ stdcall _wcstoi64() msvcrt._wcstoi64 +@ stub _wcstoi64_l +@ stub _wcstoimax_l +@ stub _wcstol_l +@ stub _wcstold_l +@ stub _wcstoll_l +@ stub _wcstombs_l +@ stub _wcstombs_s_l +@ stdcall _wcstoui64() msvcrt._wcstoui64 +@ stub _wcstoui64_l +@ stub _wcstoul_l +@ stub _wcstoull_l +@ stub _wcstoumax_l +@ stub _wctomb_l +@ stub _wctomb_s_l +@ stdcall _wtof() msvcrt._wtof +@ stub _wtof_l +@ stdcall _wtoi() msvcrt._wtoi +@ stdcall _wtoi64() msvcrt._wtoi64 +@ stub _wtoi64_l +@ stub _wtoi_l +@ stdcall _wtol() msvcrt._wtol +@ stub _wtol_l +@ stub _wtoll +@ stub _wtoll_l +@ stdcall atof() msvcrt.atof +@ stdcall atoi() msvcrt.atoi +@ stdcall atol() msvcrt.atol +@ stub atoll +@ stub btowc +@ stub c16rtomb +@ stub c32rtomb +@ stub mbrtoc16 +@ stub mbrtoc32 +@ stub mbrtowc +@ stub mbsrtowcs +@ stub mbsrtowcs_s +@ stdcall mbstowcs() msvcrt.mbstowcs +@ stub mbstowcs_s +@ stdcall mbtowc() msvcrt.mbtowc +@ stdcall strtod() msvcrt.strtod +@ stub strtof +@ stub strtoimax +@ stdcall strtol() msvcrt.strtol +@ stub strtold +@ stub strtoll +@ stdcall strtoul() msvcrt.strtoul +@ stub strtoull +@ stub strtoumax +@ stub wcrtomb +@ stub wcrtomb_s +@ stub wcsrtombs +@ stub wcsrtombs_s +@ stdcall wcstod() msvcrt.wcstod +@ stub wcstof +@ stub wcstoimax +@ stdcall wcstol() msvcrt.wcstol +@ stub wcstold +@ stub wcstoll +@ stdcall wcstombs() msvcrt.wcstombs +@ stub wcstombs_s +@ stdcall wcstoul() msvcrt.wcstoul +@ stub wcstoull +@ stub wcstoumax +@ stub wctob +@ stdcall wctomb() msvcrt.wctomb +@ stub wctomb_s +@ stub wctrans diff --git a/dll/apisets/api-ms-win-crt-environment-l1-1-0.spec b/dll/apisets/api-ms-win-crt-environment-l1-1-0.spec new file mode 100644 index 0000000000..5afd83baa8 --- /dev/null +++ b/dll/apisets/api-ms-win-crt-environment-l1-1-0.spec @@ -0,0 +1,21 @@ + +# This file is autogenerated by update.py + +@ stdcall -arch=i386 __p__environ() msvcrt.__p__environ +@ stdcall -arch=i386 __p__wenviron() msvcrt.__p__wenviron +@ stub _dupenv_s +@ stdcall _putenv() msvcrt._putenv +@ stub _putenv_s +@ stdcall _searchenv() msvcrt._searchenv +@ stub _searchenv_s +@ stub _wdupenv_s +@ stdcall _wgetcwd() msvcrt._wgetcwd +@ stdcall _wgetdcwd() msvcrt._wgetdcwd +@ stdcall _wgetenv() msvcrt._wgetenv +@ stub _wgetenv_s +@ stdcall _wputenv() msvcrt._wputenv +@ stub _wputenv_s +@ stdcall _wsearchenv() msvcrt._wsearchenv +@ stub _wsearchenv_s +@ stdcall getenv() msvcrt.getenv +@ stub getenv_s diff --git a/dll/apisets/api-ms-win-crt-filesystem-l1-1-0.spec b/dll/apisets/api-ms-win-crt-filesystem-l1-1-0.spec new file mode 100644 index 0000000000..5d7384d942 --- /dev/null +++ b/dll/apisets/api-ms-win-crt-filesystem-l1-1-0.spec @@ -0,0 +1,68 @@ + +# This file is autogenerated by update.py + +@ stdcall _access() msvcrt._access +@ stub _access_s +@ stdcall _chdir() msvcrt._chdir +@ stdcall _chdrive() msvcrt._chdrive +@ stdcall _chmod() msvcrt._chmod +@ stdcall _findclose() msvcrt._findclose +@ stub _findfirst32 +@ stub _findfirst32i64 +@ stdcall _findfirst64() msvcrt._findfirst64 +@ stub _findfirst64i32 +@ stub _findnext32 +@ stub _findnext32i64 +@ stdcall _findnext64() msvcrt._findnext64 +@ stub _findnext64i32 +@ stub _fstat32 +@ stub _fstat32i64 +@ stdcall _fstat64() msvcrt._fstat64 +@ stub _fstat64i32 +@ stdcall _fullpath() msvcrt._fullpath +@ stdcall _getdiskfree() msvcrt._getdiskfree +@ stdcall _getdrive() msvcrt._getdrive +@ stdcall _getdrives() msvcrt._getdrives +@ stub _lock_file +@ stdcall _makepath() msvcrt._makepath +@ stub _makepath_s +@ stdcall _mkdir() msvcrt._mkdir +@ stdcall _rmdir() msvcrt._rmdir +@ stdcall _splitpath() msvcrt._splitpath +@ stub _splitpath_s +@ stub _stat32 +@ stub _stat32i64 +@ stdcall _stat64() msvcrt._stat64 +@ stub _stat64i32 +@ stdcall _umask() msvcrt._umask +@ stub _umask_s +@ stdcall _unlink() msvcrt._unlink +@ stub _unlock_file +@ stdcall _waccess() msvcrt._waccess +@ stub _waccess_s +@ stdcall _wchdir() msvcrt._wchdir +@ stdcall _wchmod() msvcrt._wchmod +@ stub _wfindfirst32 +@ stub _wfindfirst32i64 +@ stub _wfindfirst64 +@ stub _wfindfirst64i32 +@ stub _wfindnext32 +@ stub _wfindnext32i64 +@ stub _wfindnext64 +@ stub _wfindnext64i32 +@ stdcall _wfullpath() msvcrt._wfullpath +@ stdcall _wmakepath() msvcrt._wmakepath +@ stub _wmakepath_s +@ stdcall _wmkdir() msvcrt._wmkdir +@ stdcall _wremove() msvcrt._wremove +@ stdcall _wrename() msvcrt._wrename +@ stdcall _wrmdir() msvcrt._wrmdir +@ stdcall _wsplitpath() msvcrt._wsplitpath +@ stub _wsplitpath_s +@ stub _wstat32 +@ stub _wstat32i64 +@ stdcall _wstat64() msvcrt._wstat64 +@ stub _wstat64i32 +@ stdcall _wunlink() msvcrt._wunlink +@ stdcall remove() msvcrt.remove +@ stdcall rename() msvcrt.rename diff --git a/dll/apisets/api-ms-win-crt-heap-l1-1-0.spec b/dll/apisets/api-ms-win-crt-heap-l1-1-0.spec new file mode 100644 index 0000000000..1fa5011a4d --- /dev/null +++ b/dll/apisets/api-ms-win-crt-heap-l1-1-0.spec @@ -0,0 +1,30 @@ + +# This file is autogenerated by update.py + +@ stdcall _aligned_free() msvcrt._aligned_free +@ stdcall _aligned_malloc() msvcrt._aligned_malloc +@ stub _aligned_msize +@ stdcall _aligned_offset_malloc() msvcrt._aligned_offset_malloc +@ stdcall _aligned_offset_realloc() msvcrt._aligned_offset_realloc +@ stub _aligned_offset_recalloc +@ stdcall _aligned_realloc() msvcrt._aligned_realloc +@ stub _aligned_recalloc +@ stdcall _callnewh() msvcrt._callnewh +@ stub _calloc_base +@ stdcall _expand() msvcrt._expand +@ stub _free_base +@ stub _get_heap_handle +@ stdcall _heapchk() msvcrt._heapchk +@ stdcall _heapmin() msvcrt._heapmin +@ stdcall _heapwalk() msvcrt._heapwalk +@ stub _malloc_base +@ stdcall _msize() msvcrt._msize +@ stub _query_new_handler +@ stub _query_new_mode +@ stub _realloc_base +@ stub _recalloc +@ stub _set_new_mode +@ stdcall calloc() msvcrt.calloc +@ stdcall free() msvcrt.free +@ stdcall malloc() msvcrt.malloc +@ stdcall realloc() msvcrt.realloc diff --git a/dll/apisets/api-ms-win-crt-locale-l1-1-0.spec b/dll/apisets/api-ms-win-crt-locale-l1-1-0.spec new file mode 100644 index 0000000000..0d255582c1 --- /dev/null +++ b/dll/apisets/api-ms-win-crt-locale-l1-1-0.spec @@ -0,0 +1,23 @@ + +# This file is autogenerated by update.py + +@ stdcall ___lc_codepage_func() msvcrt.___lc_codepage_func +@ stdcall ___lc_collate_cp_func() msvcrt.___lc_collate_cp_func +@ stub ___lc_locale_name_func +@ stdcall ___mb_cur_max_func() msvcrt.___mb_cur_max_func +@ stub ___mb_cur_max_l_func +@ stub __initialize_lconv_for_unsigned_char +@ stdcall __pctype_func() msvcrt.__pctype_func +@ stdcall __pwctype_func() msvcrt.__pwctype_func +@ stub _configthreadlocale +@ stub _create_locale +@ stub _free_locale +@ stub _get_current_locale +@ stdcall _getmbcp() msvcrt._getmbcp +@ stub _lock_locales +@ stdcall _setmbcp() msvcrt._setmbcp +@ stub _unlock_locales +@ stub _wcreate_locale +@ stdcall _wsetlocale() msvcrt._wsetlocale +@ stdcall localeconv() msvcrt.localeconv +@ stdcall setlocale() msvcrt.setlocale diff --git a/dll/apisets/api-ms-win-crt-math-l1-1-0.spec b/dll/apisets/api-ms-win-crt-math-l1-1-0.spec new file mode 100644 index 0000000000..0082447de8 --- /dev/null +++ b/dll/apisets/api-ms-win-crt-math-l1-1-0.spec @@ -0,0 +1,344 @@ + +# This file is autogenerated by update.py + +@ stdcall -arch=i386 _CIacos() msvcrt._CIacos +@ stdcall -arch=i386 _CIasin() msvcrt._CIasin +@ stdcall -arch=i386 _CIatan() msvcrt._CIatan +@ stdcall -arch=i386 _CIatan2() msvcrt._CIatan2 +@ stdcall -arch=i386 _CIcos() msvcrt._CIcos +@ stdcall -arch=i386 _CIcosh() msvcrt._CIcosh +@ stdcall -arch=i386 _CIexp() msvcrt._CIexp +@ stdcall -arch=i386 _CIfmod() msvcrt._CIfmod +@ stdcall -arch=i386 _CIlog() msvcrt._CIlog +@ stdcall -arch=i386 _CIlog10() msvcrt._CIlog10 +@ stdcall -arch=i386 _CIpow() msvcrt._CIpow +@ stdcall -arch=i386 _CIsin() msvcrt._CIsin +@ stdcall -arch=i386 _CIsinh() msvcrt._CIsinh +@ stdcall -arch=i386 _CIsqrt() msvcrt._CIsqrt +@ stdcall -arch=i386 _CItan() msvcrt._CItan +@ stdcall -arch=i386 _CItanh() msvcrt._CItanh +@ stub _Cbuild +@ stub _Cmulcc +@ stub _Cmulcr +@ stub _FCbuild +@ stub _FCmulcc +@ stub _FCmulcr +@ stub _LCbuild +@ stub _LCmulcc +@ stub _LCmulcr +@ stub __libm_sse2_acos +@ stub __libm_sse2_acosf +@ stub __libm_sse2_asin +@ stub __libm_sse2_asinf +@ stub __libm_sse2_atan +@ stub __libm_sse2_atan2 +@ stub __libm_sse2_atanf +@ stub __libm_sse2_cos +@ stub __libm_sse2_cosf +@ stub __libm_sse2_exp +@ stub __libm_sse2_expf +@ stub __libm_sse2_log +@ stub __libm_sse2_log10 +@ stub __libm_sse2_log10f +@ stub __libm_sse2_logf +@ stub __libm_sse2_pow +@ stub __libm_sse2_powf +@ stub __libm_sse2_sin +@ stub __libm_sse2_sinf +@ stub __libm_sse2_tan +@ stub __libm_sse2_tanf +@ stdcall __setusermatherr() msvcrt.__setusermatherr +@ stdcall _cabs() msvcrt._cabs +@ stdcall _chgsign() msvcrt._chgsign +@ stdcall -arch=x86_64,arm _chgsignf() msvcrt._chgsignf +@ stdcall _copysign() msvcrt._copysign +@ stdcall -arch=x86_64,arm _copysignf() msvcrt._copysignf +@ stub _d_int +@ stub _dclass +@ stub _dexp +@ stub _dlog +@ stub _dnorm +@ stub _dpcomp +@ stub _dpoly +@ stub _dscale +@ stub _dsign +@ stub _dsin +@ stub _dtest +@ stub _dunscale +@ stub _except1 +@ stub _fd_int +@ stub _fdclass +@ stub _fdexp +@ stub _fdlog +@ stub _fdnorm +@ stdcall _fdopen() msvcrt._fdopen +@ stub _fdpcomp +@ stub _fdpoly +@ stub _fdscale +@ stub _fdsign +@ stub _fdsin +@ stub _fdtest +@ stub _fdunscale +@ stdcall _finite() msvcrt._finite +@ stub _finitef +@ stdcall _fpclass() msvcrt._fpclass +@ stub _fpclassf +@ stdcall -arch=i386 _ftol() msvcrt._ftol +@ stub _get_FMA3_enable +@ stdcall _hypot() msvcrt._hypot +@ stdcall -arch=x86_64,arm _hypotf() msvcrt._hypotf +@ stdcall _isnan() msvcrt._isnan +@ stub _isnanf +@ stdcall _j0() msvcrt._j0 +@ stdcall _j1() msvcrt._j1 +@ stdcall _jn() msvcrt._jn +@ stub _ld_int +@ stub _ldclass +@ stub _ldexp +@ stub _ldlog +@ stub _ldpcomp +@ stub _ldpoly +@ stub _ldscale +@ stub _ldsign +@ stub _ldsin +@ stub _ldtest +@ stub _ldunscale +@ stub _libm_sse2_acos_precise +@ stub _libm_sse2_asin_precise +@ stub _libm_sse2_atan_precise +@ stub _libm_sse2_cos_precise +@ stub _libm_sse2_exp_precise +@ stub _libm_sse2_log10_precise +@ stub _libm_sse2_log_precise +@ stub _libm_sse2_pow_precise +@ stub _libm_sse2_sin_precise +@ stub _libm_sse2_sqrt_precise +@ stub _libm_sse2_tan_precise +@ stdcall _logb() msvcrt._logb +@ stub _logbf +@ stdcall _nextafter() msvcrt._nextafter +@ stub _nextafterf +@ stdcall _scalb() msvcrt._scalb +@ stub _scalbf +@ stub _set_FMA3_enable +@ stub _set_SSE2_enable +@ stdcall _y0() msvcrt._y0 +@ stdcall _y1() msvcrt._y1 +@ stdcall _yn() msvcrt._yn +@ stdcall acos() msvcrt.acos +@ stdcall -arch=x86_64,arm acosf() msvcrt.acosf +@ stub acosh +@ stub acoshf +@ stub acoshl +@ stdcall asin() msvcrt.asin +@ stdcall -arch=x86_64,arm asinf() msvcrt.asinf +@ stub asinh +@ stub asinhf +@ stub asinhl +@ stdcall atan() msvcrt.atan +@ stdcall atan2() msvcrt.atan2 +@ stdcall -arch=x86_64,arm atan2f() msvcrt.atan2f +@ stdcall -arch=x86_64,arm atanf() msvcrt.atanf +@ stub atanh +@ stub atanhf +@ stub atanhl +@ stub cabs +@ stub cabsf +@ stub cabsl +@ stub cacos +@ stub cacosf +@ stub cacosh +@ stub cacoshf +@ stub cacoshl +@ stub cacosl +@ stub carg +@ stub cargf +@ stub cargl +@ stub casin +@ stub casinf +@ stub casinh +@ stub casinhf +@ stub casinhl +@ stub casinl +@ stub catan +@ stub catanf ... 4206 lines suppressed ...

1 0

02/03: [APISETS] Introduce a script that will generate apisets based on wine apisets. Functions that are present in ReactOS will be forwarded, the rest stubbed. CORE-13231
by Mark Jansen 07 Apr '18

07 Apr '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=3ff8f1bb09e6cbc46329c… commit 3ff8f1bb09e6cbc46329ce368fbe7ded4733e95d Author: Mark Jansen <mark.jansen(a)reactos.org> AuthorDate: Sat Apr 7 03:24:07 2018 +0200 Commit: Mark Jansen <mark.jansen(a)reactos.org> CommitDate: Sat Apr 7 14:50:58 2018 +0200 [APISETS] Introduce a script that will generate apisets based on wine apisets. Functions that are present in ReactOS will be forwarded, the rest stubbed. CORE-13231 --- dll/CMakeLists.txt | 1 + dll/apisets/CMakeLists.txt.in | 39 ++++ dll/apisets/update.py | 456 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 496 insertions(+) diff --git a/dll/CMakeLists.txt b/dll/CMakeLists.txt index 2e913af571..c9f4f72195 100644 --- a/dll/CMakeLists.txt +++ b/dll/CMakeLists.txt @@ -1,5 +1,6 @@ add_subdirectory(3rdparty) +#add_subdirectory(apisets) add_subdirectory(appcompat) add_subdirectory(cpl) add_subdirectory(directx) diff --git a/dll/apisets/CMakeLists.txt.in b/dll/apisets/CMakeLists.txt.in new file mode 100644 index 0000000000..2399d21bf1 --- /dev/null +++ b/dll/apisets/CMakeLists.txt.in @@ -0,0 +1,39 @@ + +# This file is generated by update.py, please edit CMakeLists.txt.in instead +# Generated from %WINE_GIT_VERSION% + +project(apisets) + +function (add_apiset apiset_name baseaddress) + spec2def(${apiset_name}.dll ${apiset_name}.spec ADD_IMPORTLIB) + + add_definitions( + -D_CTYPE_DISABLE_MACROS + -D_NO_INLINING + -D__CRT__NO_INLINE + -D__STDC_WANT_SECURE_LIB__=0 + -D_INC_STRING + -D_CTYPE_DEFINED + -D_WCTYPE_DEFINED + -D_CRT_ERRNO_DEFINED) + + add_library(${apiset_name} SHARED + ${CMAKE_CURRENT_BINARY_DIR}/${apiset_name}_stubs.c + ${CMAKE_CURRENT_BINARY_DIR}/${apiset_name}.def) + + add_dependencies(${apiset_name} xdk) + set_module_type(${apiset_name} win32dll ENTRYPOINT 0 UNICODE IMAGEBASE ${baseaddress}) + + if(NOT MSVC) + add_target_compile_flags(${apiset_name} "-fno-builtin") + else() + add_target_compile_flags(${apiset_name} "/wd4026 /wd4273") + endif() + + add_importlibs(${apiset_name} ${ARGN} kernel32 ntdll) + + add_cd_file(TARGET ${apiset_name} DESTINATION reactos/system32 FOR all) +endfunction() + +# Apisets will be appended + diff --git a/dll/apisets/update.py b/dll/apisets/update.py new file mode 100644 index 0000000000..2d7ce387a7 --- /dev/null +++ b/dll/apisets/update.py @@ -0,0 +1,456 @@ +''' +PROJECT: ReactOS apisets generator +LICENSE: MIT (https://spdx.org/licenses/MIT) +PURPOSE: Create apiset forwarders based on Wine apisets +COPYRIGHT: Copyright 2017,2018 Mark Jansen (mark.jansen(a)reactos.org) +''' + +import os +import re +import sys +from collections import defaultdict +import subprocess + + +SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__)) + +IGNORE_OPTIONS = ('-norelay', '-ret16', '-ret64', '-register', '-private', + '-noname', '-ordinal', '-i386', '-arch=', '-stub') + +# Figure these out later +FUNCTION_BLACKLIST = [ + # api-ms-win-crt-utility-l1-1-0_stubs.c(6): + # error C2169: '_abs64': intrinsic function, cannot be defined + '_abs64', + '_byteswap_uint64', '_byteswap_ulong', '_byteswap_ushort', + '_rotl64', '_rotr64', +] + +SPEC_HEADER = [ + '\n', + '# This file is autogenerated by update.py\n', + '\n' +] + + +class InvalidSpecError(Exception): + def __init__(self, message): + Exception.__init__(self, message) + +class Arch(object): + none = 0 + i386 = 1 + x86_64 = 2 + arm = 4 + arm64 = 8 + Any = i386 | x86_64 | arm | arm64 + + FROM_STR = { + 'i386': i386, + 'x86_64': x86_64, + 'arm': arm, + 'arm64': arm64, + 'any': Any, + 'win32': i386, + 'win64': x86_64, + } + + TO_STR = { + i386: 'i386', + x86_64: 'x86_64', + arm: 'arm', + arm64: 'arm64', + } + + def __init__(self, initial=none): + self._val = initial + + def add(self, text): + self._val |= sum([Arch.FROM_STR[arch] for arch in text.split(',')]) + assert self._val != 0 + + def has(self, val): + return (self._val & val) != 0 + + def to_str(self): + arch_str = [] + for value in Arch.TO_STR: + if value & self._val: + arch_str.append(Arch.TO_STR[value]) + return ','.join(arch_str) + + def __len__(self): + return bin(self._val).count("1") + + def __add__(self, other): + return Arch(self._val | other._val) # pylint: disable=W0212 + + def __sub__(self, other): + return Arch(self._val & ~other._val) # pylint: disable=W0212 + + def __gt__(self, other): + return self._val > other._val # pylint: disable=W0212 + + def __lt__(self, other): + return self._val < other._val # pylint: disable=W0212 + + def __eq__(self, other): + return self._val == other._val # pylint: disable=W0212 + + def __ne__(self, other): + return not self.__eq__(other) + +ALIAS_DLL = { + 'ucrtbase': 'msvcrt', + 'kernelbase': 'kernel32', + 'shcore': 'shlwapi', + 'combase': 'ole32', + + # These modules cannot be linked against in ROS, so forward it + 'cfgmgr32': 'setupapi', # Forward everything + 'wmi': 'advapi32', # Forward everything +} + +class SpecEntry(object): + def __init__(self, text, spec): + self.spec = spec + self._ord = None + self.callconv = None + self.name = None + self.arch = Arch() + self._forwarder = None + self.init(text) + self.noname = False + if self.name == '@': + self.noname = True + if self._forwarder: + self.name = self._forwarder[1] + + def init(self, text): + tokens = re.split(r'([\s#;])', text.strip()) + tokens = [token for token in tokens if token and not token.isspace()] + idx = [] + for comment in ['#', ';']: + if comment in tokens: + idx.append(tokens.index(comment)) + idx = sorted(idx) + if idx: + tokens = tokens[:idx[0]] + if not tokens: + raise InvalidSpecError(text) + self._ord = tokens[0] + assert self._ord == '@' or self._ord.isdigit(), text + tokens = tokens[1:] + self.callconv = tokens.pop(0) + self.name = tokens.pop(0) + while self.name.startswith(IGNORE_OPTIONS): + if self.name.startswith('-arch='): + self.arch.add(self.name[6:]) + elif self.name == '-i386': + self.arch.add('i386') + self.name = tokens.pop(0) + if not self.arch: + self.arch = Arch(Arch.Any) + assert not self.name.startswith('-'), text + if not tokens: + return + if tokens[0] == '(': + assert ')' in tokens, text + arg = tokens.pop(0) + while True: + arg = tokens.pop(0) + if arg == ')': + break + if not tokens: + return + assert len(tokens) == 1, text + self._forwarder = tokens.pop(0).split('.', 2) + if len(self._forwarder) == 1: + self._forwarder = ['self', self._forwarder[0]] + assert len(self._forwarder) in (0, 2), self._forwarder + if self._forwarder[0] in ALIAS_DLL: + self._forwarder[0] = ALIAS_DLL[self._forwarder[0]] + + def resolve_forwarders(self, module_lookup, try_modules): + if self._forwarder: + assert self._forwarder[1] == self.name, '{}:{}'.format(self._forwarder[1], self.name) + if self.noname and self.name == '@': + return 0 # cannot search for this function + self._forwarder = [] + self.arch = Arch() + for module_name in try_modules: + assert module_name in module_lookup, module_name + module = module_lookup[module_name] + fwd_arch = module.find_arch(self.name) + callconv = module.find_callconv(self.name) + if fwd_arch: + self.arch = fwd_arch + self._forwarder = [module_name, self.name] + self.callconv = callconv + return 1 + return 0 + + def extra_forwarders(self, function_lookup, module_lookup): + if self._forwarder: + return 1 + if self.noname and self.name == '@': + return 0 # cannot search for this function + lst = function_lookup.get(self.name, None) + if lst: + modules = list(set([func.spec.name for func in lst])) + if len(modules) > 1: + mod = None + arch = Arch() + for module in modules: + mod_arch = module_lookup[module].find_arch(self.name) + if mod is None or mod_arch > arch: + mod = module + arch = mod_arch + modules = [mod] + mod = modules[0] + self._forwarder = [mod, self.name] + mod = module_lookup[mod] + self.arch = mod.find_arch(self.name) + self.callconv = mod.find_callconv(self.name) + return 1 + return 0 + + def forwarder_module(self): + if self._forwarder: + return self._forwarder[0] + + def forwarder(self): + if self._forwarder: + return 1 + return 0 + + def write(self, spec_file): + name = self.name + opts = '' + estimate_size = 0 + if self.noname: + opts = '{} -noname'.format(opts) + if self.name == '@': + assert self._ord != '@' + name = 'Ordinal' + self._ord + if not self._forwarder: + spec_file.write('{} stub{} {}\n'.format(self._ord, opts, name)) + estimate_size += 0x1000 + else: + assert self.arch != Arch(), self.name + args = '()' + callconv = 'stdcall' + fwd = '.'.join(self._forwarder) + name = self.name if not self.noname else '@' + arch = self.arch + if self.callconv == 'extern': + args = '' + callconv = 'extern' + if arch.has(Arch.x86_64): + fwd = '{}.__imp_{}'.format(*self._forwarder) + self.arch = arch - Arch(Arch.x86_64) + estimate_size += self.write(spec_file) + self.arch = arch + arch = Arch(Arch.x86_64) + else: + fwd = '{}._imp__{}'.format(*self._forwarder) + if arch != Arch(Arch.Any): + opts = '{} -arch={}'.format(opts, arch.to_str()) + spec_file.write('{ord} {cc}{opts} {name}{args} {fwd}\n'.format(ord=self._ord, + cc=callconv, + opts=opts, + name=name, + args=args, + fwd=fwd)) + estimate_size += 0x100 + return estimate_size + + + +class SpecFile(object): + def __init__(self, fullpath, name): + self._path = fullpath + self.name = name + self._entries = [] + self._functions = defaultdict(list) + self._estimate_size = 0 + + def parse(self): + with open(self._path, 'rb') as specfile: + for line in specfile.readlines(): + if line: + try: + entry = SpecEntry(line, self) + self._entries.append(entry) + self._functions[entry.name].append(entry) + except InvalidSpecError: + pass + return (sum([entry.forwarder() for entry in self._entries]), len(self._entries)) + + def add_functions(self, function_lookup): + for entry in self._entries: + function_lookup[entry.name].append(entry) + + def find(self, name): + return self._functions.get(name, None) + + def find_arch(self, name): + functions = self.find(name) + arch = Arch() + if functions: + for func in functions: + arch += func.arch + return arch + + def find_callconv(self, name): + functions = self.find(name) + callconv = None + if functions: + for func in functions: + if not callconv: + callconv = func.callconv + elif callconv != func.callconv: + assert callconv != 'extern', 'Cannot have data/function with same name' + callconv = func.callconv + return callconv + + def resolve_forwarders(self, module_lookup): + modules = self.forwarder_modules() + total = 0 + for entry in self._entries: + total += entry.resolve_forwarders(module_lookup, modules) + return (total, len(self._entries)) + + def extra_forwarders(self, function_lookup, module_lookup): + total = 0 + for entry in self._entries: + total += entry.extra_forwarders(function_lookup, module_lookup) + return (total, len(self._entries)) + + def forwarder_modules(self): + modules = defaultdict(int) + for entry in self._entries: + module = entry.forwarder_module() + if module: + modules[module] += 1 + return sorted(modules, key=modules.get, reverse=True) + + def write(self, spec_file): + written = set(FUNCTION_BLACKLIST) + self._estimate_size = 0 + for entry in self._entries: + if entry.name not in written: + self._estimate_size += entry.write(spec_file) + written.add(entry.name) + + def write_cmake(self, cmakelists, baseaddress): + seen = set() + # ntdll and kernel32 are linked against everything, self = internal, + # we cannot link cfgmgr32 and wmi? + ignore = ['ntdll', 'kernel32', 'self', 'cfgmgr32', 'wmi'] + forwarders = self.forwarder_modules() + fwd_strings = [x for x in forwarders if not (x in seen or x in ignore or seen.add(x))] + fwd_strings = ' '.join(fwd_strings) + name = self.name + baseaddress = '0x{:8x}'.format(baseaddress) + cmakelists.write('add_apiset({} {} {})\n'.format(name, baseaddress, fwd_strings)) + return self._estimate_size + + + +def generate_specnames(dll_dir): + win32 = os.path.join(dll_dir, 'win32') + for dirname in os.listdir(win32): + fullpath = os.path.join(win32, dirname, dirname + '.spec') + if not os.path.isfile(fullpath): + if '.' in dirname: + fullpath = os.path.join(win32, dirname, dirname.rsplit('.', 1)[0] + '.spec') + if not os.path.isfile(fullpath): + continue + else: + continue + yield (fullpath, dirname) + # Special cases + yield (os.path.join(dll_dir, 'ntdll', 'def', 'ntdll.spec'), 'ntdll') + yield (os.path.join(dll_dir, 'appcompat', 'apphelp', 'apphelp.spec'), 'apphelp') + yield (os.path.join(dll_dir, '..', 'win32ss', 'user', 'user32', 'user32.spec'), 'user32') + yield (os.path.join(dll_dir, '..', 'win32ss', 'gdi', 'gdi32', 'gdi32.spec'), 'gdi32') + +def run(wineroot): + wine_apisets = [] + ros_modules = [] + + module_lookup = {} + function_lookup = defaultdict(list) + + version = subprocess.check_output(["git", "describe"], cwd=wineroot).strip() + + print 'Reading Wine apisets for', version + wine_apiset_path = os.path.join(wineroot, 'dlls') + for dirname in os.listdir(wine_apiset_path): + if not dirname.startswith('api-'): + continue + if not os.path.isdir(os.path.join(wine_apiset_path, dirname)): + continue + fullpath = os.path.join(wine_apiset_path, dirname, dirname + '.spec') + spec = SpecFile(fullpath, dirname) + wine_apisets.append(spec) + + print 'Parsing Wine apisets,', + total = (0, 0) + for apiset in wine_apisets: + total = tuple(map(sum, zip(apiset.parse(), total))) + print 'found', total[0], '/', total[1], 'forwarders' + + print 'Reading ReactOS modules' + for fullpath, dllname in generate_specnames(os.path.dirname(SCRIPT_DIR)): + spec = SpecFile(fullpath, dllname) + ros_modules.append(spec) + + print 'Parsing ReactOS modules' + for module in ros_modules: + module.parse() + assert module.name not in module_lookup, module.name + module_lookup[module.name] = module + module.add_functions(function_lookup) + + print 'First pass, resolving forwarders,', + total = (0, 0) + for apiset in wine_apisets: + total = tuple(map(sum, zip(apiset.resolve_forwarders(module_lookup), total))) + print 'found', total[0], '/', total[1], 'forwarders' + + print 'Second pass, searching extra forwarders,', + total = (0, 0) + for apiset in wine_apisets: + total = tuple(map(sum, zip(apiset.extra_forwarders(function_lookup, module_lookup), total))) + print 'found', total[0], '/', total[1], 'forwarders' + + print 'Writing apisets' + for apiset in wine_apisets: + with open(os.path.join(SCRIPT_DIR, apiset.name + '.spec'), 'wb') as out_spec: + out_spec.writelines(SPEC_HEADER) + apiset.write(out_spec) + + print 'Writing CMakeLists.txt' + with open(os.path.join(SCRIPT_DIR, 'CMakeLists.txt.in'), 'rb') as template: + data = template.read() + data = data.replace('%WINE_GIT_VERSION%', version) + baseaddress = 0x60000000 + with open(os.path.join(SCRIPT_DIR, 'CMakeLists.txt'), 'wb') as cmakelists: + cmakelists.write(data) + for apiset in wine_apisets: + baseaddress += apiset.write_cmake(cmakelists, baseaddress) + baseaddress += (0x10000 - baseaddress) % 0x10000 + print 'Done' + +def main(paths): + for path in paths: + if path: + run(path) + return + print 'No path specified,' + print 'either pass it as argument, or set the environment variable "WINE_SRC_ROOT"' + +if __name__ == '__main__': + main(sys.argv[1:] + [os.environ.get('WINE_SRC_ROOT')])

1 0

01/03: [SDK] Remove some unused includes in stubs.h CORE-13231
by Mark Jansen 07 Apr '18

07 Apr '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=547240efd5f02e328087f… commit 547240efd5f02e328087fd6a44e85f48316a3a34 Author: Mark Jansen <mark.jansen(a)reactos.org> AuthorDate: Sat Apr 7 03:23:56 2018 +0200 Commit: Mark Jansen <mark.jansen(a)reactos.org> CommitDate: Sat Apr 7 14:50:42 2018 +0200 [SDK] Remove some unused includes in stubs.h CORE-13231 --- sdk/include/reactos/stubs.h | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/sdk/include/reactos/stubs.h b/sdk/include/reactos/stubs.h index f81e53aa45..3be4027260 100644 --- a/sdk/include/reactos/stubs.h +++ b/sdk/include/reactos/stubs.h @@ -1,9 +1,8 @@ -#include <stdarg.h> #define WIN32_NO_STATUS #include <windef.h> -#include <wine/config.h> -#include <wine/exception.h> +#define EXCEPTION_WINE_STUB 0x80000100 +#define EH_NONCONTINUABLE 0x01 ULONG __cdecl DbgPrint(_In_z_ _Printf_format_string_ PCSTR Format, ...);

1 0

02/02: [NTOS:CC] Use UNIMPLEMENTED_ONCE instead of custom code
by Serge Gautherie 07 Apr '18

07 Apr '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=6618a2fd2ce002b97f480… commit 6618a2fd2ce002b97f4801f2d748f74bab68cccb Author: Serge Gautherie <reactos-git_serge_171003(a)gautherie.fr> AuthorDate: Thu Feb 22 15:31:04 2018 +0100 Commit: Mark Jansen <mark.jansen(a)reactos.org> CommitDate: Sat Apr 7 12:00:10 2018 +0200 [NTOS:CC] Use UNIMPLEMENTED_ONCE instead of custom code - Rewrite e319f85e67b1d057fb1c0d0449a6756fa0d459ba. --- ntoskrnl/cc/cacheman.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/ntoskrnl/cc/cacheman.c b/ntoskrnl/cc/cacheman.c index a2f9a9bb44..8ccd6a703d 100644 --- a/ntoskrnl/cc/cacheman.c +++ b/ntoskrnl/cc/cacheman.c @@ -165,7 +165,6 @@ CcScheduleReadAhead ( LARGE_INTEGER NewOffset; PROS_SHARED_CACHE_MAP SharedCacheMap; PPRIVATE_CACHE_MAP PrivateCacheMap; - static ULONG Warn; SharedCacheMap = FileObject->SectionObjectPointer->SharedCacheMap; PrivateCacheMap = FileObject->PrivateCacheMap; @@ -215,7 +214,7 @@ CcScheduleReadAhead ( { /* FIXME: handle the other cases */ KeReleaseSpinLock(&PrivateCacheMap->ReadAheadSpinLock, OldIrql); - if (!Warn++) UNIMPLEMENTED; + UNIMPLEMENTED_ONCE; return; } }

1 0

01/02: [SDK:REACTOS] Define UNIMPLEMENTED_ONCE for "!DBG && _MSC_VER" too
by Serge Gautherie 07 Apr '18

07 Apr '18

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=c704cf5f87a818bda66bf… commit c704cf5f87a818bda66bfad8cb75badedfc5c208 Author: Serge Gautherie <reactos-git_serge_171003(a)gautherie.fr> AuthorDate: Thu Feb 22 15:26:10 2018 +0100 Commit: Mark Jansen <mark.jansen(a)reactos.org> CommitDate: Sat Apr 7 12:00:10 2018 +0200 [SDK:REACTOS] Define UNIMPLEMENTED_ONCE for "!DBG && _MSC_VER" too - Addendum to 81eb3bbceb518c331f3d8e4754ad61adc0e94d33. - Merge "_MSC_VER" and "!_MSC_VER" cases, to prevent such a mistake. --- sdk/include/reactos/debug.h | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/sdk/include/reactos/debug.h b/sdk/include/reactos/debug.h index 70c3cb488e..adecac6f46 100644 --- a/sdk/include/reactos/debug.h +++ b/sdk/include/reactos/debug.h @@ -132,12 +132,12 @@ RtlAssert( #else /* not DBG */ /* On non-debug builds, we never show these */ + #define UNIMPLEMENTED + #define UNIMPLEMENTED_ONCE #if defined(_MSC_VER) #define DPRINT1 __noop #define DPRINT __noop - #define UNIMPLEMENTED - #define ERR_(ch, ...) __noop #define WARN_(ch, ...) __noop #define TRACE_(ch, ...) __noop @@ -151,9 +151,6 @@ RtlAssert( #define DPRINT1(...) do { if(0) { DbgPrint(__VA_ARGS__); } } while(0) #define DPRINT(...) do { if(0) { DbgPrint(__VA_ARGS__); } } while(0) - #define UNIMPLEMENTED - #define UNIMPLEMENTED_ONCE - #define ERR_(ch, ...) do { if(0) { DbgPrint(__VA_ARGS__); } } while(0) #define WARN_(ch, ...) do { if(0) { DbgPrint(__VA_ARGS__); } } while(0) #define TRACE_(ch, ...) do { if(0) { DbgPrint(__VA_ARGS__); } } while(0)

1 0

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs