mirror of
https://github.com/ZDoom/qzdoom.git
synced 2025-03-16 16:01:06 +00:00
Merge branch 'master' of https://github.com/coelckers/gzdoom
This commit is contained in:
commit
4eb98c6c5b
72 changed files with 2145 additions and 1855 deletions
|
@ -1,373 +0,0 @@
|
|||
Mozilla Public License Version 2.0
|
||||
==================================
|
||||
|
||||
1. Definitions
|
||||
--------------
|
||||
|
||||
1.1. "Contributor"
|
||||
means each individual or legal entity that creates, contributes to
|
||||
the creation of, or owns Covered Software.
|
||||
|
||||
1.2. "Contributor Version"
|
||||
means the combination of the Contributions of others (if any) used
|
||||
by a Contributor and that particular Contributor's Contribution.
|
||||
|
||||
1.3. "Contribution"
|
||||
means Covered Software of a particular Contributor.
|
||||
|
||||
1.4. "Covered Software"
|
||||
means Source Code Form to which the initial Contributor has attached
|
||||
the notice in Exhibit A, the Executable Form of such Source Code
|
||||
Form, and Modifications of such Source Code Form, in each case
|
||||
including portions thereof.
|
||||
|
||||
1.5. "Incompatible With Secondary Licenses"
|
||||
means
|
||||
|
||||
(a) that the initial Contributor has attached the notice described
|
||||
in Exhibit B to the Covered Software; or
|
||||
|
||||
(b) that the Covered Software was made available under the terms of
|
||||
version 1.1 or earlier of the License, but not also under the
|
||||
terms of a Secondary License.
|
||||
|
||||
1.6. "Executable Form"
|
||||
means any form of the work other than Source Code Form.
|
||||
|
||||
1.7. "Larger Work"
|
||||
means a work that combines Covered Software with other material, in
|
||||
a separate file or files, that is not Covered Software.
|
||||
|
||||
1.8. "License"
|
||||
means this document.
|
||||
|
||||
1.9. "Licensable"
|
||||
means having the right to grant, to the maximum extent possible,
|
||||
whether at the time of the initial grant or subsequently, any and
|
||||
all of the rights conveyed by this License.
|
||||
|
||||
1.10. "Modifications"
|
||||
means any of the following:
|
||||
|
||||
(a) any file in Source Code Form that results from an addition to,
|
||||
deletion from, or modification of the contents of Covered
|
||||
Software; or
|
||||
|
||||
(b) any new file in Source Code Form that contains any Covered
|
||||
Software.
|
||||
|
||||
1.11. "Patent Claims" of a Contributor
|
||||
means any patent claim(s), including without limitation, method,
|
||||
process, and apparatus claims, in any patent Licensable by such
|
||||
Contributor that would be infringed, but for the grant of the
|
||||
License, by the making, using, selling, offering for sale, having
|
||||
made, import, or transfer of either its Contributions or its
|
||||
Contributor Version.
|
||||
|
||||
1.12. "Secondary License"
|
||||
means either the GNU General Public License, Version 2.0, the GNU
|
||||
Lesser General Public License, Version 2.1, the GNU Affero General
|
||||
Public License, Version 3.0, or any later versions of those
|
||||
licenses.
|
||||
|
||||
1.13. "Source Code Form"
|
||||
means the form of the work preferred for making modifications.
|
||||
|
||||
1.14. "You" (or "Your")
|
||||
means an individual or a legal entity exercising rights under this
|
||||
License. For legal entities, "You" includes any entity that
|
||||
controls, is controlled by, or is under common control with You. For
|
||||
purposes of this definition, "control" means (a) the power, direct
|
||||
or indirect, to cause the direction or management of such entity,
|
||||
whether by contract or otherwise, or (b) ownership of more than
|
||||
fifty percent (50%) of the outstanding shares or beneficial
|
||||
ownership of such entity.
|
||||
|
||||
2. License Grants and Conditions
|
||||
--------------------------------
|
||||
|
||||
2.1. Grants
|
||||
|
||||
Each Contributor hereby grants You a world-wide, royalty-free,
|
||||
non-exclusive license:
|
||||
|
||||
(a) under intellectual property rights (other than patent or trademark)
|
||||
Licensable by such Contributor to use, reproduce, make available,
|
||||
modify, display, perform, distribute, and otherwise exploit its
|
||||
Contributions, either on an unmodified basis, with Modifications, or
|
||||
as part of a Larger Work; and
|
||||
|
||||
(b) under Patent Claims of such Contributor to make, use, sell, offer
|
||||
for sale, have made, import, and otherwise transfer either its
|
||||
Contributions or its Contributor Version.
|
||||
|
||||
2.2. Effective Date
|
||||
|
||||
The licenses granted in Section 2.1 with respect to any Contribution
|
||||
become effective for each Contribution on the date the Contributor first
|
||||
distributes such Contribution.
|
||||
|
||||
2.3. Limitations on Grant Scope
|
||||
|
||||
The licenses granted in this Section 2 are the only rights granted under
|
||||
this License. No additional rights or licenses will be implied from the
|
||||
distribution or licensing of Covered Software under this License.
|
||||
Notwithstanding Section 2.1(b) above, no patent license is granted by a
|
||||
Contributor:
|
||||
|
||||
(a) for any code that a Contributor has removed from Covered Software;
|
||||
or
|
||||
|
||||
(b) for infringements caused by: (i) Your and any other third party's
|
||||
modifications of Covered Software, or (ii) the combination of its
|
||||
Contributions with other software (except as part of its Contributor
|
||||
Version); or
|
||||
|
||||
(c) under Patent Claims infringed by Covered Software in the absence of
|
||||
its Contributions.
|
||||
|
||||
This License does not grant any rights in the trademarks, service marks,
|
||||
or logos of any Contributor (except as may be necessary to comply with
|
||||
the notice requirements in Section 3.4).
|
||||
|
||||
2.4. Subsequent Licenses
|
||||
|
||||
No Contributor makes additional grants as a result of Your choice to
|
||||
distribute the Covered Software under a subsequent version of this
|
||||
License (see Section 10.2) or under the terms of a Secondary License (if
|
||||
permitted under the terms of Section 3.3).
|
||||
|
||||
2.5. Representation
|
||||
|
||||
Each Contributor represents that the Contributor believes its
|
||||
Contributions are its original creation(s) or it has sufficient rights
|
||||
to grant the rights to its Contributions conveyed by this License.
|
||||
|
||||
2.6. Fair Use
|
||||
|
||||
This License is not intended to limit any rights You have under
|
||||
applicable copyright doctrines of fair use, fair dealing, or other
|
||||
equivalents.
|
||||
|
||||
2.7. Conditions
|
||||
|
||||
Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
|
||||
in Section 2.1.
|
||||
|
||||
3. Responsibilities
|
||||
-------------------
|
||||
|
||||
3.1. Distribution of Source Form
|
||||
|
||||
All distribution of Covered Software in Source Code Form, including any
|
||||
Modifications that You create or to which You contribute, must be under
|
||||
the terms of this License. You must inform recipients that the Source
|
||||
Code Form of the Covered Software is governed by the terms of this
|
||||
License, and how they can obtain a copy of this License. You may not
|
||||
attempt to alter or restrict the recipients' rights in the Source Code
|
||||
Form.
|
||||
|
||||
3.2. Distribution of Executable Form
|
||||
|
||||
If You distribute Covered Software in Executable Form then:
|
||||
|
||||
(a) such Covered Software must also be made available in Source Code
|
||||
Form, as described in Section 3.1, and You must inform recipients of
|
||||
the Executable Form how they can obtain a copy of such Source Code
|
||||
Form by reasonable means in a timely manner, at a charge no more
|
||||
than the cost of distribution to the recipient; and
|
||||
|
||||
(b) You may distribute such Executable Form under the terms of this
|
||||
License, or sublicense it under different terms, provided that the
|
||||
license for the Executable Form does not attempt to limit or alter
|
||||
the recipients' rights in the Source Code Form under this License.
|
||||
|
||||
3.3. Distribution of a Larger Work
|
||||
|
||||
You may create and distribute a Larger Work under terms of Your choice,
|
||||
provided that You also comply with the requirements of this License for
|
||||
the Covered Software. If the Larger Work is a combination of Covered
|
||||
Software with a work governed by one or more Secondary Licenses, and the
|
||||
Covered Software is not Incompatible With Secondary Licenses, this
|
||||
License permits You to additionally distribute such Covered Software
|
||||
under the terms of such Secondary License(s), so that the recipient of
|
||||
the Larger Work may, at their option, further distribute the Covered
|
||||
Software under the terms of either this License or such Secondary
|
||||
License(s).
|
||||
|
||||
3.4. Notices
|
||||
|
||||
You may not remove or alter the substance of any license notices
|
||||
(including copyright notices, patent notices, disclaimers of warranty,
|
||||
or limitations of liability) contained within the Source Code Form of
|
||||
the Covered Software, except that You may alter any license notices to
|
||||
the extent required to remedy known factual inaccuracies.
|
||||
|
||||
3.5. Application of Additional Terms
|
||||
|
||||
You may choose to offer, and to charge a fee for, warranty, support,
|
||||
indemnity or liability obligations to one or more recipients of Covered
|
||||
Software. However, You may do so only on Your own behalf, and not on
|
||||
behalf of any Contributor. You must make it absolutely clear that any
|
||||
such warranty, support, indemnity, or liability obligation is offered by
|
||||
You alone, and You hereby agree to indemnify every Contributor for any
|
||||
liability incurred by such Contributor as a result of warranty, support,
|
||||
indemnity or liability terms You offer. You may include additional
|
||||
disclaimers of warranty and limitations of liability specific to any
|
||||
jurisdiction.
|
||||
|
||||
4. Inability to Comply Due to Statute or Regulation
|
||||
---------------------------------------------------
|
||||
|
||||
If it is impossible for You to comply with any of the terms of this
|
||||
License with respect to some or all of the Covered Software due to
|
||||
statute, judicial order, or regulation then You must: (a) comply with
|
||||
the terms of this License to the maximum extent possible; and (b)
|
||||
describe the limitations and the code they affect. Such description must
|
||||
be placed in a text file included with all distributions of the Covered
|
||||
Software under this License. Except to the extent prohibited by statute
|
||||
or regulation, such description must be sufficiently detailed for a
|
||||
recipient of ordinary skill to be able to understand it.
|
||||
|
||||
5. Termination
|
||||
--------------
|
||||
|
||||
5.1. The rights granted under this License will terminate automatically
|
||||
if You fail to comply with any of its terms. However, if You become
|
||||
compliant, then the rights granted under this License from a particular
|
||||
Contributor are reinstated (a) provisionally, unless and until such
|
||||
Contributor explicitly and finally terminates Your grants, and (b) on an
|
||||
ongoing basis, if such Contributor fails to notify You of the
|
||||
non-compliance by some reasonable means prior to 60 days after You have
|
||||
come back into compliance. Moreover, Your grants from a particular
|
||||
Contributor are reinstated on an ongoing basis if such Contributor
|
||||
notifies You of the non-compliance by some reasonable means, this is the
|
||||
first time You have received notice of non-compliance with this License
|
||||
from such Contributor, and You become compliant prior to 30 days after
|
||||
Your receipt of the notice.
|
||||
|
||||
5.2. If You initiate litigation against any entity by asserting a patent
|
||||
infringement claim (excluding declaratory judgment actions,
|
||||
counter-claims, and cross-claims) alleging that a Contributor Version
|
||||
directly or indirectly infringes any patent, then the rights granted to
|
||||
You by any and all Contributors for the Covered Software under Section
|
||||
2.1 of this License shall terminate.
|
||||
|
||||
5.3. In the event of termination under Sections 5.1 or 5.2 above, all
|
||||
end user license agreements (excluding distributors and resellers) which
|
||||
have been validly granted by You or Your distributors under this License
|
||||
prior to termination shall survive termination.
|
||||
|
||||
************************************************************************
|
||||
* *
|
||||
* 6. Disclaimer of Warranty *
|
||||
* ------------------------- *
|
||||
* *
|
||||
* Covered Software is provided under this License on an "as is" *
|
||||
* basis, without warranty of any kind, either expressed, implied, or *
|
||||
* statutory, including, without limitation, warranties that the *
|
||||
* Covered Software is free of defects, merchantable, fit for a *
|
||||
* particular purpose or non-infringing. The entire risk as to the *
|
||||
* quality and performance of the Covered Software is with You. *
|
||||
* Should any Covered Software prove defective in any respect, You *
|
||||
* (not any Contributor) assume the cost of any necessary servicing, *
|
||||
* repair, or correction. This disclaimer of warranty constitutes an *
|
||||
* essential part of this License. No use of any Covered Software is *
|
||||
* authorized under this License except under this disclaimer. *
|
||||
* *
|
||||
************************************************************************
|
||||
|
||||
************************************************************************
|
||||
* *
|
||||
* 7. Limitation of Liability *
|
||||
* -------------------------- *
|
||||
* *
|
||||
* Under no circumstances and under no legal theory, whether tort *
|
||||
* (including negligence), contract, or otherwise, shall any *
|
||||
* Contributor, or anyone who distributes Covered Software as *
|
||||
* permitted above, be liable to You for any direct, indirect, *
|
||||
* special, incidental, or consequential damages of any character *
|
||||
* including, without limitation, damages for lost profits, loss of *
|
||||
* goodwill, work stoppage, computer failure or malfunction, or any *
|
||||
* and all other commercial damages or losses, even if such party *
|
||||
* shall have been informed of the possibility of such damages. This *
|
||||
* limitation of liability shall not apply to liability for death or *
|
||||
* personal injury resulting from such party's negligence to the *
|
||||
* extent applicable law prohibits such limitation. Some *
|
||||
* jurisdictions do not allow the exclusion or limitation of *
|
||||
* incidental or consequential damages, so this exclusion and *
|
||||
* limitation may not apply to You. *
|
||||
* *
|
||||
************************************************************************
|
||||
|
||||
8. Litigation
|
||||
-------------
|
||||
|
||||
Any litigation relating to this License may be brought only in the
|
||||
courts of a jurisdiction where the defendant maintains its principal
|
||||
place of business and such litigation shall be governed by laws of that
|
||||
jurisdiction, without reference to its conflict-of-law provisions.
|
||||
Nothing in this Section shall prevent a party's ability to bring
|
||||
cross-claims or counter-claims.
|
||||
|
||||
9. Miscellaneous
|
||||
----------------
|
||||
|
||||
This License represents the complete agreement concerning the subject
|
||||
matter hereof. If any provision of this License is held to be
|
||||
unenforceable, such provision shall be reformed only to the extent
|
||||
necessary to make it enforceable. Any law or regulation which provides
|
||||
that the language of a contract shall be construed against the drafter
|
||||
shall not be used to construe this License against a Contributor.
|
||||
|
||||
10. Versions of the License
|
||||
---------------------------
|
||||
|
||||
10.1. New Versions
|
||||
|
||||
Mozilla Foundation is the license steward. Except as provided in Section
|
||||
10.3, no one other than the license steward has the right to modify or
|
||||
publish new versions of this License. Each version will be given a
|
||||
distinguishing version number.
|
||||
|
||||
10.2. Effect of New Versions
|
||||
|
||||
You may distribute the Covered Software under the terms of the version
|
||||
of the License under which You originally received the Covered Software,
|
||||
or under the terms of any subsequent version published by the license
|
||||
steward.
|
||||
|
||||
10.3. Modified Versions
|
||||
|
||||
If you create software not governed by this License, and you want to
|
||||
create a new license for such software, you may create and use a
|
||||
modified version of this License if you rename the license and remove
|
||||
any references to the name of the license steward (except to note that
|
||||
such modified license differs from this License).
|
||||
|
||||
10.4. Distributing Source Code Form that is Incompatible With Secondary
|
||||
Licenses
|
||||
|
||||
If You choose to distribute Source Code Form that is Incompatible With
|
||||
Secondary Licenses under the terms of this version of the License, the
|
||||
notice described in Exhibit B of this License must be attached.
|
||||
|
||||
Exhibit A - Source Code Form License Notice
|
||||
-------------------------------------------
|
||||
|
||||
This Source Code Form is subject to the terms of the Mozilla Public
|
||||
License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
||||
|
||||
If it is not possible or desirable to put the notice in a particular
|
||||
file, then You may include the notice in a location (such as a LICENSE
|
||||
file in a relevant directory) where a recipient would be likely to look
|
||||
for such a notice.
|
||||
|
||||
You may add additional accurate notices of copyright ownership.
|
||||
|
||||
Exhibit B - "Incompatible With Secondary Licenses" Notice
|
||||
---------------------------------------------------------
|
||||
|
||||
This Source Code Form is "Incompatible With Secondary Licenses", as
|
||||
defined by the Mozilla Public License, v. 2.0.
|
|
@ -1,7 +1,7 @@
|
|||
#define MY_VER_MAJOR 17
|
||||
#define MY_VER_MAJOR 18
|
||||
#define MY_VER_MINOR 01
|
||||
#define MY_VER_BUILD 0
|
||||
#define MY_VERSION_NUMBERS "17.01 beta"
|
||||
#define MY_VERSION_NUMBERS "18.01"
|
||||
#define MY_VERSION MY_VERSION_NUMBERS
|
||||
|
||||
#ifdef MY_CPU_NAME
|
||||
|
@ -10,12 +10,12 @@
|
|||
#define MY_VERSION_CPU MY_VERSION
|
||||
#endif
|
||||
|
||||
#define MY_DATE "2017-08-28"
|
||||
#define MY_DATE "2018-01-28"
|
||||
#undef MY_COPYRIGHT
|
||||
#undef MY_VERSION_COPYRIGHT_DATE
|
||||
#define MY_AUTHOR_NAME "Igor Pavlov"
|
||||
#define MY_COPYRIGHT_PD "Igor Pavlov : Public domain"
|
||||
#define MY_COPYRIGHT_CR "Copyright (c) 1999-2017 Igor Pavlov"
|
||||
#define MY_COPYRIGHT_CR "Copyright (c) 1999-2018 Igor Pavlov"
|
||||
|
||||
#ifdef USE_COPYRIGHT_CR
|
||||
#define MY_COPYRIGHT MY_COPYRIGHT_CR
|
||||
|
|
|
@ -409,8 +409,7 @@ CHECK_CXX_SOURCE_COMPILES("thread_local int i; int main() { i = 0; }"
|
|||
HAVE_THREAD_LOCAL)
|
||||
|
||||
if( NOT HAVE_THREAD_LOCAL )
|
||||
message( WARNING "C++ compiler doesn't support thread_local storage duration specifier" )
|
||||
add_definitions( -Dthread_local= )
|
||||
message( SEND_ERROR "C++ compiler doesn't support thread_local storage duration specifier" )
|
||||
endif()
|
||||
|
||||
# Check for functions that may or may not exist.
|
||||
|
|
|
@ -348,13 +348,16 @@ int FIWadManager::CheckIWADInfo(const char *fn)
|
|||
FIWADInfo result;
|
||||
ParseIWadInfo(resfile->Filename, (const char*)lmp->CacheLump(), lmp->LumpSize, &result);
|
||||
delete resfile;
|
||||
for (auto &wadinf : mIWadInfos)
|
||||
|
||||
for (unsigned i = 0, count = mIWadInfos.Size(); i < count; ++i)
|
||||
{
|
||||
if (wadinf.Name == result.Name)
|
||||
if (mIWadInfos[i].Name == result.Name)
|
||||
{
|
||||
return -1; // do not show the same one twice.
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
mOrderNames.Push(result.Name);
|
||||
return mIWadInfos.Push(result);
|
||||
}
|
||||
catch (CRecoverableError &err)
|
||||
|
@ -434,7 +437,7 @@ void FIWadManager::AddIWADCandidates(const char *dir)
|
|||
if (p != nullptr)
|
||||
{
|
||||
// special IWAD extension.
|
||||
if (!stricmp(p, ".iwad") || !stricmp(p, ".ipk3") || !stricmp(p, "ipk7"))
|
||||
if (!stricmp(p, ".iwad") || !stricmp(p, ".ipk3") || !stricmp(p, ".ipk7"))
|
||||
{
|
||||
mFoundWads.Push(FFoundWadInfo{ slasheddir + FindName, "", -1 });
|
||||
}
|
||||
|
@ -468,7 +471,7 @@ void FIWadManager::ValidateIWADs()
|
|||
{
|
||||
int index;
|
||||
auto x = strrchr(p.mFullPath, '.');
|
||||
if (x != nullptr && (!stricmp(x, ".iwad") || !stricmp(x, ".ipk3") || !stricmp(x, "ipk7")))
|
||||
if (x != nullptr && (!stricmp(x, ".iwad") || !stricmp(x, ".ipk3") || !stricmp(x, ".ipk7")))
|
||||
{
|
||||
index = CheckIWADInfo(p.mFullPath);
|
||||
}
|
||||
|
@ -519,28 +522,39 @@ int FIWadManager::IdentifyVersion (TArray<FString> &wadfiles, const char *iwad,
|
|||
|
||||
if (iwadparm)
|
||||
{
|
||||
// Check if the given IWAD has an absolute path, in which case the search path will be ignored.
|
||||
custwad = iwadparm;
|
||||
FixPathSeperator(custwad);
|
||||
DefaultExtension(custwad, ".wad");
|
||||
bool isAbsolute = (custwad[0] == '/');
|
||||
const char* const extensions[] = { ".wad", ".pk3", ".iwad", ".ipk3", ".ipk7" };
|
||||
|
||||
for (auto ext : extensions)
|
||||
{
|
||||
// Check if the given IWAD has an absolute path, in which case the search path will be ignored.
|
||||
custwad = iwadparm;
|
||||
FixPathSeperator(custwad);
|
||||
DefaultExtension(custwad, ext);
|
||||
bool isAbsolute = (custwad[0] == '/');
|
||||
#ifdef WINDOWS
|
||||
isAbsolute |= (custwad.Len() >= 2 && custwad[1] == ':');
|
||||
isAbsolute |= (custwad.Len() >= 2 && custwad[1] == ':');
|
||||
#endif
|
||||
if (isAbsolute)
|
||||
{
|
||||
if (FileExists(custwad)) mFoundWads.Push({ custwad, "", -1 });
|
||||
}
|
||||
else
|
||||
{
|
||||
for (auto &dir : mSearchPaths)
|
||||
if (isAbsolute)
|
||||
{
|
||||
FStringf fullpath("%s/%s", dir.GetChars(), custwad.GetChars());
|
||||
if (FileExists(fullpath))
|
||||
if (FileExists(custwad)) mFoundWads.Push({ custwad, "", -1 });
|
||||
}
|
||||
else
|
||||
{
|
||||
for (auto &dir : mSearchPaths)
|
||||
{
|
||||
mFoundWads.Push({ fullpath, "", -1 });
|
||||
FStringf fullpath("%s/%s", dir.GetChars(), custwad.GetChars());
|
||||
if (FileExists(fullpath))
|
||||
{
|
||||
mFoundWads.Push({ fullpath, "", -1 });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (mFoundWads.Size() != numFoundWads)
|
||||
{
|
||||
// Found IWAD with guessed extension
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
// -iwad not found or not specified. Revert back to standard behavior.
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
|
||||
#define NO_SEND_STATS
|
||||
#ifdef NO_SEND_STATS
|
||||
|
||||
void D_DoAnonStats()
|
||||
|
|
|
@ -174,8 +174,9 @@ bool E_CheckHandler(DStaticEventHandler* handler)
|
|||
|
||||
bool E_IsStaticType(PClass* type)
|
||||
{
|
||||
return (type->IsDescendantOf(RUNTIME_CLASS(DStaticEventHandler)) && // make sure it's from our hierarchy at all.
|
||||
!type->IsDescendantOf(RUNTIME_CLASS(DEventHandler)));
|
||||
assert(type != nullptr);
|
||||
assert(type->IsDescendantOf(RUNTIME_CLASS(DStaticEventHandler)));
|
||||
return !type->IsDescendantOf(RUNTIME_CLASS(DEventHandler));
|
||||
}
|
||||
|
||||
void E_SerializeEvents(FSerializer& arc)
|
||||
|
@ -230,27 +231,24 @@ void E_SerializeEvents(FSerializer& arc)
|
|||
}
|
||||
}
|
||||
|
||||
static void E_InitStaticHandler(PClass* type, FString typestring, bool map)
|
||||
static PClass* E_GetHandlerClass(const FString& typeName)
|
||||
{
|
||||
PClass* type = PClass::FindClass(typeName);
|
||||
|
||||
if (type == nullptr)
|
||||
{
|
||||
I_Error("Fatal: unknown event handler class %s in MAPINFO!\n", typestring.GetChars());
|
||||
return;
|
||||
|
||||
I_Error("Fatal: unknown event handler class %s", typeName.GetChars());
|
||||
}
|
||||
else if (!type->IsDescendantOf(RUNTIME_CLASS(DStaticEventHandler)))
|
||||
{
|
||||
I_Error("Fatal: event handler class %s is not derived from StaticEventHandler", typeName.GetChars());
|
||||
}
|
||||
|
||||
if (E_IsStaticType(type) && map)
|
||||
{
|
||||
I_Error("Fatal: invalid event handler class %s in MAPINFO!\nMap-specific event handlers cannot be static.\n", typestring.GetChars());
|
||||
return;
|
||||
}
|
||||
/*
|
||||
if (!E_IsStaticType(type) && !map)
|
||||
{
|
||||
Printf("%cGWarning: invalid event handler class %s in MAPINFO!\nMAPINFO event handlers should inherit Static* directly!\n", TEXTCOLOR_ESCAPE, typestring.GetChars());
|
||||
return;
|
||||
}*/
|
||||
return type;
|
||||
}
|
||||
|
||||
static void E_InitHandler(PClass* type)
|
||||
{
|
||||
// check if type already exists, don't add twice.
|
||||
bool typeExists = false;
|
||||
for (DStaticEventHandler* handler = E_FirstEventHandler; handler; handler = handler->next)
|
||||
|
@ -269,41 +267,34 @@ static void E_InitStaticHandler(PClass* type, FString typestring, bool map)
|
|||
|
||||
void E_InitStaticHandlers(bool map)
|
||||
{
|
||||
// don't initialize map handlers if restoring from savegame.
|
||||
if (savegamerestore)
|
||||
return;
|
||||
|
||||
// just make sure
|
||||
E_Shutdown(map);
|
||||
|
||||
if (map) // don't initialize map handlers if restoring from savegame.
|
||||
// initialize event handlers from gameinfo
|
||||
for (const FString& typeName : gameinfo.EventHandlers)
|
||||
{
|
||||
// load non-static handlers from gameinfo
|
||||
for (unsigned int i = 0; i < gameinfo.EventHandlers.Size(); i++)
|
||||
{
|
||||
FString typestring = gameinfo.EventHandlers[i];
|
||||
PClass* type = PClass::FindClass(typestring);
|
||||
if (!type || E_IsStaticType(type)) // don't init the really global stuff here.
|
||||
continue;
|
||||
E_InitStaticHandler(type, typestring, false);
|
||||
}
|
||||
|
||||
for (unsigned int i = 0; i < level.info->EventHandlers.Size(); i++)
|
||||
{
|
||||
FString typestring = level.info->EventHandlers[i];
|
||||
PClass* type = PClass::FindClass(typestring);
|
||||
E_InitStaticHandler(type, typestring, true);
|
||||
}
|
||||
PClass* type = E_GetHandlerClass(typeName);
|
||||
// don't init the really global stuff here on startup initialization.
|
||||
// don't init map-local global stuff here on level setup.
|
||||
if (map == E_IsStaticType(type))
|
||||
continue;
|
||||
E_InitHandler(type);
|
||||
}
|
||||
else
|
||||
|
||||
if (!map)
|
||||
return;
|
||||
|
||||
// initialize event handlers from mapinfo
|
||||
for (const FString& typeName : level.info->EventHandlers)
|
||||
{
|
||||
for (unsigned int i = 0; i < gameinfo.EventHandlers.Size(); i++)
|
||||
{
|
||||
FString typestring = gameinfo.EventHandlers[i];
|
||||
PClass* type = PClass::FindClass(typestring);
|
||||
if (!type || !E_IsStaticType(type)) // don't init map-local global stuff here.
|
||||
continue;
|
||||
E_InitStaticHandler(type, typestring, false);
|
||||
}
|
||||
PClass* type = E_GetHandlerClass(typeName);
|
||||
if (E_IsStaticType(type))
|
||||
I_Error("Fatal: invalid event handler class %s in MAPINFO!\nMap-specific event handlers cannot be static.\n", typeName.GetChars());
|
||||
E_InitHandler(type);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -36,6 +36,7 @@
|
|||
#include "serializer.h"
|
||||
#include "g_levellocals.h"
|
||||
#include "events.h"
|
||||
#include "gi.h"
|
||||
|
||||
static FRandom pr_lightning ("Lightning");
|
||||
|
||||
|
@ -205,6 +206,32 @@ static DLightningThinker *LocateLightning ()
|
|||
|
||||
void P_StartLightning ()
|
||||
{
|
||||
const bool isOriginalHexen = (gameinfo.gametype == GAME_Hexen)
|
||||
&& (level.flags2 & LEVEL2_HEXENHACK);
|
||||
|
||||
if (isOriginalHexen)
|
||||
{
|
||||
bool hasLightning = false;
|
||||
|
||||
for (const sector_t §or : level.sectors)
|
||||
{
|
||||
hasLightning = sector.GetTexture(sector_t::ceiling) == skyflatnum
|
||||
|| sector.special == Light_IndoorLightning1
|
||||
|| sector.special == Light_IndoorLightning2;
|
||||
|
||||
if (hasLightning)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!hasLightning)
|
||||
{
|
||||
level.flags &= ~LEVEL_STARTLIGHTNING;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
DLightningThinker *lightning = LocateLightning ();
|
||||
if (lightning == NULL)
|
||||
{
|
||||
|
|
|
@ -1392,12 +1392,6 @@ void GLWall::DoFFloorBlocks(seg_t * seg, sector_t * frontsector, sector_t * back
|
|||
ff_topleft = topleft;
|
||||
ff_topright = topright;
|
||||
}
|
||||
if (ff_bottomleft < bottomleft && ff_bottomright < bottomright)
|
||||
{
|
||||
// the new section extends into the floor.
|
||||
ff_bottomleft = bottomleft;
|
||||
ff_bottomright = bottomright;
|
||||
}
|
||||
|
||||
// do all inverse floors above the current one it there is a gap between the
|
||||
// last 3D floor and this one.
|
||||
|
|
|
@ -487,7 +487,7 @@ unsigned FSavegameManager::ExtractSaveData(int index)
|
|||
arc("Comment", pcomment);
|
||||
|
||||
comment = time;
|
||||
if (time.Len() > 0) comment += "\n\n";
|
||||
if (time.Len() > 0) comment += "\n";
|
||||
comment += pcomment;
|
||||
|
||||
SaveComment = V_BreakLines(SmallFont, WindowSize, comment.GetChars());
|
||||
|
@ -619,10 +619,12 @@ void FSavegameManager::DrawSaveComment(FFont *font, int cr, int x, int y, int sc
|
|||
|
||||
CleanXfac = CleanYfac = scalefactor;
|
||||
|
||||
int maxlines = screen->GetHeight()>400?10:screen->GetHeight()>240?7:screen->GetHeight()>200?8:5;
|
||||
if (SmallFont->GetHeight() > 9) maxlines--; // not Doom
|
||||
// I'm not sure why SaveComment would go nullptr in this loop, but I got
|
||||
// a crash report where it was nullptr when i reached 1, so now I check
|
||||
// for that.
|
||||
for (int i = 0; SaveComment != nullptr && SaveComment[i].Width >= 0 && i < 6; ++i)
|
||||
for (int i = 0; SaveComment != nullptr && SaveComment[i].Width >= 0 && i < maxlines; ++i)
|
||||
{
|
||||
screen->DrawText(font, cr, x, y + font->GetHeight() * i * scalefactor, SaveComment[i].Text, DTA_CleanNoMove, true, TAG_DONE);
|
||||
}
|
||||
|
|
|
@ -1429,11 +1429,11 @@ static void InitMusicMenus()
|
|||
|
||||
if (menu != nullptr)
|
||||
{
|
||||
if (soundfonts.Size() > 0)
|
||||
int adl_banks_count = adl_getBanksCount();
|
||||
if (adl_banks_count > 0)
|
||||
{
|
||||
int adl_banks_count = adl_getBanksCount();
|
||||
const char *const *adl_bank_names = adl_getBankNames();
|
||||
for(int i=0; i < adl_banks_count; i++)
|
||||
for (int i=0; i < adl_banks_count; i++)
|
||||
{
|
||||
auto it = CreateOptionMenuItemCommand(adl_bank_names[i], FStringf("adl_bank %d", i), true);
|
||||
static_cast<DOptionMenuDescriptor*>(*menu)->mItems.Push(it);
|
||||
|
|
|
@ -129,7 +129,7 @@ private:
|
|||
{
|
||||
FString Str;
|
||||
unsigned int Hash;
|
||||
unsigned int Next;
|
||||
unsigned int Next = FREE_ENTRY;
|
||||
bool Mark;
|
||||
TArray<int> Locks;
|
||||
|
||||
|
|
|
@ -6765,7 +6765,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_CheckTerrain)
|
|||
DEFINE_ACTION_FUNCTION(AActor, A_SetSize)
|
||||
{
|
||||
PARAM_SELF_PROLOGUE(AActor);
|
||||
PARAM_FLOAT(newradius);
|
||||
PARAM_FLOAT_DEF(newradius);
|
||||
PARAM_FLOAT_DEF(newheight);
|
||||
PARAM_BOOL_DEF(testpos);
|
||||
|
||||
|
|
|
@ -227,9 +227,16 @@ void P_LoadStrifeConversations (MapData *map, const char *mapname)
|
|||
bool LoadScriptFile (const char *name, bool include, int type)
|
||||
{
|
||||
int lumpnum = Wads.CheckNumForName (name);
|
||||
const bool found = lumpnum >= 0
|
||||
|| (lumpnum = Wads.CheckNumForFullName (name)) >= 0;
|
||||
|
||||
if (lumpnum < 0)
|
||||
if (!found)
|
||||
{
|
||||
if (type == 0)
|
||||
{
|
||||
Printf(TEXTCOLOR_RED "Could not find dialog file %s", name);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
FileReader lump = Wads.ReopenLumpReader (lumpnum);
|
||||
|
|
|
@ -4888,8 +4888,8 @@ bool P_LineTrace(AActor *t1, DAngle angle, double distance,
|
|||
|
||||
ActorFlags aflags = (flags & TRF_ALLACTORS) ? ActorFlags::FromInt(0xFFFFFFFF) : MF_SHOOTABLE;
|
||||
int lflags = 0;
|
||||
if ( !(lflags & TRF_THRUBLOCK) ) lflags |= ML_BLOCKEVERYTHING;
|
||||
if ( !(lflags & TRF_THRUHITSCAN) ) lflags |= ML_BLOCKHITSCAN;
|
||||
if ( !(flags & TRF_THRUBLOCK) ) lflags |= ML_BLOCKEVERYTHING;
|
||||
if ( !(flags & TRF_THRUHITSCAN) ) lflags |= ML_BLOCKHITSCAN;
|
||||
int tflags = TRACE_ReportPortals;
|
||||
if ( flags & TRF_NOSKY ) tflags |= TRACE_NoSky;
|
||||
|
||||
|
|
|
@ -8317,15 +8317,15 @@ DEFINE_ACTION_FUNCTION(AActor, Vec2To)
|
|||
{
|
||||
PARAM_SELF_PROLOGUE(AActor);
|
||||
PARAM_OBJECT_NOT_NULL(t, AActor)
|
||||
ACTION_RETURN_VEC2(self->Vec2To(t));
|
||||
ACTION_RETURN_VEC2(self->Vec2To(t));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(AActor, Vec3Angle)
|
||||
{
|
||||
PARAM_SELF_PROLOGUE(AActor);
|
||||
PARAM_FLOAT(length)
|
||||
PARAM_ANGLE(angle);
|
||||
PARAM_FLOAT(z);
|
||||
PARAM_ANGLE(angle);
|
||||
PARAM_FLOAT_DEF(z);
|
||||
PARAM_BOOL_DEF(absolute);
|
||||
ACTION_RETURN_VEC3(self->Vec3Angle(length, angle, z, absolute));
|
||||
}
|
||||
|
|
|
@ -153,10 +153,13 @@ DPSprite::DPSprite(player_t *owner, AActor *caller, int id)
|
|||
: x(.0), y(.0),
|
||||
oldx(.0), oldy(.0),
|
||||
firstTic(true),
|
||||
Tics(0),
|
||||
Flags(0),
|
||||
Caller(caller),
|
||||
Owner(owner),
|
||||
State(nullptr),
|
||||
Sprite(0),
|
||||
Frame(0),
|
||||
ID(id),
|
||||
processPending(true)
|
||||
{
|
||||
|
|
|
@ -242,6 +242,28 @@ bool P_ActivateLine (line_t *line, AActor *mo, int side, int activationType, DVe
|
|||
return true;
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Line, Activate)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(line_t);
|
||||
PARAM_POINTER(mo, AActor);
|
||||
PARAM_INT(side);
|
||||
PARAM_INT(activationType);
|
||||
ACTION_RETURN_BOOL(P_ActivateLine(self, mo, side, activationType, NULL));
|
||||
}
|
||||
|
||||
DEFINE_ACTION_FUNCTION(_Line, RemoteActivate)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(line_t);
|
||||
PARAM_POINTER(mo, AActor);
|
||||
PARAM_INT(side);
|
||||
PARAM_INT(activationType);
|
||||
PARAM_FLOAT(optx);
|
||||
PARAM_FLOAT(opty);
|
||||
PARAM_FLOAT(optz);
|
||||
DVector3 optpos = DVector3(optx, opty, optz);
|
||||
ACTION_RETURN_BOOL(P_ActivateLine(self, mo, side, activationType, &optpos));
|
||||
}
|
||||
|
||||
//============================================================================
|
||||
//
|
||||
// P_TestActivateLine
|
||||
|
|
|
@ -354,7 +354,8 @@ void RenderPolyPlayerSprites::RenderSprite(PolyRenderThread *thread, DPSprite *p
|
|||
invertcolormap = !invertcolormap;
|
||||
}
|
||||
|
||||
bool fullbright = !foggy && pspr->GetState()->GetFullbright();
|
||||
const FState* const psprState = pspr->GetState();
|
||||
bool fullbright = !foggy && (psprState == nullptr ? false : psprState->GetFullbright());
|
||||
bool fadeToBlack = (vis.RenderStyle.Flags & STYLEF_FadeToBlack) != 0;
|
||||
|
||||
vis.Light.SetColormap(0, spriteshade, basecolormap, fullbright, invertcolormap, fadeToBlack);
|
||||
|
|
|
@ -55,6 +55,7 @@
|
|||
#include "v_text.h"
|
||||
#include "v_video.h"
|
||||
#include "version.h"
|
||||
#include "videomodes.h"
|
||||
|
||||
#include "gl/system/gl_system.h"
|
||||
#include "gl/data/gl_vertexbuffer.h"
|
||||
|
@ -402,80 +403,6 @@ extern id appCtrl;
|
|||
namespace
|
||||
{
|
||||
|
||||
const struct
|
||||
{
|
||||
uint16_t width;
|
||||
uint16_t height;
|
||||
}
|
||||
VideoModes[] =
|
||||
{
|
||||
{ 320, 200 },
|
||||
{ 320, 240 },
|
||||
{ 400, 225 }, // 16:9
|
||||
{ 400, 300 },
|
||||
{ 480, 270 }, // 16:9
|
||||
{ 480, 360 },
|
||||
{ 512, 288 }, // 16:9
|
||||
{ 512, 384 },
|
||||
{ 640, 360 }, // 16:9
|
||||
{ 640, 400 },
|
||||
{ 640, 480 },
|
||||
{ 720, 480 }, // 16:10
|
||||
{ 720, 540 },
|
||||
{ 800, 450 }, // 16:9
|
||||
{ 800, 480 },
|
||||
{ 800, 500 }, // 16:10
|
||||
{ 800, 600 },
|
||||
{ 848, 480 }, // 16:9
|
||||
{ 960, 600 }, // 16:10
|
||||
{ 960, 720 },
|
||||
{ 1024, 576 }, // 16:9
|
||||
{ 1024, 600 }, // 17:10
|
||||
{ 1024, 640 }, // 16:10
|
||||
{ 1024, 768 },
|
||||
{ 1088, 612 }, // 16:9
|
||||
{ 1152, 648 }, // 16:9
|
||||
{ 1152, 720 }, // 16:10
|
||||
{ 1152, 864 },
|
||||
{ 1280, 540 }, // 21:9
|
||||
{ 1280, 720 }, // 16:9
|
||||
{ 1280, 854 },
|
||||
{ 1280, 800 }, // 16:10
|
||||
{ 1280, 960 },
|
||||
{ 1280, 1024 }, // 5:4
|
||||
{ 1360, 768 }, // 16:9
|
||||
{ 1366, 768 },
|
||||
{ 1400, 787 }, // 16:9
|
||||
{ 1400, 875 }, // 16:10
|
||||
{ 1400, 1050 },
|
||||
{ 1440, 900 },
|
||||
{ 1440, 960 },
|
||||
{ 1440, 1080 },
|
||||
{ 1600, 900 }, // 16:9
|
||||
{ 1600, 1000 }, // 16:10
|
||||
{ 1600, 1200 },
|
||||
{ 1680, 1050 }, // 16:10
|
||||
{ 1920, 1080 },
|
||||
{ 1920, 1200 },
|
||||
{ 2048, 1152 }, // 16:9, iMac Retina 4K 21.5", HiDPI off
|
||||
{ 2048, 1536 },
|
||||
{ 2304, 1440 }, // 16:10, MacBook Retina 12"
|
||||
{ 2560, 1080 }, // 21:9
|
||||
{ 2560, 1440 },
|
||||
{ 2560, 1600 },
|
||||
{ 2560, 2048 },
|
||||
{ 2880, 1800 }, // 16:10, MacBook Pro Retina 15"
|
||||
{ 3200, 1800 },
|
||||
{ 3440, 1440 }, // 21:9
|
||||
{ 3840, 2160 },
|
||||
{ 3840, 2400 },
|
||||
{ 4096, 2160 },
|
||||
{ 4096, 2304 }, // 16:9, iMac Retina 4K 21.5"
|
||||
{ 5120, 2160 }, // 21:9
|
||||
{ 5120, 2880 } // 16:9, iMac Retina 5K 27"
|
||||
};
|
||||
|
||||
|
||||
cycle_t BlitCycles;
|
||||
cycle_t FlipCycles;
|
||||
|
||||
|
|
|
@ -45,6 +45,7 @@
|
|||
#include "version.h"
|
||||
#include "c_console.h"
|
||||
|
||||
#include "videomodes.h"
|
||||
#include "sdlglvideo.h"
|
||||
#include "sdlvideo.h"
|
||||
#include "gl/system/gl_system.h"
|
||||
|
@ -63,11 +64,6 @@
|
|||
|
||||
// TYPES -------------------------------------------------------------------
|
||||
|
||||
struct MiniModeInfo
|
||||
{
|
||||
uint16_t Width, Height;
|
||||
};
|
||||
|
||||
// PUBLIC FUNCTION PROTOTYPES ----------------------------------------------
|
||||
|
||||
// PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
|
||||
|
@ -114,67 +110,6 @@ CUSTOM_CVAR(Bool, gl_es, false, CVAR_ARCHIVE | CVAR_GLOBALCONFIG | CVAR_NOINITCA
|
|||
|
||||
// PRIVATE DATA DEFINITIONS ------------------------------------------------
|
||||
|
||||
// Dummy screen sizes to pass when windowed
|
||||
static MiniModeInfo WinModes[] =
|
||||
{
|
||||
{ 320, 200 },
|
||||
{ 320, 240 },
|
||||
{ 400, 225 }, // 16:9
|
||||
{ 400, 300 },
|
||||
{ 480, 270 }, // 16:9
|
||||
{ 480, 360 },
|
||||
{ 512, 288 }, // 16:9
|
||||
{ 512, 384 },
|
||||
{ 640, 360 }, // 16:9
|
||||
{ 640, 400 },
|
||||
{ 640, 480 },
|
||||
{ 720, 480 }, // 16:10
|
||||
{ 720, 540 },
|
||||
{ 800, 450 }, // 16:9
|
||||
{ 800, 480 },
|
||||
{ 800, 500 }, // 16:10
|
||||
{ 800, 600 },
|
||||
{ 848, 480 }, // 16:9
|
||||
{ 960, 600 }, // 16:10
|
||||
{ 960, 720 },
|
||||
{ 1024, 576 }, // 16:9
|
||||
{ 1024, 600 }, // 17:10
|
||||
{ 1024, 640 }, // 16:10
|
||||
{ 1024, 768 },
|
||||
{ 1088, 612 }, // 16:9
|
||||
{ 1152, 648 }, // 16:9
|
||||
{ 1152, 720 }, // 16:10
|
||||
{ 1152, 864 },
|
||||
{ 1280, 720 }, // 16:9
|
||||
{ 1280, 854 },
|
||||
{ 1280, 800 }, // 16:10
|
||||
{ 1280, 960 },
|
||||
{ 1280, 1024 }, // 5:4
|
||||
{ 1360, 768 }, // 16:9
|
||||
{ 1366, 768 },
|
||||
{ 1400, 787 }, // 16:9
|
||||
{ 1400, 875 }, // 16:10
|
||||
{ 1400, 1050 },
|
||||
{ 1440, 900 },
|
||||
{ 1440, 960 },
|
||||
{ 1440, 1080 },
|
||||
{ 1600, 900 }, // 16:9
|
||||
{ 1600, 1000 }, // 16:10
|
||||
{ 1600, 1200 },
|
||||
{ 1920, 1080 },
|
||||
{ 1920, 1200 },
|
||||
{ 2048, 1536 },
|
||||
{ 2560, 1440 },
|
||||
{ 2560, 1600 },
|
||||
{ 2560, 2048 },
|
||||
{ 2880, 1800 },
|
||||
{ 3200, 1800 },
|
||||
{ 3840, 2160 },
|
||||
{ 3840, 2400 },
|
||||
{ 4096, 2160 },
|
||||
{ 5120, 2880 }
|
||||
};
|
||||
|
||||
// CODE --------------------------------------------------------------------
|
||||
|
||||
SDLGLVideo::SDLGLVideo (int parm)
|
||||
|
@ -202,10 +137,10 @@ bool SDLGLVideo::NextMode (int *width, int *height, bool *letterbox)
|
|||
if (IteratorBits != 8)
|
||||
return false;
|
||||
|
||||
if ((unsigned)IteratorMode < sizeof(WinModes)/sizeof(WinModes[0]))
|
||||
if ((unsigned)IteratorMode < sizeof(VideoModes)/sizeof(VideoModes[0]))
|
||||
{
|
||||
*width = WinModes[IteratorMode].Width;
|
||||
*height = WinModes[IteratorMode].Height;
|
||||
*width = VideoModes[IteratorMode].width;
|
||||
*height = VideoModes[IteratorMode].height;
|
||||
++IteratorMode;
|
||||
return true;
|
||||
}
|
||||
|
|
105
src/posix/videomodes.h
Normal file
105
src/posix/videomodes.h
Normal file
|
@ -0,0 +1,105 @@
|
|||
/*
|
||||
** videomodes.h
|
||||
**
|
||||
**---------------------------------------------------------------------------
|
||||
** Copyright 2018 Alexey Lysiuk
|
||||
** All rights reserved.
|
||||
**
|
||||
** Redistribution and use in source and binary forms, with or without
|
||||
** modification, are permitted provided that the following conditions
|
||||
** are met:
|
||||
**
|
||||
** 1. Redistributions of source code must retain the above copyright
|
||||
** notice, this list of conditions and the following disclaimer.
|
||||
** 2. Redistributions in binary form must reproduce the above copyright
|
||||
** notice, this list of conditions and the following disclaimer in the
|
||||
** documentation and/or other materials provided with the distribution.
|
||||
** 3. The name of the author may not be used to endorse or promote products
|
||||
** derived from this software without specific prior written permission.
|
||||
**
|
||||
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
**---------------------------------------------------------------------------
|
||||
**
|
||||
*/
|
||||
|
||||
static const struct
|
||||
{
|
||||
uint16_t width;
|
||||
uint16_t height;
|
||||
}
|
||||
VideoModes[] =
|
||||
{
|
||||
{ 320, 200 },
|
||||
{ 320, 240 },
|
||||
{ 400, 225 }, // 16:9
|
||||
{ 400, 300 },
|
||||
{ 480, 270 }, // 16:9
|
||||
{ 480, 360 },
|
||||
{ 512, 288 }, // 16:9
|
||||
{ 512, 384 },
|
||||
{ 640, 360 }, // 16:9
|
||||
{ 640, 400 },
|
||||
{ 640, 480 },
|
||||
{ 720, 480 }, // 16:10
|
||||
{ 720, 540 },
|
||||
{ 800, 450 }, // 16:9
|
||||
{ 800, 480 },
|
||||
{ 800, 500 }, // 16:10
|
||||
{ 800, 600 },
|
||||
{ 848, 480 }, // 16:9
|
||||
{ 960, 600 }, // 16:10
|
||||
{ 960, 720 },
|
||||
{ 1024, 576 }, // 16:9
|
||||
{ 1024, 600 }, // 17:10
|
||||
{ 1024, 640 }, // 16:10
|
||||
{ 1024, 768 },
|
||||
{ 1088, 612 }, // 16:9
|
||||
{ 1152, 648 }, // 16:9
|
||||
{ 1152, 720 }, // 16:10
|
||||
{ 1152, 864 },
|
||||
{ 1280, 540 }, // 21:9
|
||||
{ 1280, 720 }, // 16:9
|
||||
{ 1280, 854 },
|
||||
{ 1280, 800 }, // 16:10
|
||||
{ 1280, 960 },
|
||||
{ 1280, 1024 }, // 5:4
|
||||
{ 1360, 768 }, // 16:9
|
||||
{ 1366, 768 },
|
||||
{ 1400, 787 }, // 16:9
|
||||
{ 1400, 875 }, // 16:10
|
||||
{ 1400, 1050 },
|
||||
{ 1440, 900 },
|
||||
{ 1440, 960 },
|
||||
{ 1440, 1080 },
|
||||
{ 1600, 900 }, // 16:9
|
||||
{ 1600, 1000 }, // 16:10
|
||||
{ 1600, 1200 },
|
||||
{ 1680, 1050 }, // 16:10
|
||||
{ 1920, 1080 },
|
||||
{ 1920, 1200 },
|
||||
{ 2048, 1152 }, // 16:9, iMac Retina 4K 21.5", HiDPI off
|
||||
{ 2048, 1536 },
|
||||
{ 2304, 1440 }, // 16:10, MacBook Retina 12"
|
||||
{ 2560, 1080 }, // 21:9
|
||||
{ 2560, 1440 },
|
||||
{ 2560, 1600 },
|
||||
{ 2560, 2048 },
|
||||
{ 2880, 1800 }, // 16:10, MacBook Pro Retina 15"
|
||||
{ 3200, 1800 },
|
||||
{ 3440, 1440 }, // 21:9
|
||||
{ 3840, 2160 },
|
||||
{ 3840, 2400 },
|
||||
{ 4096, 2160 },
|
||||
{ 4096, 2304 }, // 16:9, iMac Retina 4K 21.5"
|
||||
{ 5120, 2160 }, // 21:9
|
||||
{ 5120, 2880 } // 16:9, iMac Retina 5K 27"
|
||||
};
|
|
@ -817,14 +817,17 @@ static void CalcPosVel(int type, const AActor *actor, const sector_t *sector,
|
|||
//
|
||||
//==========================================================================
|
||||
|
||||
inline bool Validate(const float value)
|
||||
inline bool Validate(const float value, const float limit)
|
||||
{
|
||||
return value >= -32768.f && value <= 32768.f;
|
||||
return value >= -limit && value <= limit;
|
||||
}
|
||||
|
||||
static bool Validate(const FVector3 &value, const char *const name, const AActor *const actor)
|
||||
static bool Validate(const FVector3 &value, const float limit, const char *const name, const AActor *const actor)
|
||||
{
|
||||
const bool valid = Validate(value.X) && Validate(value.Y) && Validate(value.Z);
|
||||
const bool valid =
|
||||
Validate(value.X, limit)
|
||||
&& Validate(value.Y, limit)
|
||||
&& Validate(value.Z, limit);
|
||||
|
||||
if (!valid)
|
||||
{
|
||||
|
@ -845,8 +848,13 @@ static bool Validate(const FVector3 &value, const char *const name, const AActor
|
|||
|
||||
static bool ValidatePosVel(const AActor *actor, const FVector3 &pos, const FVector3 &vel)
|
||||
{
|
||||
const bool valid = Validate(pos, "position", actor);
|
||||
return Validate(vel, "velocity", actor) && valid;
|
||||
// The actual limit for map coordinates
|
||||
static const float POSITION_LIMIT = 32768.f;
|
||||
const bool valid = Validate(pos, POSITION_LIMIT, "position", actor);
|
||||
|
||||
// The maximum velocity is enough to travel through entire map in one tic
|
||||
static const float VELOCITY_LIMIT = 2 * POSITION_LIMIT * TICRATE;
|
||||
return Validate(vel, VELOCITY_LIMIT, "velocity", actor) && valid;
|
||||
}
|
||||
|
||||
static bool ValidatePosVel(const FSoundChan *const chan, const FVector3 &pos, const FVector3 &vel)
|
||||
|
|
|
@ -54,6 +54,20 @@ typedef TArray<void*> FDynArray_Ptr;
|
|||
typedef TArray<DObject*> FDynArray_Obj;
|
||||
typedef TArray<FString> FDynArray_String;
|
||||
|
||||
// The following macros are used to zero initialize items implicitly added to a dynamic array
|
||||
// Some function like Insert() and Resize() can append such items during their operation
|
||||
// It's more natural for a scripting language to have them initialized
|
||||
// This is a must for DObject pointers because of garbage collection
|
||||
|
||||
#define PARAM_DYNARRAY_SIZE_PROLOGUE(type) \
|
||||
PARAM_SELF_STRUCT_PROLOGUE(type); \
|
||||
const unsigned oldSize = self->Size();
|
||||
|
||||
#define DYNARRAY_FILL_ITEMS_SKIP(skip) \
|
||||
const int fillCount = int(self->Size() - oldSize) - skip; \
|
||||
if (fillCount > 0) memset(&(*self)[oldSize], 0, sizeof(*self)[0] * fillCount);
|
||||
|
||||
|
||||
//-----------------------------------------------------
|
||||
//
|
||||
// Int8 array
|
||||
|
@ -107,10 +121,11 @@ DEFINE_ACTION_FUNCTION(FDynArray_I8, Delete)
|
|||
|
||||
DEFINE_ACTION_FUNCTION(FDynArray_I8, Insert)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_I8);
|
||||
PARAM_DYNARRAY_SIZE_PROLOGUE(FDynArray_I8);
|
||||
PARAM_INT(index);
|
||||
PARAM_INT(val);
|
||||
self->Insert(index, val);
|
||||
DYNARRAY_FILL_ITEMS_SKIP(1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -131,9 +146,10 @@ DEFINE_ACTION_FUNCTION(FDynArray_I8, Grow)
|
|||
|
||||
DEFINE_ACTION_FUNCTION(FDynArray_I8, Resize)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_I8);
|
||||
PARAM_DYNARRAY_SIZE_PROLOGUE(FDynArray_I8);
|
||||
PARAM_INT(count);
|
||||
self->Resize(count);
|
||||
DYNARRAY_FILL_ITEMS_SKIP(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -210,10 +226,11 @@ DEFINE_ACTION_FUNCTION(FDynArray_I16, Delete)
|
|||
|
||||
DEFINE_ACTION_FUNCTION(FDynArray_I16, Insert)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_I16);
|
||||
PARAM_DYNARRAY_SIZE_PROLOGUE(FDynArray_I16);
|
||||
PARAM_INT(index);
|
||||
PARAM_INT(val);
|
||||
self->Insert(index, val);
|
||||
DYNARRAY_FILL_ITEMS_SKIP(1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -234,9 +251,10 @@ DEFINE_ACTION_FUNCTION(FDynArray_I16, Grow)
|
|||
|
||||
DEFINE_ACTION_FUNCTION(FDynArray_I16, Resize)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_I16);
|
||||
PARAM_DYNARRAY_SIZE_PROLOGUE(FDynArray_I16);
|
||||
PARAM_INT(count);
|
||||
self->Resize(count);
|
||||
DYNARRAY_FILL_ITEMS_SKIP(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -313,10 +331,11 @@ DEFINE_ACTION_FUNCTION(FDynArray_I32, Delete)
|
|||
|
||||
DEFINE_ACTION_FUNCTION(FDynArray_I32, Insert)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_I32);
|
||||
PARAM_DYNARRAY_SIZE_PROLOGUE(FDynArray_I32);
|
||||
PARAM_INT(index);
|
||||
PARAM_INT(val);
|
||||
self->Insert(index, val);
|
||||
DYNARRAY_FILL_ITEMS_SKIP(1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -337,9 +356,10 @@ DEFINE_ACTION_FUNCTION(FDynArray_I32, Grow)
|
|||
|
||||
DEFINE_ACTION_FUNCTION(FDynArray_I32, Resize)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_I32);
|
||||
PARAM_DYNARRAY_SIZE_PROLOGUE(FDynArray_I32);
|
||||
PARAM_INT(count);
|
||||
self->Resize(count);
|
||||
DYNARRAY_FILL_ITEMS_SKIP(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -416,10 +436,11 @@ DEFINE_ACTION_FUNCTION(FDynArray_F32, Delete)
|
|||
|
||||
DEFINE_ACTION_FUNCTION(FDynArray_F32, Insert)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_F32);
|
||||
PARAM_DYNARRAY_SIZE_PROLOGUE(FDynArray_F32);
|
||||
PARAM_INT(index);
|
||||
PARAM_FLOAT(val);
|
||||
self->Insert(index, (float)val);
|
||||
DYNARRAY_FILL_ITEMS_SKIP(1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -440,9 +461,10 @@ DEFINE_ACTION_FUNCTION(FDynArray_F32, Grow)
|
|||
|
||||
DEFINE_ACTION_FUNCTION(FDynArray_F32, Resize)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_F32);
|
||||
PARAM_DYNARRAY_SIZE_PROLOGUE(FDynArray_F32);
|
||||
PARAM_INT(count);
|
||||
self->Resize(count);
|
||||
DYNARRAY_FILL_ITEMS_SKIP(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -519,10 +541,11 @@ DEFINE_ACTION_FUNCTION(FDynArray_F64, Delete)
|
|||
|
||||
DEFINE_ACTION_FUNCTION(FDynArray_F64, Insert)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_F64);
|
||||
PARAM_DYNARRAY_SIZE_PROLOGUE(FDynArray_F64);
|
||||
PARAM_INT(index);
|
||||
PARAM_FLOAT(val);
|
||||
self->Insert(index, val);
|
||||
DYNARRAY_FILL_ITEMS_SKIP(1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -543,9 +566,10 @@ DEFINE_ACTION_FUNCTION(FDynArray_F64, Grow)
|
|||
|
||||
DEFINE_ACTION_FUNCTION(FDynArray_F64, Resize)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_F64);
|
||||
PARAM_DYNARRAY_SIZE_PROLOGUE(FDynArray_F64);
|
||||
PARAM_INT(count);
|
||||
self->Resize(count);
|
||||
DYNARRAY_FILL_ITEMS_SKIP(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -622,10 +646,11 @@ DEFINE_ACTION_FUNCTION(FDynArray_Ptr, Delete)
|
|||
|
||||
DEFINE_ACTION_FUNCTION(FDynArray_Ptr, Insert)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_Ptr);
|
||||
PARAM_DYNARRAY_SIZE_PROLOGUE(FDynArray_Ptr);
|
||||
PARAM_INT(index);
|
||||
PARAM_POINTER(val, void);
|
||||
self->Insert(index, val);
|
||||
DYNARRAY_FILL_ITEMS_SKIP(1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -646,9 +671,10 @@ DEFINE_ACTION_FUNCTION(FDynArray_Ptr, Grow)
|
|||
|
||||
DEFINE_ACTION_FUNCTION(FDynArray_Ptr, Resize)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_Ptr);
|
||||
PARAM_DYNARRAY_SIZE_PROLOGUE(FDynArray_Ptr);
|
||||
PARAM_INT(count);
|
||||
self->Resize(count);
|
||||
DYNARRAY_FILL_ITEMS_SKIP(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -727,11 +753,12 @@ DEFINE_ACTION_FUNCTION(FDynArray_Obj, Delete)
|
|||
|
||||
DEFINE_ACTION_FUNCTION(FDynArray_Obj, Insert)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_Obj);
|
||||
PARAM_DYNARRAY_SIZE_PROLOGUE(FDynArray_Obj);
|
||||
PARAM_INT(index);
|
||||
PARAM_OBJECT(val, DObject);
|
||||
GC::WriteBarrier(val);
|
||||
self->Insert(index, val);
|
||||
DYNARRAY_FILL_ITEMS_SKIP(1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -752,9 +779,10 @@ DEFINE_ACTION_FUNCTION(FDynArray_Obj, Grow)
|
|||
|
||||
DEFINE_ACTION_FUNCTION(FDynArray_Obj, Resize)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(FDynArray_Obj);
|
||||
PARAM_DYNARRAY_SIZE_PROLOGUE(FDynArray_Obj);
|
||||
PARAM_INT(count);
|
||||
self->Resize(count);
|
||||
DYNARRAY_FILL_ITEMS_SKIP(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -1204,8 +1204,8 @@ DEFINE_ACTION_FUNCTION(FStringStruct, AppendFormat)
|
|||
DEFINE_ACTION_FUNCTION(FStringStruct, Mid)
|
||||
{
|
||||
PARAM_SELF_STRUCT_PROLOGUE(FString);
|
||||
PARAM_UINT(pos);
|
||||
PARAM_UINT(len);
|
||||
PARAM_UINT_DEF(pos);
|
||||
PARAM_UINT_DEF(len);
|
||||
FString s = self->Mid(pos, len);
|
||||
ACTION_RETURN_STRING(s);
|
||||
}
|
||||
|
|
|
@ -2316,6 +2316,11 @@ void ZCCCompiler::CompileFunction(ZCC_StructWork *c, ZCC_FuncDeclarator *f, bool
|
|||
// structs and classes only get passed by pointer.
|
||||
type = NewPointer(type);
|
||||
}
|
||||
else if (type->isDynArray())
|
||||
{
|
||||
Error(f, "The return type of a function cannot be a dynamic array");
|
||||
break;
|
||||
}
|
||||
// TBD: disallow certain types? For now, let everything pass that isn't an array.
|
||||
rets.Push(type);
|
||||
t = static_cast<decltype(t)>(t->SiblingNext);
|
||||
|
|
|
@ -4,7 +4,7 @@
|
|||
* FROM A NUMBER OF SOURCES, MOSTLY PC GAMES.
|
||||
* PREPROCESSED, CONVERTED, AND POSTPROCESSED OFF-SCREEN.
|
||||
*/
|
||||
const adldata adl[4425] =
|
||||
const adldata adl[4423] =
|
||||
{ // ,---------+-------- Wave select settings
|
||||
// | ,-------ч-+------ Sustain/release rates
|
||||
// | | ,-----ч-ч-+---- Attack/decay rates
|
||||
|
@ -4116,7 +4116,7 @@ const adldata adl[4425] =
|
|||
{ 0x332F985,0x0A5D684, 0x05,0x40, 0xE, +0 },
|
||||
{ 0x0FFF00B,0x2FF220C, 0x00,0x00, 0xE, +0 },
|
||||
{ 0x223A133,0x4F4F131, 0xD6,0x09, 0x6, +0 },
|
||||
{ 0x223B132,0x0F4F131, 0xD3,0x0A, 0x6, +0 },
|
||||
{ 0x023B131,0x0F4F131, 0xD3,0x0A, 0x6, +0 },
|
||||
{ 0x433F133,0x0F4F131, 0xD6,0x09, 0x8, +0 },
|
||||
{ 0x2F3F132,0x4F6F131, 0xD3,0x0A, 0x6, +0 },
|
||||
{ 0x2A4A112,0x4B5F211, 0xD2,0x05, 0x4, +0 },
|
||||
|
@ -4135,10 +4135,10 @@ const adldata adl[4425] =
|
|||
{ 0x587F617,0x0E4F231, 0x54,0x08, 0x9, +0 },
|
||||
{ 0x0A5F33F,0x0F2C312, 0xA1,0x06, 0xC, -12 },
|
||||
{ 0x0A5F43F,0x0F2F392, 0xD5,0x07, 0x0, -12 },
|
||||
{ 0x461A417,0x0017C11, 0xAA,0x08, 0x7, +0 },
|
||||
{ 0x061A416,0x0018911, 0xA7,0x07, 0x7, +0 },
|
||||
{ 0x0F6F2B2,0x0F6F281, 0xE5,0x00, 0xF, +0 },
|
||||
{ 0x0F6F2A4,0x007F08F, 0x40,0x00, 0x1, +0 },
|
||||
{ 0x462A417,0x0027A11, 0x9C,0x08, 0x9, +0 },
|
||||
{ 0x062A416,0x0028811, 0x99,0x07, 0x9, +0 },
|
||||
{ 0x0F6F2B2,0x0F6F281, 0xE8,0x05, 0xF, +0 },
|
||||
{ 0x0F6F2A4,0x007F08F, 0x45,0x05, 0x1, +0 },
|
||||
{ 0x0F6F618,0x0F7E500, 0x63,0x80, 0x6, +12 },
|
||||
{ 0x5A6F40E,0x007D804, 0x5B,0x80, 0x0, +0 },
|
||||
{ 0x2F6F71A,0x0F5F413, 0x1F,0x03, 0x4, -19 },
|
||||
|
@ -4162,8 +4162,8 @@ const adldata adl[4425] =
|
|||
{ 0x105FF2C,0x01A6222, 0x9D,0x12, 0x8, +0 },
|
||||
{ 0x107F021,0x2055232, 0x92,0x07, 0x8, +0 },
|
||||
{ 0x107F021,0x2055232, 0x92,0x07, 0x0, +0 },
|
||||
{ 0x274A613,0x4B8F401, 0xDD,0x05, 0x6, +0 },
|
||||
{ 0x2249134,0x2B8D301, 0x5E,0x05, 0xA, -12 },
|
||||
{ 0x574A613,0x4B8F401, 0x9D,0x0D, 0x6, +0 },
|
||||
{ 0x2249134,0x2B8D301, 0x61,0x05, 0xA, -12 },
|
||||
{ 0x5E5F133,0x1E4F211, 0x99,0x07, 0x6, +0 },
|
||||
{ 0x1E5F133,0x5E4F211, 0x9E,0x0B, 0x0, +0 },
|
||||
{ 0x21FF021,0x088F211, 0xA5,0x80, 0xA, +12 },
|
||||
|
@ -4178,8 +4178,8 @@ const adldata adl[4425] =
|
|||
{ 0x0F78140,0x3F7F040, 0x40,0x05, 0xC, +14 },
|
||||
{ 0x6F78AE8,0x649B1F4, 0x03,0x0A, 0xA, +0 },
|
||||
{ 0x6F78AE8,0x649B1F4, 0x43,0x4B, 0xA, +0 },
|
||||
{ 0x0209221,0x0E6C131, 0x97,0x05, 0x0, +0 },
|
||||
{ 0x0608521,0x0E6A131, 0xD4,0x05, 0x4, +0 },
|
||||
{ 0x0609533,0x4E5C131, 0x63,0x05, 0x0, +0 },
|
||||
{ 0x0608521,0x0E4A131, 0xD4,0x05, 0x4, +0 },
|
||||
{ 0x0F9F030,0x0F8F131, 0x9D,0x05, 0xA, +12 },
|
||||
{ 0x7F0F017,0x7F9B700, 0x00,0x0F, 0xA, +12 },
|
||||
{ 0x026AA21,0x0D7F132, 0xCF,0x84, 0xA, +0 },
|
||||
|
@ -4191,7 +4191,8 @@ const adldata adl[4425] =
|
|||
{ 0x2E69515,0x1B6B211, 0x17,0x08, 0x0, +0 },
|
||||
{ 0x077FA21,0x06AC332, 0x07,0x0D, 0x0, +0 },
|
||||
{ 0x0F5F430,0x0F6F330, 0x0E,0x00, 0xA, +12 },
|
||||
{ 0x1468331,0x017D232, 0x15,0x00, 0xA, +0 },
|
||||
{ 0x139A331,0x0F8F133, 0x93,0x08, 0xC, +0 },
|
||||
{ 0x139A331,0x0F8F133, 0x93,0x08, 0xA, +0 },
|
||||
{ 0x2257020,0x4266161, 0x95,0x05, 0xA, +0 },
|
||||
{ 0x1257021,0x0266141, 0x99,0x07, 0x8, +0 },
|
||||
{ 0x2426070,0x2154130, 0x4F,0x00, 0xA, +0 },
|
||||
|
@ -4200,12 +4201,12 @@ const adldata adl[4425] =
|
|||
{ 0x521F571,0x4166022, 0x90,0x09, 0x6, +0 },
|
||||
{ 0x52151F0,0x4156021, 0x97,0x0D, 0x4, +12 },
|
||||
{ 0x223F8F2,0x4055421, 0x99,0x8A, 0xC, +0 },
|
||||
{ 0x0A05211,0x0E4C411, 0x9F,0x03, 0xA, +0 },
|
||||
{ 0x1C79612,0x0E45411, 0xD9,0x03, 0x4, +0 },
|
||||
{ 0x4A35211,0x0E4C411, 0x9C,0x08, 0x6, +0 },
|
||||
{ 0x2C79613,0x4E45411, 0xD7,0x08, 0xA, +0 },
|
||||
{ 0x023E133,0x0F2F131, 0xA2,0x09, 0xE, +0 },
|
||||
{ 0x023F132,0x0F2F131, 0x24,0x0A, 0xE, +0 },
|
||||
{ 0x4C3C413,0x0B4D214, 0x9B,0x48, 0xA, -24 },
|
||||
{ 0x5BAF900,0x0B4F211, 0x87,0x48, 0x6, +0 },
|
||||
{ 0x5C3C404,0x1B4B519, 0xA1,0x00, 0xC, -31 },
|
||||
{ 0x17A9913,0x0B4F213, 0x0F,0x00, 0x8, -19 },
|
||||
{ 0x223F832,0x4055421, 0x99,0x8A, 0xC, +0 },
|
||||
{ 0x433CB32,0x5057561, 0x9B,0x8A, 0xA, +0 },
|
||||
{ 0x1029033,0x4044561, 0x5B,0x85, 0x4, +0 },
|
||||
|
@ -4225,7 +4226,7 @@ const adldata adl[4425] =
|
|||
{ 0x0235271,0x0198161, 0x1E,0x08, 0xE, +0 },
|
||||
{ 0x0235361,0x0196161, 0x1D,0x03, 0xE, +0 },
|
||||
{ 0x0155331,0x0378261, 0x94,0x00, 0xA, +0 },
|
||||
{ 0x118537A,0x5177432, 0x21,0x00, 0x4, -12 },
|
||||
{ 0x118543A,0x5177472, 0x1E,0x00, 0x4, -12 },
|
||||
{ 0x0364121,0x02B7221, 0x21,0x08, 0xC, +0 },
|
||||
{ 0x026F021,0x0056121, 0x26,0x03, 0xC, +0 },
|
||||
{ 0x0578321,0x117C021, 0x19,0x03, 0xC, +0 },
|
||||
|
@ -4233,21 +4234,22 @@ const adldata adl[4425] =
|
|||
{ 0x036F121,0x337F121, 0x92,0x08, 0xE, +0 },
|
||||
{ 0x0368121,0x037F121, 0x92,0x08, 0xE, +0 },
|
||||
{ 0x0A66121,0x0976121, 0x9B,0x08, 0xE, +0 },
|
||||
{ 0x0F37011,0x1F65052, 0x51,0x04, 0xA, +0 },
|
||||
{ 0x1067021,0x1165231, 0x8A,0x00, 0x6, +0 },
|
||||
{ 0x5237731,0x1F65012, 0x4B,0x00, 0xA, +0 },
|
||||
{ 0x0137732,0x0F65011, 0xC7,0x0A, 0xA, +0 },
|
||||
{ 0x1067021,0x1165231, 0x46,0x00, 0x6, +0 },
|
||||
{ 0x00B9820,0x10B5330, 0x8E,0x00, 0xA, +12 },
|
||||
{ 0x10B8020,0x11B6330, 0x87,0x00, 0x8, +12 },
|
||||
{ 0x0235031,0x0076C64, 0x58,0x08, 0xA, +0 },
|
||||
{ 0x055D531,0x0076C72, 0x17,0x0D, 0x6, +0 },
|
||||
{ 0x2077830,0x2076331, 0x94,0x00, 0xA, +0 },
|
||||
{ 0x1235031,0x0077C24, 0xC0,0x08, 0x2, +0 },
|
||||
{ 0x045D933,0x4076C35, 0xD0,0x26, 0x4, +0 },
|
||||
{ 0x2077830,0x2076331, 0x9F,0x00, 0xA, +0 },
|
||||
{ 0x0199031,0x01B6134, 0x95,0x80, 0xA, +0 },
|
||||
{ 0x0177532,0x0174531, 0x93,0x03, 0xC, +0 },
|
||||
{ 0x0277530,0x0174536, 0x14,0x9C, 0xE, +12 },
|
||||
{ 0x08D6EF1,0x02A3571, 0xC0,0x00, 0xE, +0 },
|
||||
{ 0x08860A1,0x01A6561, 0x5C,0x00, 0x8, +0 },
|
||||
{ 0x2176522,0x0277421, 0x5A,0x00, 0x6, +0 },
|
||||
{ 0x1274472,0x01745B1, 0x8D,0x05, 0x4, +0 },
|
||||
{ 0x2F0F051,0x09A7801, 0x03,0x12, 0xA, +0 },
|
||||
{ 0x1267532,0x0166531, 0x8D,0x05, 0x4, +0 },
|
||||
{ 0x2F0F011,0x0987801, 0x03,0x17, 0xA, +0 },
|
||||
{ 0x00457F2,0x0375761, 0xA8,0x00, 0xE, +0 },
|
||||
{ 0x2545C73,0x0776821, 0x00,0x0D, 0xE, +0 },
|
||||
{ 0x5543737,0x25D67A1, 0x28,0x00, 0x8, +0 },
|
||||
|
@ -4260,23 +4262,23 @@ const adldata adl[4425] =
|
|||
{ 0x3AB8120,0x308F130, 0x9E,0x06, 0x0, +0 },
|
||||
{ 0x13357F1,0x00767E1, 0x21,0x00, 0xA, +0 },
|
||||
{ 0x43357F2,0x00767E1, 0x28,0x00, 0x0, +0 },
|
||||
{ 0x2444830,0x43D67A1, 0x22,0x00, 0x8, +0 },
|
||||
{ 0x534B821,0x13D87A1, 0x1F,0x00, 0xA, +0 },
|
||||
{ 0x2444830,0x21D67A1, 0x22,0x00, 0x8, +0 },
|
||||
{ 0x534B821,0x02D87A1, 0x1F,0x00, 0xA, +0 },
|
||||
{ 0x32B7420,0x12BF134, 0x46,0x00, 0x8, +0 },
|
||||
{ 0x5029072,0x0069061, 0x96,0x0C, 0x8, +0 },
|
||||
{ 0x1019031,0x0069061, 0x1A,0x0C, 0x6, +0 },
|
||||
{ 0x245C224,0x2550133, 0x83,0x80, 0x9, -36 },
|
||||
{ 0x2459224,0x2556133, 0x83,0x80, 0x9, -36 },
|
||||
{ 0x132ED10,0x3E7D010, 0x87,0x08, 0x6, +12 },
|
||||
{ 0x132ED30,0x3E7D010, 0x87,0x0D, 0x6, +12 },
|
||||
{ 0x2946374,0x005A0A1, 0xA5,0x05, 0x2, +0 },
|
||||
{ 0x2055F02,0x004FFE1, 0xA8,0x05, 0x0, +0 },
|
||||
{ 0x0031131,0x0054361, 0xD4,0x00, 0x4, +0 },
|
||||
{ 0x20311B0,0x00543E1, 0xD9,0x00, 0x4, +0 },
|
||||
{ 0x245C224,0x2550133, 0x81,0x80, 0xB, -36 },
|
||||
{ 0x2459224,0x2556133, 0x81,0x80, 0xB, -36 },
|
||||
{ 0x132ED10,0x3E7D010, 0x87,0x0D, 0x6, +12 },
|
||||
{ 0x132ED30,0x3E7D010, 0x87,0x12, 0x6, +12 },
|
||||
{ 0x033513A,0x013C121, 0xA4,0x06, 0x2, +0 },
|
||||
{ 0x273F325,0x0228231, 0x20,0x06, 0x4, +0 },
|
||||
{ 0x0031131,0x0054361, 0xD4,0x08, 0x4, +0 },
|
||||
{ 0x20311B0,0x00543E1, 0xD9,0x08, 0x4, +0 },
|
||||
{ 0x245A121,0x126A121, 0x98,0x05, 0xC, +0 },
|
||||
{ 0x255A421,0x126A121, 0x98,0x05, 0xC, +0 },
|
||||
{ 0x20470E0,0x1148161, 0x59,0x03, 0x2, +0 },
|
||||
{ 0x10460E1,0x2148161, 0x5F,0x83, 0x6, +0 },
|
||||
{ 0x50470E1,0x1148161, 0x59,0x03, 0x2, +0 },
|
||||
{ 0x10460E2,0x4148161, 0x5F,0x83, 0x6, +0 },
|
||||
{ 0x0336186,0x05452E1, 0xA7,0x00, 0x6, +0 },
|
||||
{ 0x13351A6,0x05452E1, 0xA7,0x00, 0x0, +0 },
|
||||
{ 0x2529084,0x1534341, 0x9D,0x80, 0xC, +0 },
|
||||
|
@ -4290,8 +4292,8 @@ const adldata adl[4425] =
|
|||
{ 0x2322122,0x0133221, 0x8C,0x92, 0x6, +0 },
|
||||
{ 0x4033121,0x0132122, 0x93,0x48, 0x4, +7 },
|
||||
{ 0x074F624,0x0249303, 0xC0,0x0D, 0x0, +0 },
|
||||
{ 0x3D2C092,0x1D2D131, 0x8E,0x03, 0x0, +0 },
|
||||
{ 0x0D2D091,0x1D23132, 0x8E,0x03, 0x0, +0 },
|
||||
{ 0x3D2C092,0x1D2D131, 0x8E,0x09, 0x0, +0 },
|
||||
{ 0x0D2D091,0x1D23132, 0x8E,0x09, 0x0, +0 },
|
||||
{ 0x5F29054,0x0F2C241, 0x99,0x06, 0xE, +0 },
|
||||
{ 0x1F19011,0x0F2C241, 0x1A,0x06, 0x6, +0 },
|
||||
{ 0x05233E1,0x0131371, 0x1A,0x88, 0x7, +0 },
|
||||
|
@ -4306,7 +4308,7 @@ const adldata adl[4425] =
|
|||
{ 0x3F0F014,0x6F7F611, 0x40,0x43, 0xA, +0 },
|
||||
{ 0x033F201,0x373F402, 0xD1,0x8A, 0x0, +0 },
|
||||
{ 0x6A7F907,0x229A904, 0x1A,0x00, 0xA, -12 },
|
||||
{ 0x332F320,0x6E49423, 0x0E,0x08, 0x8, +0 },
|
||||
{ 0x5E2F321,0x6E4F523, 0x1B,0x08, 0x8, +0 },
|
||||
{ 0x455F71C,0x0D68501, 0xA3,0x08, 0x6, +0 },
|
||||
{ 0x055F718,0x0D6E501, 0x23,0x08, 0x0, +0 },
|
||||
{ 0x1397931,0x2099B22, 0x80,0x00, 0x6, +0 },
|
||||
|
@ -4326,7 +4328,7 @@ const adldata adl[4425] =
|
|||
{ 0x250F610,0x0E7F510, 0x00,0xC8, 0x6, +0 },
|
||||
{ 0x2114109,0x51D2101, 0x05,0x80, 0xA, +0 },
|
||||
{ 0x2114108,0x31D2101, 0x05,0x80, 0xA, +12 },
|
||||
{ 0x4543311,0x357451A, 0x19,0x03, 0xE, -14 },
|
||||
{ 0x0534313,0x7574A1F, 0x20,0x03, 0xE, -14 },
|
||||
{ 0x00437D2,0x0343471, 0xA1,0x07, 0xC, +0 },
|
||||
{ 0x0F0F00C,0x0F66700, 0x00,0xCD, 0xE, +0 },
|
||||
{ 0x200C327,0x6021300, 0x80,0x12, 0xE, -23 },
|
||||
|
@ -4355,29 +4357,22 @@ const adldata adl[4425] =
|
|||
{ 0x2F7F602,0x0F8F802, 0x00,0x88, 0xE, +12 },
|
||||
{ 0x05476C1,0x30892C5, 0x80,0x08, 0x0, +0 },
|
||||
{ 0x05477C1,0x30892C5, 0x00,0x08, 0xA, -2 },
|
||||
{ 0x007C604,0x007C604, 0x08,0x08, 0x1, +0 },
|
||||
{ 0x201F302,0x057AB09, 0x03,0x07, 0xC, +12 },
|
||||
{ 0x005C604,0x005C604, 0x08,0x00, 0x1, +0 },
|
||||
{ 0x509F902,0x057AB07, 0x03,0x07, 0xC, +12 },
|
||||
{ 0x254F307,0x307F905, 0x04,0x08, 0x6, -5 },
|
||||
{ 0x254F307,0x207F905, 0x04,0x08, 0x8, +0 },
|
||||
{ 0x006C604,0x007C604, 0x08,0x08, 0x1, +0 },
|
||||
{ 0x201F312,0x057AB09, 0x03,0x07, 0xC, +12 },
|
||||
{ 0x509F912,0x057AB07, 0x03,0x07, 0xC, +12 },
|
||||
{ 0x254D307,0x3288905, 0x04,0x03, 0xA, -5 },
|
||||
{ 0x0015500,0x007C716, 0x0C,0x00, 0x0, +0 },
|
||||
{ 0x201F312,0x057AB09, 0x00,0x07, 0xC, +12 },
|
||||
{ 0x0015500,0x007C719, 0x0C,0x00, 0x0, +0 },
|
||||
{ 0x001F312,0x047BB05, 0x03,0x07, 0xC, +12 },
|
||||
{ 0x0015500,0x007C71B, 0x0C,0x00, 0x0, +0 },
|
||||
{ 0x201F312,0x047BB09, 0x03,0x07, 0xC, +12 },
|
||||
{ 0x0015500,0x007C71F, 0x0C,0x00, 0x0, +0 },
|
||||
{ 0x210F509,0x305FE03, 0x8A,0x85, 0xE, +12 },
|
||||
{ 0x200F508,0x305FE03, 0xC7,0x85, 0xC, +12 },
|
||||
{ 0x2E1F119,0x3F3F11B, 0x04,0x0D, 0x8, +0 },
|
||||
{ 0x509F902,0x057AB07, 0x03,0x07, 0x0, +12 },
|
||||
{ 0x210F509,0x605FE05, 0x8A,0x8A, 0xE, +12 },
|
||||
{ 0x400F509,0x605FE05, 0x07,0x8A, 0xA, +12 },
|
||||
{ 0x2E1F11E,0x3F3F318, 0x04,0x00, 0x8, +0 },
|
||||
{ 0x2777603,0x3679601, 0x87,0x08, 0x6, +12 },
|
||||
{ 0x277C643,0x3679601, 0x87,0x08, 0xE, +12 },
|
||||
{ 0x366F905,0x099F701, 0x00,0x00, 0xC, +12 },
|
||||
{ 0x431A000,0x085B41A, 0x81,0x05, 0xA, +12 },
|
||||
{ 0x459F640,0x185B418, 0x00,0x20, 0xB, +12 },
|
||||
{ 0x212FD04,0x305FD03, 0x01,0x00, 0x8, +12 },
|
||||
{ 0x212FD08,0x305FD03, 0x01,0x03, 0x8, +12 },
|
||||
{ 0x2A8F9E3,0x0779643, 0x1E,0x08, 0x2, +6 },
|
||||
{ 0x0A5F7E8,0x0D89949, 0xDE,0x00, 0x0, +0 },
|
||||
{ 0x2A8F9E3,0x0779643, 0x1E,0x00, 0xE, +12 },
|
||||
|
@ -4394,8 +4389,11 @@ const adldata adl[4425] =
|
|||
{ 0x367FE05,0x678F701, 0x09,0x08, 0x8, +12 },
|
||||
{ 0x367FD10,0x078F901, 0x00,0x0D, 0x8, +11 },
|
||||
{ 0x098600F,0x3FC8590, 0x08,0xC0, 0xE, +12 },
|
||||
{ 0x009F020,0x37DA588, 0x07,0x00, 0xA, +12 },
|
||||
{ 0x00FC020,0x32DA5A8, 0x07,0x00, 0xA, +12 },
|
||||
{ 0x009F020,0x27DA788, 0x25,0x00, 0x0, +12 },
|
||||
{ 0x00FC020,0x22DA388, 0x25,0x00, 0xA, +12 },
|
||||
{ 0x0F00000,0x0F00000, 0x3F,0x3F, 0xC, +0 },
|
||||
{ 0x000F020,0x40A8A00, 0x0A,0x00, 0xE, +0 },
|
||||
{ 0x70F5F20,0x70F4F00, 0x00,0x00, 0x2, -12 },
|
||||
{ 0x0D1F815,0x078F512, 0x44,0x00, 0x8, +12 },
|
||||
{ 0x2D1F213,0x098F614, 0x9D,0x00, 0x0, +0 },
|
||||
{ 0x2D1F213,0x098F614, 0x9D,0x21, 0x0, -2 },
|
||||
|
@ -4442,7 +4440,7 @@ const adldata adl[4425] =
|
|||
{ 0x04CA700,0x04FC600, 0x00,0x2B, 0x0, -12 },
|
||||
{ 0x0B5F704,0x002010C, 0x00,0x00, 0x8, +21 },
|
||||
};
|
||||
const struct adlinsdata adlins[4547] =
|
||||
const struct adlinsdata adlins[4549] =
|
||||
{
|
||||
{ 0, 0, 0, 0, 1660, 1660,0.000000 },
|
||||
{ 1, 1, 0, 0, 1746, 1746,0.000000 },
|
||||
|
@ -8783,7 +8781,7 @@ const struct adlinsdata adlins[4547] =
|
|||
{3547,3547,109, 0, 1780, 1780,0.000000 },
|
||||
{4097,4097, 79, 0, 126, 126,0.000000 },
|
||||
{4098,4098, 0, 0, 3413, 3413,0.000000 },
|
||||
{4099,4100, 0, 1, 2040, 2040,0.031250 },
|
||||
{4099,4100, 0, 1, 1613, 1613,0.031250 },
|
||||
{4101,4102, 0, 1, 2146, 2146,0.031250 },
|
||||
{4103,4104, 0, 1, 1646, 1646,0.046875 },
|
||||
{4105,4106, 0, 1, 1900, 1900,0.156250 },
|
||||
|
@ -8793,7 +8791,7 @@ const struct adlinsdata adlins[4547] =
|
|||
{4113,4114, 0, 1, 1740, 1740,0.000000 },
|
||||
{4115,4116, 0, 1, 993, 993,0.000025 },
|
||||
{4117,4118, 0, 1, 886, 886,0.000000 },
|
||||
{4119,4120, 0, 1, 1900, 1900,0.046875 },
|
||||
{4119,4120, 0, 1, 1153, 1153,0.046875 },
|
||||
{4121,4122, 0, 1, 1420, 1420,0.000000 },
|
||||
{4123,4124, 0, 1, 193, 193,0.000000 },
|
||||
{4125,4126, 0, 1, 406, 406,0.000000 },
|
||||
|
@ -8807,7 +8805,7 @@ const struct adlinsdata adlins[4547] =
|
|||
{4140,4141, 0, 1, 40000, 46,0.140625 },
|
||||
{4142,4143, 0, 1, 40000, 6,0.000000 },
|
||||
{4144,4145, 0, 1, 40000, 153,0.109375 },
|
||||
{4146,4147, 0, 1, 600, 600,0.000000 },
|
||||
{4146,4147, 0, 1, 920, 920,0.000000 },
|
||||
{4148,4149, 0, 1, 653, 653,0.000025 },
|
||||
{4150,4151, 0, 1, 633, 633,0.000000 },
|
||||
{4152,4153, 0, 1, 893, 893,0.046875 },
|
||||
|
@ -8815,182 +8813,184 @@ const struct adlinsdata adlins[4547] =
|
|||
{4156,4157, 0, 1, 40000, 60,-1.906250 },
|
||||
{4158,4159, 0, 1, 40000, 60,-1.906250 },
|
||||
{4160,4161, 0, 1, 2033, 2033,0.234375 },
|
||||
{4162,4163, 0, 1, 1600, 1600,0.031250 },
|
||||
{4162,4163, 0, 1, 1900, 1900,0.031250 },
|
||||
{4164,4165, 0, 1, 1453, 1453,0.000000 },
|
||||
{4166,4167, 0, 1, 2186, 2186,0.000000 },
|
||||
{4168,4169, 0, 1, 1933, 1933,0.046875 },
|
||||
{4170,4171, 0, 1, 633, 633,0.000000 },
|
||||
{4172,4173, 0, 1, 486, 486,0.000000 },
|
||||
{4174,4174, 0, 0, 313, 313,0.000000 },
|
||||
{4175,4175, 0, 1, 40000, 33,0.156250 },
|
||||
{4176,4177, 0, 1, 2040, 13,0.000000 },
|
||||
{4178,4178, 0, 0, 40000, 66,0.000000 },
|
||||
{4179,4180, 0, 1, 40000, 60,0.000025 },
|
||||
{4181,4181, 0, 0, 40000, 133,0.000000 },
|
||||
{4182,4183, 0, 1, 40000, 173,0.078125 },
|
||||
{4184,4185, 0, 1, 320, 320,0.156250 },
|
||||
{4186,4187, 0, 1, 1813, 1813,0.031250 },
|
||||
{4188,4189, 0, 1, 1740, 1740,0.031250 },
|
||||
{4190,4191, 0, 1, 40000, 213,0.062500 },
|
||||
{4192,4193, 0, 1, 40000, 500,-0.062500 },
|
||||
{4194,4194, 0, 1, 40000, 326,0.109375 },
|
||||
{4195,4195, 0, 1, 40000, 406,0.109375 },
|
||||
{4196,4197, 0, 1, 40000, 280,0.140625 },
|
||||
{4198,4199, 0, 1, 40000, 53,0.140625 },
|
||||
{4200,4201, 0, 1, 40000, 286,0.156250 },
|
||||
{4202,4203, 0, 1, 206, 206,0.125000 },
|
||||
{4204,4205, 0, 1, 40000, 26,0.000000 },
|
||||
{4206,4207, 0, 1, 40000, 20,0.031250 },
|
||||
{4208,4208, 0, 0, 40000, 6,0.000000 },
|
||||
{4209,4209, 0, 0, 40000, 20,0.000000 },
|
||||
{4210,4211, 0, 1, 40000, 160,0.031250 },
|
||||
{4212,4213, 0, 1, 40000, 73,0.062500 },
|
||||
{4214,4215, 0, 1, 2526, 2526,0.093750 },
|
||||
{4216,4216, 0, 1, 5153, 5153,0.125000 },
|
||||
{4217,4217, 0, 0, 40000, 66,0.000000 },
|
||||
{4218,4218, 0, 0, 40000, 40,0.000000 },
|
||||
{4219,4219, 0, 0, 40000, 0,0.000000 },
|
||||
{4220,4220, 0, 0, 40000, 0,0.000000 },
|
||||
{4221,4222, 0, 1, 40000, 60,0.000000 },
|
||||
{4223,4223, 0, 0, 40000, 33,0.000000 },
|
||||
{4224,4224, 0, 0, 40000, 6,0.000000 },
|
||||
{4225,4226, 0, 1, 40000, 40,0.000000 },
|
||||
{4227,4227, 0, 0, 40000, 0,0.000000 },
|
||||
{4228,4228, 0, 0, 40000, 6,0.000000 },
|
||||
{4229,4229, 0, 0, 40000, 33,0.000000 },
|
||||
{4230,4231, 0, 1, 40000, 33,0.031250 },
|
||||
{4232,4233, 0, 1, 40000, 20,0.046875 },
|
||||
{4234,4235, 0, 1, 420, 420,0.031250 },
|
||||
{4236,4236, 0, 0, 40000, 106,0.000000 },
|
||||
{4237,4237, 0, 0, 40000, 6,0.000000 },
|
||||
{4238,4239, 0, 1, 40000, 6,0.125000 },
|
||||
{4240,4241, 0, 1, 40000, 13,0.109375 },
|
||||
{4242,4243, 0, 1, 40000, 53,0.109375 },
|
||||
{4244,4245, 0, 1, 120, 0,-0.031250 },
|
||||
{4246,4246, 0, 0, 40000, 6,0.000000 },
|
||||
{4247,4248, 0, 1, 40000, 133,0.156250 },
|
||||
{4249,4250, 0, 1, 3886, 3886,0.125000 },
|
||||
{4251,4252, 0, 1, 40000, 26,0.031250 },
|
||||
{4253,4254, 0, 1, 40000, 320,0.078125 },
|
||||
{4255,4256, 0, 1, 846, 66,0.109375 },
|
||||
{4257,4258, 0, 1, 1293, 80,0.078125 },
|
||||
{4259,4260, 0, 1, 40000, 193,0.156250 },
|
||||
{4261,4262, 0, 1, 2040, 2040,0.109375 },
|
||||
{4263,4264, 0, 1, 1360, 1360,0.062500 },
|
||||
{4265,4266, 0, 1, 40000, 433,0.093750 },
|
||||
{4267,4268, 0, 1, 40000, 533,0.109375 },
|
||||
{4269,4270, 0, 1, 826, 826,0.093750 },
|
||||
{4271,4272, 0, 1, 40000, 926,0.125000 },
|
||||
{4273,4273, 0, 1, 886, 886,0.109375 },
|
||||
{4274,4275, 0, 1, 2186, 2186,-0.046875 },
|
||||
{4276,4277, 0, 1, 1486, 1486,0.125000 },
|
||||
{4278,4279, 0, 1, 40000, 393,-0.078125 },
|
||||
{4280,4281, 0, 1, 40000, 1166,0.140625 },
|
||||
{4282,4283, 0, 1, 360, 360,0.078125 },
|
||||
{4284,4285, 0, 1, 1693, 1693,0.031250 },
|
||||
{4286,4287, 0, 1, 760, 760,0.000000 },
|
||||
{4288,4289, 0, 1, 126, 126,0.031250 },
|
||||
{4290,4290, 0, 0, 633, 633,0.000000 },
|
||||
{4291,4292, 0, 1, 280, 280,0.000000 },
|
||||
{4293,4294, 0, 1, 40000, 26,0.062500 },
|
||||
{4295,4295, 0, 0, 40000, 66,0.000000 },
|
||||
{4296,4296, 0, 0, 40000, 53,0.000000 },
|
||||
{4297,4297, 0, 0, 1940, 1940,0.000000 },
|
||||
{4298,4298, 0, 0, 86, 86,0.000000 },
|
||||
{4299,4300, 0, 1, 280, 280,0.031250 },
|
||||
{4301,4301, 0, 0, 40, 40,0.000000 },
|
||||
{4302,4303, 0, 1, 53, 53,0.000000 },
|
||||
{4304,4305, 0, 1, 140, 140,0.000000 },
|
||||
{4306,4307, 0, 1, 26, 26,0.000000 },
|
||||
{4308,4309, 0, 1, 2153, 2153,0.109375 },
|
||||
{4310,4310, 0, 0, 600, 600,0.000000 },
|
||||
{4311,4312, 0, 1, 993, 26,0.000000 },
|
||||
{4313,4314, 0, 1, 5613, 5613,0.000000 },
|
||||
{4315,4315, 0, 0, 220, 220,0.000000 },
|
||||
{4316,4317, 0, 1, 10306, 526,0.000000 },
|
||||
{4318,4319, 0, 1, 1486, 13,0.000000 },
|
||||
{4320,4321, 0, 1, 40000, 660,0.000000 },
|
||||
{4322,4322, 0, 0, 120, 120,0.000000 },
|
||||
{4323,4323, 34, 0, 40, 40,0.000000 },
|
||||
{4324,4324, 28, 0, 73, 73,0.000000 },
|
||||
{4325,4326, 39, 1, 233, 233,0.000000 },
|
||||
{4325,4326, 33, 1, 193, 193,0.000000 },
|
||||
{4327,4328, 63, 1, 33, 33,0.000000 },
|
||||
{4329,4329, 15, 0, 13, 13,0.000000 },
|
||||
{4330,4330, 36, 0, 13, 13,0.000000 },
|
||||
{4330,4331, 36, 1, 133, 133,0.406250 },
|
||||
{4332,4333, 25, 1, 13, 13,0.000000 },
|
||||
{4334,4333, 25, 1, 33, 33,0.000000 },
|
||||
{4335,4336, 61, 1, 40, 40,0.000000 },
|
||||
{4337,4338, 37, 1, 53, 53,0.000000 },
|
||||
{4339,4340, 15, 1, 80, 80,0.000000 },
|
||||
{4341,4342, 48, 1, 73, 73,-1.906250 },
|
||||
{4343,4344, 19, 1, 120, 120,0.000000 },
|
||||
{4345,4345, 48, 0, 53, 53,0.000000 },
|
||||
{4346,4347, 15, 1, 33, 33,0.000000 },
|
||||
{4348,4349, 12, 1, 33, 33,0.000000 },
|
||||
{4350,4351, 12, 1, 33, 33,0.000000 },
|
||||
{4352,4351, 10, 1, 40, 40,0.000000 },
|
||||
{4353,4354, 60, 1, 286, 286,0.062500 },
|
||||
{4355,4355, 62, 0, 1726, 1726,0.000000 },
|
||||
{4356,4357, 80, 1, 106, 106,0.125000 },
|
||||
{4358,4358, 58, 0, 73, 73,0.000000 },
|
||||
{4359,4360, 31, 1, 313, 313,0.000000 },
|
||||
{4361,4361, 61, 0, 206, 206,0.000000 },
|
||||
{4362,4363, 41, 1, 100, 100,0.000000 },
|
||||
{4364,4365, 35, 1, 160, 160,0.000000 },
|
||||
{4366,4367, 29, 1, 40, 40,0.000000 },
|
||||
{4368,4369, 41, 1, 166, 166,0.000000 },
|
||||
{4368,4369, 37, 1, 160, 160,0.000000 },
|
||||
{4370,4371, 54, 1, 80, 80,0.000000 },
|
||||
{4370,4372, 48, 1, 80, 80,0.000000 },
|
||||
{4373,4374, 77, 1, 53, 53,0.000000 },
|
||||
{4375,4376, 72, 1, 46, 46,0.000000 },
|
||||
{4377,4377, 40, 0, 140, 140,0.000000 },
|
||||
{4378,4378, 45, 0, 313, 313,0.000000 },
|
||||
{4379,4379, 42, 0, 40000, 0,0.000000 },
|
||||
{4380,4380, 73, 0, 60, 60,0.000000 },
|
||||
{4381,4382, 68, 1, 40, 40,0.000000 },
|
||||
{4383,4384, 18, 1, 60, 60,0.000000 },
|
||||
{4385,4386, 18, 1, 106, 106,0.000000 },
|
||||
{4387,4387, 90, 0, 80, 80,0.000000 },
|
||||
{4388,4388, 90, 0, 306, 306,0.000000 },
|
||||
{4389,4390, 64, 1, 233, 233,0.031250 },
|
||||
{4391,4392, 80, 1, 140, 140,0.031250 },
|
||||
{4393,4394, 64, 1, 606, 606,0.000000 },
|
||||
{4395,4395, 67, 0, 20, 20,0.000000 },
|
||||
{4396,4397, 50, 1, 53, 53,0.000000 },
|
||||
{4398,4398, 36, 0, 66, 66,0.000000 },
|
||||
{4399,4399, 0, 0, 40000, 20,0.000000 },
|
||||
{4400,4400, 0, 0, 40000, 0,0.000000 },
|
||||
{4401,4401, 0, 0, 360, 360,0.000000 },
|
||||
{4402,4402, 0, 0, 586, 586,0.000000 },
|
||||
{4175,4176, 0, 1, 2533, 2533,0.078125 },
|
||||
{4177,4178, 0, 1, 2040, 13,0.000000 },
|
||||
{4179,4179, 0, 0, 40000, 66,0.000000 },
|
||||
{4180,4181, 0, 1, 40000, 60,0.000025 },
|
||||
{4182,4182, 0, 0, 40000, 133,0.000000 },
|
||||
{4183,4184, 0, 1, 40000, 173,0.078125 },
|
||||
{4185,4186, 0, 1, 333, 333,0.109375 },
|
||||
{4187,4188, 0, 1, 1813, 1813,0.031250 },
|
||||
{4189,4190, 0, 1, 1473, 1473,0.031250 },
|
||||
{4191,4192, 0, 1, 40000, 213,0.062500 },
|
||||
{4193,4194, 0, 1, 40000, 500,-0.062500 },
|
||||
{4195,4195, 0, 1, 40000, 326,0.109375 },
|
||||
{4196,4196, 0, 1, 40000, 406,0.109375 },
|
||||
{4197,4198, 0, 1, 40000, 280,0.140625 },
|
||||
{4199,4200, 0, 1, 40000, 53,0.140625 },
|
||||
{4201,4202, 0, 1, 40000, 286,0.156250 },
|
||||
{4203,4204, 0, 1, 206, 206,0.125000 },
|
||||
{4205,4206, 0, 1, 40000, 26,0.000000 },
|
||||
{4207,4208, 0, 1, 40000, 20,0.031250 },
|
||||
{4209,4209, 0, 0, 40000, 6,0.000000 },
|
||||
{4210,4210, 0, 0, 40000, 20,0.000000 },
|
||||
{4211,4212, 0, 1, 40000, 160,0.031250 },
|
||||
{4213,4214, 0, 1, 40000, 73,0.062500 },
|
||||
{4215,4216, 0, 1, 2526, 2526,0.093750 },
|
||||
{4217,4217, 0, 1, 5153, 5153,0.125000 },
|
||||
{4218,4219, 0, 1, 40000, 73,0.000000 },
|
||||
{4220,4220, 0, 0, 40000, 60,0.000000 },
|
||||
{4221,4221, 0, 0, 40000, 0,0.000000 },
|
||||
{4222,4222, 0, 0, 40000, 0,0.000000 },
|
||||
{4223,4224, 0, 1, 40000, 73,0.000000 },
|
||||
{4225,4225, 0, 0, 40000, 33,0.000000 },
|
||||
{4226,4226, 0, 0, 40000, 6,0.000000 },
|
||||
{4227,4228, 0, 1, 40000, 40,0.000000 },
|
||||
{4229,4229, 0, 0, 40000, 0,0.000000 },
|
||||
{4230,4230, 0, 0, 40000, 6,0.000000 },
|
||||
{4231,4231, 0, 0, 40000, 33,0.000000 },
|
||||
{4232,4233, 0, 1, 40000, 53,0.031250 },
|
||||
{4234,4235, 0, 1, 40000, 20,0.046875 },
|
||||
{4236,4237, 0, 1, 420, 420,0.031250 },
|
||||
{4238,4238, 0, 0, 40000, 106,0.000000 },
|
||||
{4239,4239, 0, 0, 40000, 6,0.000000 },
|
||||
{4240,4241, 0, 1, 40000, 6,0.125000 },
|
||||
{4242,4243, 0, 1, 40000, 13,0.109375 },
|
||||
{4244,4245, 0, 1, 40000, 53,0.109375 },
|
||||
{4246,4247, 0, 1, 226, 6,-0.031250 },
|
||||
{4248,4248, 0, 0, 40000, 6,0.000000 },
|
||||
{4249,4250, 0, 1, 40000, 133,0.156250 },
|
||||
{4251,4252, 0, 1, 4186, 13,0.125000 },
|
||||
{4253,4254, 0, 1, 40000, 26,0.031250 },
|
||||
{4255,4256, 0, 1, 40000, 660,0.078125 },
|
||||
{4257,4258, 0, 1, 846, 66,0.109375 },
|
||||
{4259,4260, 0, 1, 1293, 80,0.078125 },
|
||||
{4261,4262, 0, 1, 40000, 300,0.140625 },
|
||||
{4263,4264, 0, 1, 2040, 2040,0.109375 },
|
||||
{4265,4266, 0, 1, 1360, 1360,0.062500 },
|
||||
{4267,4268, 0, 1, 40000, 433,0.093750 },
|
||||
{4269,4270, 0, 1, 40000, 533,0.109375 },
|
||||
{4271,4272, 0, 1, 826, 826,0.093750 },
|
||||
{4273,4274, 0, 1, 40000, 926,0.125000 },
|
||||
{4275,4275, 0, 1, 886, 886,0.109375 },
|
||||
{4276,4277, 0, 1, 2186, 2186,-0.046875 },
|
||||
{4278,4279, 0, 1, 1486, 1486,0.125000 },
|
||||
{4280,4281, 0, 1, 40000, 393,-0.078125 },
|
||||
{4282,4283, 0, 1, 40000, 1166,0.140625 },
|
||||
{4284,4285, 0, 1, 360, 360,0.078125 },
|
||||
{4286,4287, 0, 1, 1693, 1693,0.031250 },
|
||||
{4288,4289, 0, 1, 760, 760,0.000000 },
|
||||
{4290,4291, 0, 1, 126, 126,0.031250 },
|
||||
{4292,4292, 0, 0, 300, 300,0.000000 },
|
||||
{4293,4294, 0, 1, 280, 280,0.000000 },
|
||||
{4295,4296, 0, 1, 40000, 26,0.062500 },
|
||||
{4297,4297, 0, 0, 40000, 66,0.000000 },
|
||||
{4298,4298, 0, 0, 40000, 53,0.000000 },
|
||||
{4299,4299, 0, 0, 1940, 1940,0.000000 },
|
||||
{4300,4300, 0, 0, 86, 86,0.000000 },
|
||||
{4301,4302, 0, 1, 280, 280,0.031250 },
|
||||
{4303,4303, 0, 0, 40, 40,0.000000 },
|
||||
{4304,4305, 0, 1, 53, 53,0.000000 },
|
||||
{4306,4307, 0, 1, 140, 140,0.000000 },
|
||||
{4308,4309, 0, 1, 26, 26,0.000000 },
|
||||
{4310,4311, 0, 1, 2153, 2153,0.109375 },
|
||||
{4312,4312, 0, 0, 293, 293,0.000000 },
|
||||
{4313,4314, 0, 1, 993, 26,0.000000 },
|
||||
{4315,4316, 0, 1, 5613, 5613,0.000000 },
|
||||
{4317,4317, 0, 0, 220, 220,0.000000 },
|
||||
{4318,4319, 0, 1, 10306, 526,0.000000 },
|
||||
{4320,4321, 0, 1, 1486, 13,0.000000 },
|
||||
{4322,4323, 0, 1, 40000, 660,0.000000 },
|
||||
{4324,4324, 0, 0, 120, 120,0.000000 },
|
||||
{4325,4325, 34, 0, 40, 40,0.000000 },
|
||||
{4326,4326, 28, 0, 73, 73,0.000000 },
|
||||
{4327,4328, 39, 1, 233, 233,0.000000 },
|
||||
{4327,4328, 33, 1, 193, 193,0.000000 },
|
||||
{4329,4330, 63, 1, 33, 33,0.000000 },
|
||||
{4331,4331, 15, 0, 13, 13,0.000000 },
|
||||
{4332,4332, 36, 0, 13, 13,0.000000 },
|
||||
{4332,4333, 36, 1, 133, 133,0.406250 },
|
||||
{4334,4335, 25, 1, 13, 13,0.000000 },
|
||||
{4336,4335, 25, 1, 33, 33,0.000000 },
|
||||
{4337,4338, 61, 1, 40, 40,0.000000 },
|
||||
{4339,4340, 37, 1, 53, 53,0.000000 },
|
||||
{4341,4342, 15, 1, 320, 320,0.000000 },
|
||||
{4343,4344, 48, 1, 73, 73,-1.906250 },
|
||||
{4341,4345, 19, 1, 320, 320,0.000000 },
|
||||
{4346,4346, 48, 0, 53, 53,0.000000 },
|
||||
{4341,4342, 22, 1, 353, 353,0.000000 },
|
||||
{4341,4342, 24, 1, 360, 360,0.000000 },
|
||||
{4341,4347, 27, 1, 393, 393,0.000000 },
|
||||
{4341,4342, 31, 1, 380, 380,0.000000 },
|
||||
{4348,4349, 60, 1, 246, 246,0.031250 },
|
||||
{4350,4350, 70, 0, 340, 340,0.000000 },
|
||||
{4351,4352, 80, 1, 106, 106,0.125000 },
|
||||
{4353,4353, 58, 0, 73, 73,0.000000 },
|
||||
{4354,4355, 31, 1, 313, 313,0.000000 },
|
||||
{4356,4356, 61, 0, 253, 253,0.000000 },
|
||||
{4357,4358, 41, 1, 100, 100,0.000000 },
|
||||
{4359,4360, 35, 1, 160, 160,0.000000 },
|
||||
{4361,4362, 29, 1, 40, 40,0.000000 },
|
||||
{4363,4364, 41, 1, 166, 166,0.000000 },
|
||||
{4363,4364, 37, 1, 160, 160,0.000000 },
|
||||
{4365,4366, 54, 1, 80, 80,0.000000 },
|
||||
{4365,4367, 48, 1, 80, 80,0.000000 },
|
||||
{4368,4369, 77, 1, 53, 53,0.000000 },
|
||||
{4370,4371, 72, 1, 46, 46,0.000000 },
|
||||
{4372,4372, 40, 0, 140, 140,0.000000 },
|
||||
{4373,4373, 38, 0, 73, 73,0.000000 },
|
||||
{4374,4374, 36, 0, 533, 533,0.000000 },
|
||||
{4375,4376, 60, 1, 26, 26,0.000000 },
|
||||
{4376,4377, 60, 1, 26, 26,0.000000 },
|
||||
{4378,4378, 73, 0, 60, 60,0.000000 },
|
||||
{4379,4380, 68, 1, 40, 40,0.000000 },
|
||||
{4381,4382, 18, 1, 60, 60,0.000000 },
|
||||
{4383,4384, 18, 1, 106, 106,0.000000 },
|
||||
{4385,4385, 90, 0, 80, 80,0.000000 },
|
||||
{4386,4386, 90, 0, 306, 306,0.000000 },
|
||||
{4387,4388, 64, 1, 233, 233,0.031250 },
|
||||
{4389,4390, 80, 1, 140, 140,0.031250 },
|
||||
{4391,4392, 64, 1, 606, 606,0.000000 },
|
||||
{4393,4393, 67, 0, 20, 20,0.000000 },
|
||||
{4394,4395, 50, 1, 53, 53,0.000000 },
|
||||
{4396,4396, 36, 0, 66, 66,0.000000 },
|
||||
{4397,4397, 0, 0, 40000, 20,0.000000 },
|
||||
{4398,4398, 0, 0, 40000, 0,0.000000 },
|
||||
{4399,4399, 0, 0, 360, 360,0.000000 },
|
||||
{4400,4400, 0, 0, 586, 586,0.000000 },
|
||||
{4401,4401, 0, 0, 40000, 0,0.000000 },
|
||||
{4402,4402, 0, 0, 40000, 0,0.000000 },
|
||||
{4403,4403, 0, 0, 40000, 0,0.000000 },
|
||||
{4404,4404, 0, 0, 40000, 0,0.000000 },
|
||||
{4404,4404, 0, 0, 40000, 6,0.000000 },
|
||||
{4405,4405, 0, 0, 40000, 0,0.000000 },
|
||||
{4406,4406, 0, 0, 40000, 6,0.000000 },
|
||||
{4407,4407, 0, 0, 40000, 0,0.000000 },
|
||||
{4408,4408, 0, 0, 146, 146,0.000000 },
|
||||
{4408,4408, 73, 0, 886, 886,0.000000 },
|
||||
{4409,4409, 0, 0, 40, 0,0.000000 },
|
||||
{4410,4410, 0, 0, 486, 0,0.000000 },
|
||||
{4411,4411, 0, 0, 1226, 1226,0.000000 },
|
||||
{4412,4412, 0, 0, 1480, 1480,0.000000 },
|
||||
{4413,4413, 0, 0, 46, 46,0.000000 },
|
||||
{4414,4414, 0, 0, 126, 126,0.000000 },
|
||||
{4414,4414, 12, 0, 106, 106,0.000000 },
|
||||
{4415,4415, 0, 0, 160, 160,0.000000 },
|
||||
{4415,4415, 1, 0, 153, 153,0.000000 },
|
||||
{4416,4416, 0, 0, 20, 20,0.000000 },
|
||||
{4416,4416, 23, 0, 26, 26,0.000000 },
|
||||
{4417,4417, 0, 0, 140, 140,0.000000 },
|
||||
{4418,4418, 0, 0, 486, 486,0.000000 },
|
||||
{4419,4419, 0, 0, 40000, 13,0.000000 },
|
||||
{4420,4420, 0, 0, 40000, 0,0.000000 },
|
||||
{4421,4421, 0, 0, 1226, 1226,0.000000 },
|
||||
{4422,4422, 0, 0, 766, 766,0.000000 },
|
||||
{4423,4423, 0, 0, 93, 93,0.000000 },
|
||||
{4424,4424, 0, 2, 40000, 0,0.000000 },
|
||||
{4406,4406, 0, 0, 146, 146,0.000000 },
|
||||
{4406,4406, 73, 0, 886, 886,0.000000 },
|
||||
{4407,4407, 0, 0, 40, 0,0.000000 },
|
||||
{4408,4408, 0, 0, 486, 0,0.000000 },
|
||||
{4409,4409, 0, 0, 1226, 1226,0.000000 },
|
||||
{4410,4410, 0, 0, 1480, 1480,0.000000 },
|
||||
{4411,4411, 0, 0, 46, 46,0.000000 },
|
||||
{4412,4412, 0, 0, 126, 126,0.000000 },
|
||||
{4412,4412, 12, 0, 106, 106,0.000000 },
|
||||
{4413,4413, 0, 0, 160, 160,0.000000 },
|
||||
{4413,4413, 1, 0, 153, 153,0.000000 },
|
||||
{4414,4414, 0, 0, 20, 20,0.000000 },
|
||||
{4414,4414, 23, 0, 26, 26,0.000000 },
|
||||
{4415,4415, 0, 0, 140, 140,0.000000 },
|
||||
{4416,4416, 0, 0, 486, 486,0.000000 },
|
||||
{4417,4417, 0, 0, 40000, 13,0.000000 },
|
||||
{4418,4418, 0, 0, 40000, 0,0.000000 },
|
||||
{4419,4419, 0, 0, 1226, 1226,0.000000 },
|
||||
{4420,4420, 0, 0, 766, 766,0.000000 },
|
||||
{4421,4421, 0, 0, 93, 93,0.000000 },
|
||||
{4422,4422, 0, 2, 40000, 0,0.000000 },
|
||||
};
|
||||
|
||||
|
||||
|
@ -9002,7 +9002,7 @@ int maxAdlBanks()
|
|||
|
||||
const char* const banknames[74] =
|
||||
{
|
||||
"AIL (Star Control 3, Albion, Empire 2, many others)",
|
||||
"AIL (Star Control 3, Albion, Empire 2, etc.)",
|
||||
"Bisqwit (selection of 4op and 2op)",
|
||||
"HMI (Descent, Asterix)",
|
||||
"HMI (Descent:: Int)",
|
||||
|
@ -9016,47 +9016,47 @@ const char* const banknames[74] =
|
|||
"HMI (Aces of the Deep)",
|
||||
"HMI (Earthsiege)",
|
||||
"HMI (Anvil of Dawn)",
|
||||
"DMX (Doom)",
|
||||
"DMX (Doom 2)",
|
||||
"DMX (Hexen, Heretic)",
|
||||
"DMX (MUS Play)",
|
||||
"AIL (Discworld, Grandest Fleet)",
|
||||
"DMX (DOOM, MUS Play)",
|
||||
"AIL (Discworld, Grandest Fleet, etc.)",
|
||||
"AIL (Warcraft 2)",
|
||||
"AIL (Syndicate)",
|
||||
"AIL (Guilty, Orion Conspiracy)",
|
||||
"AIL (Guilty, Orion Conspiracy, TNSFC ::4op)",
|
||||
"AIL (Magic Carpet 2)",
|
||||
"AIL (Nemesis)",
|
||||
"AIL (Jagged Alliance)",
|
||||
"AIL (When Two Worlds War)",
|
||||
"AIL (Bards Tale Construction)",
|
||||
"AIL (When Two Worlds War :MISS-INS:)",
|
||||
"AIL (Bards Tale Construction :MISS-INS:)",
|
||||
"AIL (Return to Zork)",
|
||||
"AIL (Theme Hospital)",
|
||||
"AIL (National Hockey League PA)",
|
||||
"AIL (Inherit The Earth)",
|
||||
"AIL (Inherit The Earth, file two)",
|
||||
"AIL (Little Big Adventure)",
|
||||
"AIL (Little Big Adventure :: 4op)",
|
||||
"AIL (Wreckin Crew)",
|
||||
"AIL (Death Gate)",
|
||||
"AIL (FIFA International Soccer)",
|
||||
"AIL (Starship Invasion)",
|
||||
"AIL (Super Street Fighter 2)",
|
||||
"AIL (Lords of the Realm)",
|
||||
"AIL (SimFarm, SimHealth)",
|
||||
"AIL (Super Street Fighter 2 :4op:)",
|
||||
"AIL (Lords of the Realm :MISS-INS:)",
|
||||
"AIL (SimFarm, SimHealth :: 4op)",
|
||||
"AIL (SimFarm, Settlers, Serf City)",
|
||||
"AIL (Caesar 2, MISSING INSTRUMENTS)",
|
||||
"AIL (Caesar 2, :p4op::MISS-INS:)",
|
||||
"AIL (Syndicate Wars)",
|
||||
"AIL (Bubble Bobble Feat. Rainbow Islands, Z)",
|
||||
"AIL (Warcraft)",
|
||||
"AIL (Terra Nova Strike Force Centuri)",
|
||||
"AIL (System Shock)",
|
||||
"AIL (Terra Nova Strike Force Centuri :p4op:)",
|
||||
"AIL (System Shock :p4op:)",
|
||||
"AIL (Advanced Civilization)",
|
||||
"AIL (Battle Chess 4000, melodic only)",
|
||||
"AIL (Ultimate Soccer Manager)",
|
||||
"AIL (Air Bucks, Blue And The Gray)",
|
||||
"AIL (Battle Chess 4000 :p4op:)",
|
||||
"AIL (Ultimate Soccer Manager :p4op:)",
|
||||
"AIL (Air Bucks, Blue And The Gray, etc)",
|
||||
"AIL (Ultima Underworld 2)",
|
||||
"AIL (Kasparov's Gambit)",
|
||||
"AIL (High Seas Trader)",
|
||||
"AIL (Master of Magic, std percussion)",
|
||||
"AIL (Master of Magic, orchestral percussion)",
|
||||
"AIL (High Seas Trader :MISS-INS:)",
|
||||
"AIL (Master of Magic, :4op: std percussion)",
|
||||
"AIL (Master of Magic, :4op: orchestral percussion)",
|
||||
"SB (Action Soccer)",
|
||||
"SB (3d Cyberpuck :: melodic only)",
|
||||
"SB (Simon the Sorcerer :: melodic only)",
|
||||
|
@ -10388,14 +10388,14 @@ const unsigned short banks[74][256] =
|
|||
806, 806, 806, 806, 806, 806, 806, 806, 806, 806, 806,4467,4468,4469,4470,4471,
|
||||
4472,4473,4474,4475,4476,4477,4217,4478,4218,4479,4480,4481,4482,4483,4221,4484,
|
||||
4485,4222,4486,4487,4224,4488,4489,4226,4490,4227,4491,4492,4493,4494,4495,4496,
|
||||
4497,4498,4499,4500,4501, 320,4502,4503,4504,4231,4232,4505,4506,1374,4507,4508,
|
||||
4509,4510,4511,4512,4513,4514,4515,4516, 806, 806, 806, 806, 806, 806, 806, 806,
|
||||
4497,4498,4499,4500,4501, 320,4502,4503,4504,4505,4506,4507,4508,1374,4509,4510,
|
||||
4511,4512,4513,4514,4515,4516,4517,4518, 806, 806, 806, 806, 806, 806, 806, 806,
|
||||
806, 806, 806, 806, 806, 806, 806, 806, 806, 806, 806, 806, 806, 806, 806, 806,
|
||||
806, 806, 806, 806, 806, 806, 806, 806, 806, 806, 806, 806, 806, 806, 806, 806,
|
||||
},
|
||||
{
|
||||
4517,4518,4519,4520,4518,4521,4522,4523,4524,4525,4526,4528,4529,4530,4531,4532,
|
||||
4533,4535,4537,4530,4539,4540,4541,4542,4543,4544,4545, 295, 28, 29, 30, 31,
|
||||
4519,4520,4521,4522,4520,4523,4524,4525,4526,4527,4528,4530,4531,4532,4533,4534,
|
||||
4535,4537,4539,4532,4541,4542,4543,4544,4545,4546,4547, 295, 28, 29, 30, 31,
|
||||
32, 33, 34, 35, 36, 37, 38, 33, 39, 40, 41, 42, 43, 44, 45, 46,
|
||||
47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
|
||||
63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
|
||||
|
@ -10404,8 +10404,8 @@ const unsigned short banks[74][256] =
|
|||
111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
|
||||
295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295,
|
||||
295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295,
|
||||
295, 295, 295, 127,4534, 128,4536, 130, 131, 132,4538, 134, 135, 136, 137, 138,
|
||||
139, 140, 141, 142, 143, 144,4527, 146, 147, 148, 149, 150, 151, 152, 153, 154,
|
||||
295, 295, 295, 127,4536, 128,4538, 130, 131, 132,4540, 134, 135, 136, 137, 138,
|
||||
139, 140, 141, 142, 143, 144,4529, 146, 147, 148, 149, 150, 151, 152, 153, 154,
|
||||
155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170,
|
||||
295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295,
|
||||
295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295, 295,
|
||||
|
@ -10415,7 +10415,7 @@ const unsigned short banks[74][256] =
|
|||
|
||||
const AdlBankSetup adlbanksetup[74] =
|
||||
{
|
||||
{0, 1, 1, 0, 0}, //Bank 0, AIL (Star Control 3, Albion, Empire 2, Sensible Soccer, Settlers 2, many others)
|
||||
{0, 1, 1, 0, 0}, //Bank 0, AIL (Star Control 3, Albion, Empire 2, etc.)
|
||||
{0, 1, 1, 0, 0}, //Bank 1, Bisqwit (selection of 4op and 2op)
|
||||
{0, 0, 0, 0, 0}, //Bank 2, HMI (Descent, Asterix)
|
||||
{0, 0, 0, 0, 0}, //Bank 3, HMI (Descent:: Int)
|
||||
|
@ -10429,18 +10429,18 @@ const AdlBankSetup adlbanksetup[74] =
|
|||
{0, 0, 0, 0, 0}, //Bank 11, HMI (Aces of the Deep)
|
||||
{0, 0, 0, 0, 0}, //Bank 12, HMI (Earthsiege)
|
||||
{0, 0, 0, 0, 0}, //Bank 13, HMI (Anvil of Dawn)
|
||||
{2, 0, 0, 0, 0}, //Bank 14, DMX (Doom :: partially pseudo 4op)
|
||||
{2, 0, 0, 0, 0}, //Bank 15, DMX (Hexen, Heretic :: partially pseudo 4op)
|
||||
{2, 0, 0, 0, 0}, //Bank 16, DMX (MUS Play :: partially pseudo 4op)
|
||||
{0, 1, 1, 0, 0}, //Bank 17, AIL (Discworld, Grandest Fleet, Pocahontas, Slob Zone 3d, Ultima 4, Zorro)
|
||||
{2, 0, 0, 0, 0}, //Bank 14, DMX (Doom 2)
|
||||
{2, 0, 0, 0, 0}, //Bank 15, DMX (Hexen, Heretic)
|
||||
{2, 0, 0, 0, 0}, //Bank 16, DMX (DOOM, MUS Play)
|
||||
{0, 1, 1, 0, 0}, //Bank 17, AIL (Discworld, Grandest Fleet, etc.)
|
||||
{0, 1, 1, 0, 0}, //Bank 18, AIL (Warcraft 2)
|
||||
{0, 1, 1, 0, 0}, //Bank 19, AIL (Syndicate)
|
||||
{0, 1, 1, 0, 0}, //Bank 20, AIL (Guilty, Orion Conspiracy, Terra Nova Strike Force Centauri :: 4op)
|
||||
{0, 1, 1, 0, 0}, //Bank 20, AIL (Guilty, Orion Conspiracy, TNSFC ::4op)
|
||||
{0, 1, 1, 0, 0}, //Bank 21, AIL (Magic Carpet 2)
|
||||
{0, 1, 1, 0, 0}, //Bank 22, AIL (Nemesis)
|
||||
{0, 1, 1, 0, 0}, //Bank 23, AIL (Jagged Alliance)
|
||||
{0, 1, 1, 0, 0}, //Bank 24, AIL (When Two Worlds War :: 4op, MISSING INSTRUMENTS)
|
||||
{0, 1, 1, 0, 0}, //Bank 25, AIL (Bards Tale Construction :: MISSING INSTRUMENTS)
|
||||
{0, 1, 1, 0, 0}, //Bank 24, AIL (When Two Worlds War :MISS-INS:)
|
||||
{0, 1, 1, 0, 0}, //Bank 25, AIL (Bards Tale Construction :MISS-INS:)
|
||||
{0, 1, 1, 0, 0}, //Bank 26, AIL (Return to Zork)
|
||||
{0, 1, 1, 0, 0}, //Bank 27, AIL (Theme Hospital)
|
||||
{0, 1, 1, 0, 0}, //Bank 28, AIL (National Hockey League PA)
|
||||
|
@ -10451,25 +10451,25 @@ const AdlBankSetup adlbanksetup[74] =
|
|||
{0, 1, 1, 0, 0}, //Bank 33, AIL (Death Gate)
|
||||
{0, 1, 1, 0, 0}, //Bank 34, AIL (FIFA International Soccer)
|
||||
{0, 1, 1, 0, 0}, //Bank 35, AIL (Starship Invasion)
|
||||
{0, 1, 1, 0, 0}, //Bank 36, AIL (Super Street Fighter 2 :: 4op)
|
||||
{0, 1, 1, 0, 0}, //Bank 37, AIL (Lords of the Realm :: MISSING INSTRUMENTS)
|
||||
{0, 1, 1, 0, 0}, //Bank 36, AIL (Super Street Fighter 2 :4op:)
|
||||
{0, 1, 1, 0, 0}, //Bank 37, AIL (Lords of the Realm :MISS-INS:)
|
||||
{0, 1, 1, 0, 0}, //Bank 38, AIL (SimFarm, SimHealth :: 4op)
|
||||
{0, 1, 1, 0, 0}, //Bank 39, AIL (SimFarm, Settlers, Serf City)
|
||||
{0, 1, 1, 0, 0}, //Bank 40, AIL (Caesar 2 :: partially 4op, MISSING INSTRUMENTS)
|
||||
{0, 1, 1, 0, 0}, //Bank 40, AIL (Caesar 2, :p4op::MISS-INS:)
|
||||
{0, 1, 1, 0, 0}, //Bank 41, AIL (Syndicate Wars)
|
||||
{0, 1, 1, 0, 0}, //Bank 42, AIL (Bubble Bobble Feat. Rainbow Islands, Z)
|
||||
{0, 1, 1, 0, 0}, //Bank 43, AIL (Warcraft)
|
||||
{0, 1, 1, 0, 0}, //Bank 44, AIL (Terra Nova Strike Force Centuri :: partially 4op)
|
||||
{0, 1, 1, 0, 0}, //Bank 45, AIL (System Shock :: partially 4op)
|
||||
{0, 1, 1, 0, 0}, //Bank 44, AIL (Terra Nova Strike Force Centuri :p4op:)
|
||||
{0, 1, 1, 0, 0}, //Bank 45, AIL (System Shock :p4op:)
|
||||
{0, 1, 1, 0, 0}, //Bank 46, AIL (Advanced Civilization)
|
||||
{0, 1, 1, 0, 0}, //Bank 47, AIL (Battle Chess 4000 :: partially 4op, melodic only)
|
||||
{0, 1, 1, 0, 0}, //Bank 48, AIL (Ultimate Soccer Manager :: partially 4op)
|
||||
{0, 1, 1, 0, 0}, //Bank 49, AIL (Air Bucks, Blue And The Gray, America Invades, Terminator 2029)
|
||||
{0, 1, 1, 0, 0}, //Bank 47, AIL (Battle Chess 4000 :p4op:)
|
||||
{0, 1, 1, 0, 0}, //Bank 48, AIL (Ultimate Soccer Manager :p4op:)
|
||||
{0, 1, 1, 0, 0}, //Bank 49, AIL (Air Bucks, Blue And The Gray, etc)
|
||||
{0, 1, 1, 0, 0}, //Bank 50, AIL (Ultima Underworld 2)
|
||||
{0, 1, 1, 0, 0}, //Bank 51, AIL (Kasparov's Gambit)
|
||||
{0, 1, 1, 0, 0}, //Bank 52, AIL (High Seas Trader :: MISSING INSTRUMENTS)
|
||||
{0, 0, 0, 0, 0}, //Bank 53, AIL (Master of Magic, Master of Orion 2 :: 4op, std percussion)
|
||||
{0, 0, 0, 0, 0}, //Bank 54, AIL (Master of Magic, Master of Orion 2 :: 4op, orchestral percussion)
|
||||
{0, 1, 1, 0, 0}, //Bank 52, AIL (High Seas Trader :MISS-INS:)
|
||||
{0, 0, 0, 0, 0}, //Bank 53, AIL (Master of Magic, :4op: std percussion)
|
||||
{0, 0, 0, 0, 0}, //Bank 54, AIL (Master of Magic, :4op: orchestral percussion)
|
||||
{0, 0, 0, 0, 0}, //Bank 55, SB (Action Soccer)
|
||||
{0, 0, 0, 0, 0}, //Bank 56, SB (3d Cyberpuck :: melodic only)
|
||||
{0, 0, 0, 0, 0}, //Bank 57, SB (Simon the Sorcerer :: melodic only)
|
||||
|
|
|
@ -108,7 +108,7 @@ ADLMIDI_EXPORT int adl_setBank(ADL_MIDIPlayer *device, int bank)
|
|||
if(static_cast<uint32_t>(bankno) >= NumBanks)
|
||||
{
|
||||
char errBuf[150];
|
||||
std::snprintf(errBuf, 150, "Embedded bank number may only be 0..%u!\n", (NumBanks - 1));
|
||||
snprintf(errBuf, 150, "Embedded bank number may only be 0..%u!\n", (NumBanks - 1));
|
||||
play->setErrorString(errBuf);
|
||||
return -1;
|
||||
}
|
||||
|
@ -139,7 +139,7 @@ ADLMIDI_EXPORT int adl_setNumFourOpsChn(ADL_MIDIPlayer *device, int ops4)
|
|||
if((unsigned int)ops4 > 6 * play->m_setup.NumCards)
|
||||
{
|
||||
char errBuff[250];
|
||||
std::snprintf(errBuff, 250, "number of four-op channels may only be 0..%u when %u OPL3 cards are used.\n", (6 * (play->m_setup.NumCards)), play->m_setup.NumCards);
|
||||
snprintf(errBuff, 250, "number of four-op channels may only be 0..%u when %u OPL3 cards are used.\n", (6 * (play->m_setup.NumCards)), play->m_setup.NumCards);
|
||||
play->setErrorString(errBuff);
|
||||
return -1;
|
||||
}
|
||||
|
|
|
@ -103,7 +103,8 @@ enum WOPL_InstrumentFlags
|
|||
{
|
||||
WOPL_Flags_NONE = 0,
|
||||
WOPL_Flag_Enable4OP = 0x01,
|
||||
WOPL_Flag_Pseudo4OP = 0x02
|
||||
WOPL_Flag_Pseudo4OP = 0x02,
|
||||
WOPL_Flag_NoSound = 0x04,
|
||||
};
|
||||
|
||||
struct WOPL_Inst
|
||||
|
@ -151,6 +152,7 @@ static bool readInstrument(MIDIplay::fileReader &file, WOPL_Inst &ins, uint16_t
|
|||
|
||||
uint8_t flags = idata[39];
|
||||
ins.adlins.flags = (flags & WOPL_Flag_Enable4OP) && (flags & WOPL_Flag_Pseudo4OP) ? adlinsdata::Flag_Pseudo4op : 0;
|
||||
ins.adlins.flags|= (flags & WOPL_Flag_NoSound) ? adlinsdata::Flag_NoSound : 0;
|
||||
ins.fourOps = (flags & WOPL_Flag_Enable4OP) || (flags & WOPL_Flag_Pseudo4OP);
|
||||
|
||||
ins.op[0].feedconn = (idata[40]);
|
||||
|
|
|
@ -319,7 +319,7 @@ bool MIDIplay::buildTrackData()
|
|||
evtPos.delay = ReadVarLenEx(&trackPtr, end, ok);
|
||||
if(!ok)
|
||||
{
|
||||
int len = std::sprintf(error, "buildTrackData: Can't read variable-length value at begin of track %d.\n", (int)tk);
|
||||
int len = snprintf(error, 150, "buildTrackData: Can't read variable-length value at begin of track %d.\n", (int)tk);
|
||||
if((len > 0) && (len < 150))
|
||||
errorString += std::string(error, (size_t)len);
|
||||
return false;
|
||||
|
@ -347,7 +347,7 @@ bool MIDIplay::buildTrackData()
|
|||
event = parseEvent(&trackPtr, end, status);
|
||||
if(!event.isValid)
|
||||
{
|
||||
int len = std::sprintf(error, "buildTrackData: Fail to parse event in the track %d.\n", (int)tk);
|
||||
int len = snprintf(error, 150, "buildTrackData: Fail to parse event in the track %d.\n", (int)tk);
|
||||
if((len > 0) && (len < 150))
|
||||
errorString += std::string(error, (size_t)len);
|
||||
return false;
|
||||
|
@ -1031,7 +1031,7 @@ bool MIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocity)
|
|||
{
|
||||
if(!caugh_missing_banks_melodic.count(bank))
|
||||
{
|
||||
hooks.onDebugMessage(hooks.onDebugMessage_userData, "[%i] Playing missing percussion bank %i (patch %i)", channel, bank, midiins);
|
||||
hooks.onDebugMessage(hooks.onDebugMessage_userData, "[%i] Playing missing percussion MIDI bank %i (patch %i)", channel, bank, midiins);
|
||||
caugh_missing_banks_melodic.insert(bank);
|
||||
}
|
||||
}
|
||||
|
@ -1046,7 +1046,7 @@ bool MIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocity)
|
|||
{
|
||||
if(!caugh_missing_banks_percussion.count(bank))
|
||||
{
|
||||
hooks.onDebugMessage(hooks.onDebugMessage_userData, "[%i] Playing missing melodic bank %i (patch %i)", channel, bank, midiins);
|
||||
hooks.onDebugMessage(hooks.onDebugMessage_userData, "[%i] Playing missing melodic MIDI bank %i (patch %i)", channel, bank, midiins);
|
||||
caugh_missing_banks_percussion.insert(bank);
|
||||
}
|
||||
}
|
||||
|
@ -1060,29 +1060,48 @@ bool MIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocity)
|
|||
if(midiins == 48 || midiins == 50) vol /= 4; // HACK
|
||||
*/
|
||||
//if(midiins == 56) vol = vol*6/10; // HACK
|
||||
|
||||
//int meta = banks[opl.AdlBank][midiins];
|
||||
const size_t meta = opl.GetAdlMetaNumber(midiins);
|
||||
const adlinsdata &ains = opl.GetAdlMetaIns(meta);
|
||||
|
||||
size_t meta = opl.GetAdlMetaNumber(midiins);
|
||||
const adlinsdata *ains = &opl.GetAdlMetaIns(meta);
|
||||
int16_t tone = note;
|
||||
|
||||
if(ains.tone)
|
||||
if(!isPercussion && !isXgPercussion && (bank > 0)) // For non-zero banks
|
||||
{
|
||||
if(ains->flags & adlinsdata::Flag_NoSound)
|
||||
{
|
||||
if(hooks.onDebugMessage)
|
||||
{
|
||||
if(!caugh_missing_instruments.count(static_cast<uint8_t>(midiins)))
|
||||
{
|
||||
hooks.onDebugMessage(hooks.onDebugMessage_userData, "[%i] Caugh a blank instrument %i (offset %i) in the MIDI bank %u", channel, Ch[channel].patch, midiins, bank);
|
||||
caugh_missing_instruments.insert(static_cast<uint8_t>(midiins));
|
||||
}
|
||||
}
|
||||
bank = 0;
|
||||
midiins = Ch[channel].patch;
|
||||
meta = opl.GetAdlMetaNumber(midiins);
|
||||
ains = &opl.GetAdlMetaIns(meta);
|
||||
}
|
||||
}
|
||||
|
||||
if(ains->tone)
|
||||
{
|
||||
/*if(ains.tone < 20)
|
||||
tone += ains.tone;
|
||||
else*/
|
||||
if(ains.tone < 128)
|
||||
tone = ains.tone;
|
||||
if(ains->tone < 128)
|
||||
tone = ains->tone;
|
||||
else
|
||||
tone -= ains.tone - 128;
|
||||
tone -= ains->tone - 128;
|
||||
}
|
||||
|
||||
//uint16_t i[2] = { ains.adlno1, ains.adlno2 };
|
||||
bool pseudo_4op = ains.flags & adlinsdata::Flag_Pseudo4op;
|
||||
bool pseudo_4op = ains->flags & adlinsdata::Flag_Pseudo4op;
|
||||
MIDIchannel::NoteInfo::Phys voices[2] =
|
||||
{
|
||||
{ains.adlno1, false},
|
||||
{ains.adlno2, pseudo_4op}
|
||||
{ains->adlno1, false},
|
||||
{ains->adlno2, pseudo_4op}
|
||||
};
|
||||
|
||||
if((opl.AdlPercussionMode == 1) && PercussionMap[midiins & 0xFF])
|
||||
|
@ -1090,7 +1109,7 @@ bool MIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocity)
|
|||
|
||||
if(hooks.onDebugMessage)
|
||||
{
|
||||
if(!caugh_missing_instruments.count(static_cast<uint8_t>(midiins)) && (ains.flags & adlinsdata::Flag_NoSound))
|
||||
if(!caugh_missing_instruments.count(static_cast<uint8_t>(midiins)) && (ains->flags & adlinsdata::Flag_NoSound))
|
||||
{
|
||||
hooks.onDebugMessage(hooks.onDebugMessage_userData, "[%i] Playing missing instrument %i", channel, midiins);
|
||||
caugh_missing_instruments.insert(static_cast<uint8_t>(midiins));
|
||||
|
@ -2624,12 +2643,12 @@ ADLMIDI_EXPORT void AdlInstrumentTester::NextAdl(int offset)
|
|||
if(ains.tone)
|
||||
{
|
||||
/*if(ains.tone < 20)
|
||||
std::sprintf(ToneIndication, "+%-2d", ains.tone);
|
||||
snprintf(ToneIndication, 8, "+%-2d", ains.tone);
|
||||
else*/
|
||||
if(ains.tone < 128)
|
||||
std::sprintf(ToneIndication, "=%-2d", ains.tone);
|
||||
snprintf(ToneIndication, 8, "=%-2d", ains.tone);
|
||||
else
|
||||
std::sprintf(ToneIndication, "-%-2d", ains.tone - 128);
|
||||
snprintf(ToneIndication, 8, "-%-2d", ains.tone - 128);
|
||||
}
|
||||
std::printf("%s%s%s%u\t",
|
||||
ToneIndication,
|
||||
|
|
|
@ -105,7 +105,7 @@ const char *BaseFileSearch(const char *file, const char *ext, bool lookfirstinpr
|
|||
|
||||
CVAR(String, fluid_lib, "", CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
|
||||
|
||||
CUSTOM_CVAR(String, fluid_patchset, "", CVAR_ARCHIVE | CVAR_GLOBALCONFIG)
|
||||
CUSTOM_CVAR(String, fluid_patchset, "gzdoom", CVAR_ARCHIVE | CVAR_GLOBALCONFIG)
|
||||
{
|
||||
if (currSong != nullptr && currSong->GetDeviceType() == MDEV_FLUIDSYNTH)
|
||||
{
|
||||
|
|
|
@ -78,7 +78,7 @@ protected:
|
|||
TimidityPlus::Instruments *TimidityPPMIDIDevice::instruments;
|
||||
|
||||
// Config file to use
|
||||
CUSTOM_CVAR(String, timidity_config, "timidity.cfg", CVAR_ARCHIVE | CVAR_GLOBALCONFIG)
|
||||
CUSTOM_CVAR(String, timidity_config, "gzdoom", CVAR_ARCHIVE | CVAR_GLOBALCONFIG)
|
||||
{
|
||||
if (currSong != nullptr && currSong->GetDeviceType() == MDEV_TIMIDITY)
|
||||
{
|
||||
|
|
|
@ -280,10 +280,14 @@ bool OPNMIDIplay::LoadBank(OPNMIDIplay::fileReader &fr)
|
|||
size_t off = 37 + op * 7;
|
||||
std::memcpy(data.OPS[op].data, idata + off, 7);
|
||||
}
|
||||
|
||||
meta.flags = 0;
|
||||
if(version >= 2)
|
||||
{
|
||||
meta.ms_sound_kon = toUint16BE(idata + 65);
|
||||
meta.ms_sound_koff = toUint16BE(idata + 67);
|
||||
if((meta.ms_sound_kon == 0) && (meta.ms_sound_koff == 0))
|
||||
meta.flags |= opnInstMeta::Flag_NoSound;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -295,7 +299,6 @@ bool OPNMIDIplay::LoadBank(OPNMIDIplay::fileReader &fr)
|
|||
meta.opnno2 = uint16_t(opn.dynamic_instruments.size());
|
||||
|
||||
/* Junk, delete later */
|
||||
meta.flags = 0;
|
||||
meta.fine_tune = 0.0;
|
||||
/* Junk, delete later */
|
||||
|
||||
|
|
|
@ -280,7 +280,7 @@ bool OPNMIDIplay::buildTrackData()
|
|||
evtPos.delay = ReadVarLenEx(&trackPtr, end, ok);
|
||||
if(!ok)
|
||||
{
|
||||
int len = std::sprintf(error, "buildTrackData: Can't read variable-length value at begin of track %d.\n", (int)tk);
|
||||
int len = snprintf(error, 150, "buildTrackData: Can't read variable-length value at begin of track %d.\n", (int)tk);
|
||||
if((len > 0) && (len < 150))
|
||||
errorString += std::string(error, (size_t)len);
|
||||
return false;
|
||||
|
@ -308,7 +308,7 @@ bool OPNMIDIplay::buildTrackData()
|
|||
event = parseEvent(&trackPtr, end, status);
|
||||
if(!event.isValid)
|
||||
{
|
||||
int len = std::sprintf(error, "buildTrackData: Fail to parse event in the track %d.\n", (int)tk);
|
||||
int len = snprintf(error, 150, "buildTrackData: Fail to parse event in the track %d.\n", (int)tk);
|
||||
if((len > 0) && (len < 150))
|
||||
errorString += std::string(error, (size_t)len);
|
||||
return false;
|
||||
|
@ -981,7 +981,7 @@ bool OPNMIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocit
|
|||
{
|
||||
if(!caugh_missing_banks_melodic.count(bank))
|
||||
{
|
||||
hooks.onDebugMessage(hooks.onDebugMessage_userData, "[%i] Playing missing percussion bank %i (patch %i)", channel, bank, midiins);
|
||||
hooks.onDebugMessage(hooks.onDebugMessage_userData, "[%i] Playing missing percussion MIDI bank %i (patch %i)", channel, bank, midiins);
|
||||
caugh_missing_banks_melodic.insert(bank);
|
||||
}
|
||||
}
|
||||
|
@ -996,7 +996,7 @@ bool OPNMIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocit
|
|||
{
|
||||
if(!caugh_missing_banks_melodic.count(bank))
|
||||
{
|
||||
hooks.onDebugMessage(hooks.onDebugMessage_userData, "[%i] Playing missing melodic bank %i (patch %i)", channel, bank, midiins);
|
||||
hooks.onDebugMessage(hooks.onDebugMessage_userData, "[%i] Playing missing melodic MIDI bank %i (patch %i)", channel, bank, midiins);
|
||||
caugh_missing_banks_melodic.insert(bank);
|
||||
}
|
||||
}
|
||||
|
@ -1011,28 +1011,47 @@ bool OPNMIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocit
|
|||
*/
|
||||
//if(midiins == 56) vol = vol*6/10; // HACK
|
||||
|
||||
const size_t meta = opn.GetAdlMetaNumber(midiins);
|
||||
const opnInstMeta &ains = opn.GetAdlMetaIns(meta);
|
||||
size_t meta = opn.GetAdlMetaNumber(midiins);
|
||||
const opnInstMeta *ains = &opn.GetAdlMetaIns(meta);
|
||||
int16_t tone = note;
|
||||
|
||||
if(ains.tone)
|
||||
if(!isPercussion && !isXgPercussion && (bank > 0)) // For non-zero banks
|
||||
{
|
||||
if(ains->flags & opnInstMeta::Flag_NoSound)
|
||||
{
|
||||
if(hooks.onDebugMessage)
|
||||
{
|
||||
if(!caugh_missing_instruments.count(static_cast<uint8_t>(midiins)))
|
||||
{
|
||||
hooks.onDebugMessage(hooks.onDebugMessage_userData, "[%i] Caugh a blank instrument %i (offset %i) in the MIDI bank %u", channel, Ch[channel].patch, midiins, bank);
|
||||
caugh_missing_instruments.insert(static_cast<uint8_t>(midiins));
|
||||
}
|
||||
}
|
||||
bank = 0;
|
||||
midiins = Ch[channel].patch;
|
||||
meta = opn.GetAdlMetaNumber(midiins);
|
||||
ains = &opn.GetAdlMetaIns(meta);
|
||||
}
|
||||
}
|
||||
|
||||
if(ains->tone)
|
||||
{
|
||||
/*if(ains.tone < 20)
|
||||
tone += ains.tone;
|
||||
else*/
|
||||
if(ains.tone < 128)
|
||||
tone = ains.tone;
|
||||
if(ains->tone < 128)
|
||||
tone = ains->tone;
|
||||
else
|
||||
tone -= ains.tone - 128;
|
||||
tone -= ains->tone - 128;
|
||||
}
|
||||
|
||||
uint16_t i[2] = { ains.opnno1, ains.opnno2 };
|
||||
uint16_t i[2] = { ains->opnno1, ains->opnno2 };
|
||||
//bool pseudo_4op = ains.flags & opnInstMeta::Flag_Pseudo8op;
|
||||
//if((opn.AdlPercussionMode == 1) && PercussionMap[midiins & 0xFF]) i[1] = i[0];
|
||||
|
||||
if(hooks.onDebugMessage)
|
||||
{
|
||||
if(!caugh_missing_instruments.count(static_cast<uint8_t>(midiins)) && (ains.flags & opnInstMeta::Flag_NoSound))
|
||||
if(!caugh_missing_instruments.count(static_cast<uint8_t>(midiins)) && (ains->flags & opnInstMeta::Flag_NoSound))
|
||||
{
|
||||
hooks.onDebugMessage(hooks.onDebugMessage_userData, "[%i] Playing missing instrument %i", channel, midiins);
|
||||
caugh_missing_instruments.insert(static_cast<uint8_t>(midiins));
|
||||
|
@ -2548,12 +2567,12 @@ retry_arpeggio:
|
|||
// if(ains.tone)
|
||||
// {
|
||||
// /*if(ains.tone < 20)
|
||||
// std::sprintf(ToneIndication, "+%-2d", ains.tone);
|
||||
// snprintf(ToneIndication, 8, "+%-2d", ains.tone);
|
||||
// else*/
|
||||
// if(ains.tone < 128)
|
||||
// std::sprintf(ToneIndication, "=%-2d", ains.tone);
|
||||
// snprintf(ToneIndication, 8, "=%-2d", ains.tone);
|
||||
// else
|
||||
// std::sprintf(ToneIndication, "-%-2d", ains.tone - 128);
|
||||
// snprintf(ToneIndication, 8, "-%-2d", ains.tone - 128);
|
||||
// }
|
||||
// std::printf("%s%s%s%u\t",
|
||||
// ToneIndication,
|
||||
|
|
|
@ -36,7 +36,7 @@
|
|||
#include "v_text.h"
|
||||
#include "timidity.h"
|
||||
|
||||
CUSTOM_CVAR(String, midi_config, CONFIG_FILE, CVAR_ARCHIVE | CVAR_GLOBALCONFIG)
|
||||
CUSTOM_CVAR(String, midi_config, "gzdoom", CVAR_ARCHIVE | CVAR_GLOBALCONFIG)
|
||||
{
|
||||
Timidity::FreeAll();
|
||||
if (currSong != nullptr && currSong->GetDeviceType() == MDEV_GUS)
|
||||
|
|
|
@ -86,9 +86,6 @@ config.h
|
|||
|
||||
#define MAX_AMPLIFICATION 800
|
||||
|
||||
/* The TiMiditiy configuration file */
|
||||
#define CONFIG_FILE "timidity.cfg"
|
||||
|
||||
typedef float sample_t;
|
||||
typedef float final_volume_t;
|
||||
#define FINAL_VOLUME(v) (v)
|
||||
|
|
|
@ -264,28 +264,40 @@ namespace swrenderer
|
|||
WallC.sx1 = ds->sx1;
|
||||
WallC.sx2 = ds->sx2;
|
||||
|
||||
double top, bot;
|
||||
GetMaskedWallTopBottom(ds, top, bot);
|
||||
top -= Thread->Viewport->viewpoint.Pos.Z;
|
||||
bot -= Thread->Viewport->viewpoint.Pos.Z;
|
||||
// Unclipped vanilla Doom range for the wall. Relies on ceiling/floor clip to clamp the wall in range.
|
||||
double ceilZ = textop;
|
||||
double floorZ = textop - texheight;
|
||||
|
||||
// The 3D Floors implementation destroys the ceiling clip when doing its height passes..
|
||||
if (m3DFloor.clipTop || m3DFloor.clipBottom)
|
||||
{
|
||||
// Use the actual correct wall range for the midtexture.
|
||||
// This doesn't work for self-referenced sectors, which is why we only do it if we have 3D floors.
|
||||
|
||||
double top, bot;
|
||||
GetMaskedWallTopBottom(ds, top, bot);
|
||||
top -= Thread->Viewport->viewpoint.Pos.Z;
|
||||
bot -= Thread->Viewport->viewpoint.Pos.Z;
|
||||
|
||||
ceilZ = MIN(ceilZ, top);
|
||||
floorZ = MAX(floorZ, bot);
|
||||
}
|
||||
|
||||
// Clip wall by the current 3D floor render range.
|
||||
if (m3DFloor.clipTop)
|
||||
{
|
||||
wallupper.Project(Thread->Viewport.get(), textop < m3DFloor.sclipTop - Thread->Viewport->viewpoint.Pos.Z ? textop : m3DFloor.sclipTop - Thread->Viewport->viewpoint.Pos.Z, &WallC);
|
||||
}
|
||||
else
|
||||
{
|
||||
wallupper.Project(Thread->Viewport.get(), MIN(textop, top), &WallC);
|
||||
double clipZ = m3DFloor.sclipTop - Thread->Viewport->viewpoint.Pos.Z;
|
||||
ceilZ = MIN(ceilZ, clipZ);
|
||||
}
|
||||
if (m3DFloor.clipBottom)
|
||||
{
|
||||
walllower.Project(Thread->Viewport.get(), textop - texheight > m3DFloor.sclipBottom - Thread->Viewport->viewpoint.Pos.Z ? textop - texheight : m3DFloor.sclipBottom - Thread->Viewport->viewpoint.Pos.Z, &WallC);
|
||||
}
|
||||
else
|
||||
{
|
||||
walllower.Project(Thread->Viewport.get(), MAX(textop - texheight, bot), &WallC);
|
||||
double clipZ = m3DFloor.sclipBottom - Thread->Viewport->viewpoint.Pos.Z;
|
||||
floorZ = MAX(floorZ, clipZ);
|
||||
}
|
||||
|
||||
wallupper.Project(Thread->Viewport.get(), ceilZ, &WallC);
|
||||
walllower.Project(Thread->Viewport.get(), floorZ, &WallC);
|
||||
|
||||
for (int i = x1; i < x2; i++)
|
||||
{
|
||||
if (wallupper.ScreenY[i] < mceilingclip[i])
|
||||
|
|
|
@ -357,7 +357,8 @@ namespace swrenderer
|
|||
invertcolormap = !invertcolormap;
|
||||
}
|
||||
|
||||
bool fullbright = !foggy && pspr->GetState()->GetFullbright();
|
||||
const FState* const psprState = pspr->GetState();
|
||||
bool fullbright = !foggy && (psprState == nullptr ? false : psprState->GetFullbright());
|
||||
bool fadeToBlack = (vis.RenderStyle.Flags & STYLEF_FadeToBlack) != 0;
|
||||
|
||||
vis.Light.SetColormap(0, spriteshade, basecolormap, fullbright, invertcolormap, fadeToBlack);
|
||||
|
|
|
@ -1454,7 +1454,6 @@ bool IVideo::SetResolution (int width, int height, int bits)
|
|||
|
||||
CCMD (vid_setmode)
|
||||
{
|
||||
bool goodmode = false;
|
||||
int width = 0, height = SCREENHEIGHT;
|
||||
int bits = DisplayBits;
|
||||
|
||||
|
@ -1471,13 +1470,8 @@ CCMD (vid_setmode)
|
|||
}
|
||||
}
|
||||
|
||||
if (width && I_CheckResolution (width, height, bits))
|
||||
{
|
||||
goodmode = true;
|
||||
}
|
||||
|
||||
if (!fullscreen)
|
||||
goodmode = true;
|
||||
const bool goodmode = (width > 0 && height > 0)
|
||||
&& (!fullscreen || (Video != nullptr && I_CheckResolution(width, height, bits)));
|
||||
|
||||
if (goodmode)
|
||||
{
|
||||
|
|
|
@ -579,7 +579,6 @@ NERVETEXT =
|
|||
"\n"
|
||||
"THIS RIDE IS CLOSED.\n";
|
||||
|
||||
|
||||
// Cast list (must appear in this order)
|
||||
CC_ZOMBIE = "ZOMBIEMAN";
|
||||
CC_SHOTGUN = "SHOTGUN GUY";
|
||||
|
@ -1299,7 +1298,6 @@ TXT_IMITEMS = "ITEMS";
|
|||
TXT_IMSECRETS = "SECRETS";
|
||||
TXT_IMTIME = "TIME";
|
||||
|
||||
|
||||
RAVENQUITMSG = "ARE YOU SURE YOU WANT TO QUIT?";
|
||||
|
||||
// Hexen strings
|
||||
|
@ -1459,7 +1457,6 @@ TXT_MAULER = "You picked up the mauler.";
|
|||
TXT_GLAUNCHER = "You picked up the Grenade launcher.";
|
||||
TXT_SIGIL = "You picked up the SIGIL.";
|
||||
|
||||
|
||||
TXT_BASEKEY = "You picked up the Base Key.";
|
||||
TXT_GOVSKEY = "You picked up the Govs Key.";
|
||||
TXT_PASSCARD = "You picked up the Passcard.";
|
||||
|
@ -1567,6 +1564,7 @@ TXT_GOAWAY = "Go away!";
|
|||
TXT_COMM0 = "Incoming Message";
|
||||
TXT_COMM1 = "Incoming Message from BlackBird";
|
||||
|
||||
TXT_TRADE = " for %u";
|
||||
|
||||
AMMO_CLIP = "Bullets";
|
||||
AMMO_SHELLS = "Shotgun Shells";
|
||||
|
@ -2471,12 +2469,10 @@ OPTSTR_NOINTERPOLATION = "No interpolation";
|
|||
OPTSTR_SPLINE = "Spline";
|
||||
OPTSTR_OPENAL = "OpenAL";
|
||||
|
||||
|
||||
NOTSET = "Not set";
|
||||
SAFEMESSAGE = "Do you really want to do this?";
|
||||
MNU_COLORPICKER = "SELECT COLOR";
|
||||
|
||||
|
||||
WI_FINISHED = "finished";
|
||||
WI_ENTERING = "Now entering:";
|
||||
|
||||
|
@ -2852,7 +2848,6 @@ DSPLYMNU_TCOPT = "TrueColor Options";
|
|||
|
||||
TCMNU_TITLE = "TRUECOLOR OPTIONS";
|
||||
|
||||
|
||||
TCMNU_TRUECOLOR = "True color output";
|
||||
TCMNU_MINFILTER = "Linear filter when downscaling";
|
||||
TCMNU_MAGFILTER = "Linear filter when upscaling";
|
||||
|
|
|
@ -1646,6 +1646,8 @@ TXT_GOAWAY = "Allez-vous en!";
|
|||
TXT_COMM0 = "Message reçu.";
|
||||
TXT_COMM1 = "Message reçu de BlackBird";
|
||||
|
||||
TXT_TRADE = " pour %u";
|
||||
|
||||
AMMO_CLIP = "Balles";
|
||||
AMMO_SHELLS = "Cartouches";
|
||||
AMMO_ROCKETS = "Roquettes";
|
||||
|
|
|
@ -1145,7 +1145,7 @@ class Actor : Thinker native
|
|||
native bool A_CopySpriteFrame(int from, int to, int flags = 0);
|
||||
native bool A_SetVisibleRotation(double anglestart = 0, double angleend = 0, double pitchstart = 0, double pitchend = 0, int flags = 0, int ptr = AAPTR_DEFAULT);
|
||||
native void A_SetTranslation(name transname);
|
||||
native bool A_SetSize(double newradius, double newheight = -1, bool testpos = false);
|
||||
native bool A_SetSize(double newradius = -1, double newheight = -1, bool testpos = false);
|
||||
native void A_SprayDecal(String name, double dist = 172);
|
||||
native void A_SetMugshotState(String name);
|
||||
|
||||
|
|
|
@ -663,31 +663,31 @@ struct StringTable native
|
|||
// Most are handled at load time and are omitted here.
|
||||
struct DehInfo native
|
||||
{
|
||||
native int MaxSoulsphere;
|
||||
native uint8 ExplosionStyle;
|
||||
native double ExplosionAlpha;
|
||||
native int NoAutofreeze;
|
||||
native int BFGCells;
|
||||
native int BlueAC;
|
||||
native readonly int MaxSoulsphere;
|
||||
native readonly uint8 ExplosionStyle;
|
||||
native readonly double ExplosionAlpha;
|
||||
native readonly int NoAutofreeze;
|
||||
native readonly int BFGCells;
|
||||
native readonly int BlueAC;
|
||||
}
|
||||
|
||||
struct State native
|
||||
{
|
||||
native State NextState;
|
||||
native int sprite;
|
||||
native int16 Tics;
|
||||
native uint16 TicRange;
|
||||
native uint8 Frame;
|
||||
native uint8 UseFlags;
|
||||
native int Misc1;
|
||||
native int Misc2;
|
||||
native uint16 bSlow;
|
||||
native uint16 bFast;
|
||||
native bool bFullbright;
|
||||
native bool bNoDelay;
|
||||
native bool bSameFrame;
|
||||
native bool bCanRaise;
|
||||
native bool bDehacked;
|
||||
native readonly State NextState;
|
||||
native readonly int sprite;
|
||||
native readonly int16 Tics;
|
||||
native readonly uint16 TicRange;
|
||||
native readonly uint8 Frame;
|
||||
native readonly uint8 UseFlags;
|
||||
native readonly int Misc1;
|
||||
native readonly int Misc2;
|
||||
native readonly uint16 bSlow;
|
||||
native readonly uint16 bFast;
|
||||
native readonly bool bFullbright;
|
||||
native readonly bool bNoDelay;
|
||||
native readonly bool bSameFrame;
|
||||
native readonly bool bCanRaise;
|
||||
native readonly bool bDehacked;
|
||||
|
||||
native int DistanceTo(state other);
|
||||
native bool ValidateSpriteFrame();
|
||||
|
|
|
@ -1223,3 +1223,21 @@ enum ActorRenderFeatureFlag
|
|||
RFF_VOXELS = 1<<12, // renderer is capable of voxels
|
||||
};
|
||||
|
||||
// Special activation types
|
||||
enum SPAC
|
||||
{
|
||||
SPAC_Cross = 1<<0, // when player crosses line
|
||||
SPAC_Use = 1<<1, // when player uses line
|
||||
SPAC_MCross = 1<<2, // when monster crosses line
|
||||
SPAC_Impact = 1<<3, // when projectile hits line
|
||||
SPAC_Push = 1<<4, // when player pushes line
|
||||
SPAC_PCross = 1<<5, // when projectile crosses line
|
||||
SPAC_UseThrough = 1<<6, // when player uses line (doesn't block)
|
||||
// SPAC_PTOUCH is mapped to SPAC_PCross|SPAC_Impact
|
||||
SPAC_AnyCross = 1<<7, // when anything without the MF2_TELEPORT flag crosses the line
|
||||
SPAC_MUse = 1<<8, // monsters can use
|
||||
SPAC_MPush = 1<<9, // monsters can push
|
||||
SPAC_UseBack = 1<<10, // Can be used from the backside
|
||||
|
||||
SPAC_PlayerActivate = (SPAC_Cross|SPAC_Use|SPAC_Impact|SPAC_Push|SPAC_AnyCross|SPAC_UseThrough|SPAC_UseBack),
|
||||
};
|
||||
|
|
|
@ -35,8 +35,13 @@ class ArtiHealingRadius : Inventory
|
|||
|
||||
for (int i = 0; i < MAXPLAYERS; ++i)
|
||||
{
|
||||
if (!playeringame[i])
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
PlayerPawn mo = players[i].mo;
|
||||
if (playeringame[i] && mo != null && mo.health > 0 && mo.Distance2D (Owner) <= HEAL_RADIUS_DIST)
|
||||
if (mo != null && mo.health > 0 && mo.Distance2D (Owner) <= HEAL_RADIUS_DIST)
|
||||
{
|
||||
// Q: Is it worth it to make this selectable as a player property?
|
||||
// A: Probably not - but it sure doesn't hurt.
|
||||
|
|
|
@ -156,6 +156,8 @@ struct Line native play
|
|||
native Line getPortalDestination();
|
||||
native int getPortalAlignment();
|
||||
native int Index();
|
||||
native bool Activate(Actor activator, int side, int type);
|
||||
native bool RemoteActivate(Actor activator, int side, int type, Vector3 pos);
|
||||
|
||||
int GetUDMFInt(Name nm)
|
||||
{
|
||||
|
|
|
@ -137,7 +137,7 @@ class ConversationMenu : Menu
|
|||
mShowGold |= reply.NeedsGold;
|
||||
|
||||
let ReplyText = Stringtable.Localize(reply.Reply);
|
||||
if (reply.NeedsGold) ReplyText.AppendFormat(" for %u", reply.PrintAmount);
|
||||
if (reply.NeedsGold) ReplyText.AppendFormat(Stringtable.Localize("$TXT_TRADE"), reply.PrintAmount);
|
||||
|
||||
let ReplyLines = SmallFont.BreakLines (ReplyText, ReplyWidth);
|
||||
|
||||
|
|
|
@ -132,7 +132,8 @@ class LoadSaveMenu : ListMenu
|
|||
commentLeft = savepicLeft;
|
||||
commentTop = savepicTop + savepicHeight + 16;
|
||||
commentWidth = savepicWidth;
|
||||
commentHeight = (51+(screen.GetHeight()>200?10:0))*CleanYfac;
|
||||
//commentHeight = (51+(screen.GetHeight()>200?10:0))*CleanYfac;
|
||||
commentHeight = listboxHeight - savepicHeight - 16;
|
||||
commentRight = commentLeft + commentWidth;
|
||||
commentBottom = commentTop + commentHeight;
|
||||
}
|
||||
|
|
|
@ -66,13 +66,21 @@ class FastProjectile : Actor
|
|||
int count = 8;
|
||||
if (radius > 0)
|
||||
{
|
||||
while ( abs(Vel.X) >= radius * count || abs(Vel.Y) >= radius * count || abs(Vel.Z) >= height * count)
|
||||
while (abs(Vel.X) >= radius * count || abs(Vel.Y) >= radius * count)
|
||||
{
|
||||
// we need to take smaller steps.
|
||||
count += count;
|
||||
}
|
||||
}
|
||||
|
||||
if (height > 0)
|
||||
{
|
||||
while (abs(Vel.Z) >= height * count)
|
||||
{
|
||||
count += count;
|
||||
}
|
||||
}
|
||||
|
||||
// Handle movement
|
||||
if (Vel != (0, 0, 0) || (pos.Z != floorz))
|
||||
{
|
||||
|
|
|
@ -44,16 +44,16 @@ class RandomSpawner : Actor
|
|||
{
|
||||
while (di != null)
|
||||
{
|
||||
if (di.Name != 'None')
|
||||
bool shouldSkip = (di.Name == 'None') || (nomonsters && IsMonster(di));
|
||||
|
||||
if (!shouldSkip)
|
||||
{
|
||||
if (!nomonsters || !IsMonster(di))
|
||||
{
|
||||
int amt = di.Amount;
|
||||
if (amt < 0) amt = 1; // default value is -1, we need a positive value.
|
||||
n += amt; // this is how we can weight the list.
|
||||
}
|
||||
di = di.Next;
|
||||
int amt = di.Amount;
|
||||
if (amt < 0) amt = 1; // default value is -1, we need a positive value.
|
||||
n += amt; // this is how we can weight the list.
|
||||
}
|
||||
|
||||
di = di.Next;
|
||||
}
|
||||
if (n == 0)
|
||||
{ // Nothing left to spawn. They must have all been monsters, and monsters are disabled.
|
||||
|
|
|
@ -1,10 +1,53 @@
|
|||
|
||||
ChangeLog file for zlib
|
||||
|
||||
Changes in 1.2.11 (15 Jan 2017)
|
||||
- Fix deflate stored bug when pulling last block from window
|
||||
- Permit immediate deflateParams changes before any deflate input
|
||||
|
||||
Changes in 1.2.10 (2 Jan 2017)
|
||||
- Avoid warnings on snprintf() return value
|
||||
- Fix bug in deflate_stored() for zero-length input
|
||||
- Fix bug in gzwrite.c that produced corrupt gzip files
|
||||
- Remove files to be installed before copying them in Makefile.in
|
||||
- Add warnings when compiling with assembler code
|
||||
|
||||
Changes in 1.2.9 (31 Dec 2016)
|
||||
- Fix contrib/minizip to permit unzipping with desktop API [Zouzou]
|
||||
- Improve contrib/blast to return unused bytes
|
||||
- Assure that gzoffset() is correct when appending
|
||||
- Improve compress() and uncompress() to support large lengths
|
||||
- Fix bug in test/example.c where error code not saved
|
||||
- Remedy Coverity warning [Randers-Pehrson]
|
||||
- Improve speed of gzprintf() in transparent mode
|
||||
- Fix inflateInit2() bug when windowBits is 16 or 32
|
||||
- Change DEBUG macro to ZLIB_DEBUG
|
||||
- Avoid uninitialized access by gzclose_w()
|
||||
- Allow building zlib outside of the source directory
|
||||
- Fix bug that accepted invalid zlib header when windowBits is zero
|
||||
- Fix gzseek() problem on MinGW due to buggy _lseeki64 there
|
||||
- Loop on write() calls in gzwrite.c in case of non-blocking I/O
|
||||
- Add --warn (-w) option to ./configure for more compiler warnings
|
||||
- Reject a window size of 256 bytes if not using the zlib wrapper
|
||||
- Fix bug when level 0 used with Z_HUFFMAN or Z_RLE
|
||||
- Add --debug (-d) option to ./configure to define ZLIB_DEBUG
|
||||
- Fix bugs in creating a very large gzip header
|
||||
- Add uncompress2() function, which returns the input size used
|
||||
- Assure that deflateParams() will not switch functions mid-block
|
||||
- Dramatically speed up deflation for level 0 (storing)
|
||||
- Add gzfread(), duplicating the interface of fread()
|
||||
- Add gzfwrite(), duplicating the interface of fwrite()
|
||||
- Add deflateGetDictionary() function
|
||||
- Use snprintf() for later versions of Microsoft C
|
||||
- Fix *Init macros to use z_ prefix when requested
|
||||
- Replace as400 with os400 for OS/400 support [Monnerat]
|
||||
- Add crc32_z() and adler32_z() functions with size_t lengths
|
||||
- Update Visual Studio project files [AraHaan]
|
||||
|
||||
Changes in 1.2.8 (28 Apr 2013)
|
||||
- Update contrib/minizip/iowin32.c for Windows RT [Vollant]
|
||||
- Do not force Z_CONST for C++
|
||||
- Clean up contrib/vstudio [Ro§]
|
||||
- Clean up contrib/vstudio [Roß]
|
||||
- Correct spelling error in zlib.h
|
||||
- Fix mixed line endings in contrib/vstudio
|
||||
|
||||
|
@ -34,7 +77,7 @@ Changes in 1.2.7.1 (24 Mar 2013)
|
|||
- Clean up the usage of z_const and respect const usage within zlib
|
||||
- Clean up examples/gzlog.[ch] comparisons of different types
|
||||
- Avoid shift equal to bits in type (caused endless loop)
|
||||
- Fix unintialized value bug in gzputc() introduced by const patches
|
||||
- Fix uninitialized value bug in gzputc() introduced by const patches
|
||||
- Fix memory allocation error in examples/zran.c [Nor]
|
||||
- Fix bug where gzopen(), gzclose() would write an empty file
|
||||
- Fix bug in gzclose() when gzwrite() runs out of memory
|
||||
|
@ -194,7 +237,7 @@ Changes in 1.2.5.2 (17 Dec 2011)
|
|||
- Add a transparent write mode to gzopen() when 'T' is in the mode
|
||||
- Update python link in zlib man page
|
||||
- Get inffixed.h and MAKEFIXED result to match
|
||||
- Add a ./config --solo option to make zlib subset with no libary use
|
||||
- Add a ./config --solo option to make zlib subset with no library use
|
||||
- Add undocumented inflateResetKeep() function for CAB file decoding
|
||||
- Add --cover option to ./configure for gcc coverage testing
|
||||
- Add #define ZLIB_CONST option to use const in the z_stream interface
|
||||
|
@ -564,7 +607,7 @@ Changes in 1.2.3.1 (16 August 2006)
|
|||
- Update make_vms.com [Zinser]
|
||||
- Use -fPIC for shared build in configure [Teredesai, Nicholson]
|
||||
- Use only major version number for libz.so on IRIX and OSF1 [Reinholdtsen]
|
||||
- Use fdopen() (not _fdopen()) for Interix in zutil.h [BŠck]
|
||||
- Use fdopen() (not _fdopen()) for Interix in zutil.h [Bäck]
|
||||
- Add some FAQ entries about the contrib directory
|
||||
- Update the MVS question in the FAQ
|
||||
- Avoid extraneous reads after EOF in gzio.c [Brown]
|
||||
|
@ -1178,7 +1221,7 @@ Changes in 1.0.6 (19 Jan 1998)
|
|||
386 asm code replacing longest_match().
|
||||
contrib/iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
|
||||
A C++ I/O streams interface to the zlib gz* functions
|
||||
contrib/iostream2/ by Tyge Løvset <Tyge.Lovset@cmr.no>
|
||||
contrib/iostream2/ by Tyge Løvset <Tyge.Lovset@cmr.no>
|
||||
Another C++ I/O streams interface
|
||||
contrib/untgz/ by "Pedro A. Aranda Guti\irrez" <paag@tid.es>
|
||||
A very simple tar.gz file extractor using zlib
|
||||
|
@ -1267,7 +1310,7 @@ Changes in 1.0.1 (20 May 96) [1.0 skipped to avoid confusion]
|
|||
- fix array overlay in deflate.c which sometimes caused bad compressed data
|
||||
- fix inflate bug with empty stored block
|
||||
- fix MSDOS medium model which was broken in 0.99
|
||||
- fix deflateParams() which could generated bad compressed data.
|
||||
- fix deflateParams() which could generate bad compressed data.
|
||||
- Bytef is define'd instead of typedef'ed (work around Borland bug)
|
||||
- added an INDEX file
|
||||
- new makefiles for DJGPP (Makefile.dj2), 32-bit Borland (Makefile.b32),
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
ZLIB DATA COMPRESSION LIBRARY
|
||||
|
||||
zlib 1.2.8 is a general purpose data compression library. All the code is
|
||||
zlib 1.2.11 is a general purpose data compression library. All the code is
|
||||
thread safe. The data format used by the zlib library is described by RFCs
|
||||
(Request for Comments) 1950 to 1952 in the files
|
||||
http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and
|
||||
|
@ -31,7 +31,7 @@ Mark Nelson <markn@ieee.org> wrote an article about zlib for the Jan. 1997
|
|||
issue of Dr. Dobb's Journal; a copy of the article is available at
|
||||
http://marknelson.us/1997/01/01/zlib-engine/ .
|
||||
|
||||
The changes made in version 1.2.8 are documented in the file ChangeLog.
|
||||
The changes made in version 1.2.11 are documented in the file ChangeLog.
|
||||
|
||||
Unsupported third party contributions are provided in directory contrib/ .
|
||||
|
||||
|
@ -84,7 +84,7 @@ Acknowledgments:
|
|||
|
||||
Copyright notice:
|
||||
|
||||
(C) 1995-2013 Jean-loup Gailly and Mark Adler
|
||||
(C) 1995-2017 Jean-loup Gailly and Mark Adler
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/* adler32.c -- compute the Adler-32 checksum of a data stream
|
||||
* Copyright (C) 1995-2011 Mark Adler
|
||||
* Copyright (C) 1995-2011, 2016 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
|
@ -7,11 +7,9 @@
|
|||
|
||||
#include "zutil.h"
|
||||
|
||||
#define local static
|
||||
|
||||
local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
|
||||
|
||||
#define BASE 65521 /* largest prime smaller than 65536 */
|
||||
#define BASE 65521U /* largest prime smaller than 65536 */
|
||||
#define NMAX 5552
|
||||
/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
|
||||
|
||||
|
@ -62,10 +60,10 @@ local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
|
|||
#endif
|
||||
|
||||
/* ========================================================================= */
|
||||
uLong ZEXPORT adler32(adler, buf, len)
|
||||
uLong ZEXPORT adler32_z(adler, buf, len)
|
||||
uLong adler;
|
||||
const Bytef *buf;
|
||||
uInt len;
|
||||
z_size_t len;
|
||||
{
|
||||
unsigned long sum2;
|
||||
unsigned n;
|
||||
|
@ -132,6 +130,15 @@ uLong ZEXPORT adler32(adler, buf, len)
|
|||
return adler | (sum2 << 16);
|
||||
}
|
||||
|
||||
/* ========================================================================= */
|
||||
uLong ZEXPORT adler32(adler, buf, len)
|
||||
uLong adler;
|
||||
const Bytef *buf;
|
||||
uInt len;
|
||||
{
|
||||
return adler32_z(adler, buf, len);
|
||||
}
|
||||
|
||||
/* ========================================================================= */
|
||||
local uLong adler32_combine_(adler1, adler2, len2)
|
||||
uLong adler1;
|
||||
|
@ -156,7 +163,7 @@ local uLong adler32_combine_(adler1, adler2, len2)
|
|||
sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
|
||||
if (sum1 >= BASE) sum1 -= BASE;
|
||||
if (sum1 >= BASE) sum1 -= BASE;
|
||||
if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1);
|
||||
if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);
|
||||
if (sum2 >= BASE) sum2 -= BASE;
|
||||
return sum1 | (sum2 << 16);
|
||||
}
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/* compress.c -- compress a memory buffer
|
||||
* Copyright (C) 1995-2005 Jean-loup Gailly.
|
||||
* Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
|
@ -28,16 +28,11 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
|
|||
{
|
||||
z_stream stream;
|
||||
int err;
|
||||
const uInt max = (uInt)-1;
|
||||
uLong left;
|
||||
|
||||
stream.next_in = (z_const Bytef *)source;
|
||||
stream.avail_in = (uInt)sourceLen;
|
||||
#ifdef MAXSEG_64K
|
||||
/* Check for source > 64K on 16-bit machine: */
|
||||
if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
|
||||
#endif
|
||||
stream.next_out = dest;
|
||||
stream.avail_out = (uInt)*destLen;
|
||||
if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
|
||||
left = *destLen;
|
||||
*destLen = 0;
|
||||
|
||||
stream.zalloc = (alloc_func)0;
|
||||
stream.zfree = (free_func)0;
|
||||
|
@ -46,15 +41,26 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
|
|||
err = deflateInit(&stream, level);
|
||||
if (err != Z_OK) return err;
|
||||
|
||||
err = deflate(&stream, Z_FINISH);
|
||||
if (err != Z_STREAM_END) {
|
||||
deflateEnd(&stream);
|
||||
return err == Z_OK ? Z_BUF_ERROR : err;
|
||||
}
|
||||
*destLen = stream.total_out;
|
||||
stream.next_out = dest;
|
||||
stream.avail_out = 0;
|
||||
stream.next_in = (z_const Bytef *)source;
|
||||
stream.avail_in = 0;
|
||||
|
||||
err = deflateEnd(&stream);
|
||||
return err;
|
||||
do {
|
||||
if (stream.avail_out == 0) {
|
||||
stream.avail_out = left > (uLong)max ? max : (uInt)left;
|
||||
left -= stream.avail_out;
|
||||
}
|
||||
if (stream.avail_in == 0) {
|
||||
stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen;
|
||||
sourceLen -= stream.avail_in;
|
||||
}
|
||||
err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH);
|
||||
} while (err == Z_OK);
|
||||
|
||||
*destLen = stream.total_out;
|
||||
deflateEnd(&stream);
|
||||
return err == Z_STREAM_END ? Z_OK : err;
|
||||
}
|
||||
|
||||
/* ===========================================================================
|
||||
|
|
41
zlib/crc32.c
41
zlib/crc32.c
|
@ -1,5 +1,5 @@
|
|||
/* crc32.c -- compute the CRC-32 of a data stream
|
||||
* Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler
|
||||
* Copyright (C) 1995-2006, 2010, 2011, 2012, 2016 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*
|
||||
* Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
|
||||
|
@ -30,17 +30,15 @@
|
|||
|
||||
#include "zutil.h" /* for STDC and FAR definitions */
|
||||
|
||||
#define local static
|
||||
|
||||
/* Definitions for doing the crc four data bytes at a time. */
|
||||
#if !defined(NOBYFOUR) && defined(Z_U4)
|
||||
# define BYFOUR
|
||||
#endif
|
||||
#ifdef BYFOUR
|
||||
local unsigned long crc32_little OF((unsigned long,
|
||||
const unsigned char FAR *, unsigned));
|
||||
const unsigned char FAR *, z_size_t));
|
||||
local unsigned long crc32_big OF((unsigned long,
|
||||
const unsigned char FAR *, unsigned));
|
||||
const unsigned char FAR *, z_size_t));
|
||||
# define TBLS 8
|
||||
#else
|
||||
# define TBLS 1
|
||||
|
@ -201,10 +199,10 @@ const z_crc_t FAR * ZEXPORT get_crc_table()
|
|||
#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
|
||||
|
||||
/* ========================================================================= */
|
||||
unsigned long ZEXPORT crc32(crc, buf, len)
|
||||
unsigned long ZEXPORT crc32_z(crc, buf, len)
|
||||
unsigned long crc;
|
||||
const unsigned char FAR *buf;
|
||||
uInt len;
|
||||
z_size_t len;
|
||||
{
|
||||
if (buf == Z_NULL) return 0UL;
|
||||
|
||||
|
@ -235,8 +233,29 @@ unsigned long ZEXPORT crc32(crc, buf, len)
|
|||
return crc ^ 0xffffffffUL;
|
||||
}
|
||||
|
||||
/* ========================================================================= */
|
||||
unsigned long ZEXPORT crc32(crc, buf, len)
|
||||
unsigned long crc;
|
||||
const unsigned char FAR *buf;
|
||||
uInt len;
|
||||
{
|
||||
return crc32_z(crc, buf, len);
|
||||
}
|
||||
|
||||
#ifdef BYFOUR
|
||||
|
||||
/*
|
||||
This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit
|
||||
integer pointer type. This violates the strict aliasing rule, where a
|
||||
compiler can assume, for optimization purposes, that two pointers to
|
||||
fundamentally different types won't ever point to the same memory. This can
|
||||
manifest as a problem only if one of the pointers is written to. This code
|
||||
only reads from those pointers. So long as this code remains isolated in
|
||||
this compilation unit, there won't be a problem. For this reason, this code
|
||||
should not be copied and pasted into a compilation unit in which other code
|
||||
writes to the buffer that is passed to these routines.
|
||||
*/
|
||||
|
||||
/* ========================================================================= */
|
||||
#define DOLIT4 c ^= *buf4++; \
|
||||
c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
|
||||
|
@ -247,7 +266,7 @@ unsigned long ZEXPORT crc32(crc, buf, len)
|
|||
local unsigned long crc32_little(crc, buf, len)
|
||||
unsigned long crc;
|
||||
const unsigned char FAR *buf;
|
||||
unsigned len;
|
||||
z_size_t len;
|
||||
{
|
||||
register z_crc_t c;
|
||||
register const z_crc_t FAR *buf4;
|
||||
|
@ -278,7 +297,7 @@ local unsigned long crc32_little(crc, buf, len)
|
|||
}
|
||||
|
||||
/* ========================================================================= */
|
||||
#define DOBIG4 c ^= *++buf4; \
|
||||
#define DOBIG4 c ^= *buf4++; \
|
||||
c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
|
||||
crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
|
||||
#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
|
||||
|
@ -287,7 +306,7 @@ local unsigned long crc32_little(crc, buf, len)
|
|||
local unsigned long crc32_big(crc, buf, len)
|
||||
unsigned long crc;
|
||||
const unsigned char FAR *buf;
|
||||
unsigned len;
|
||||
z_size_t len;
|
||||
{
|
||||
register z_crc_t c;
|
||||
register const z_crc_t FAR *buf4;
|
||||
|
@ -300,7 +319,6 @@ local unsigned long crc32_big(crc, buf, len)
|
|||
}
|
||||
|
||||
buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
|
||||
buf4--;
|
||||
while (len >= 32) {
|
||||
DOBIG32;
|
||||
len -= 32;
|
||||
|
@ -309,7 +327,6 @@ local unsigned long crc32_big(crc, buf, len)
|
|||
DOBIG4;
|
||||
len -= 4;
|
||||
}
|
||||
buf4++;
|
||||
buf = (const unsigned char FAR *)buf4;
|
||||
|
||||
if (len) do {
|
||||
|
|
860
zlib/deflate.c
860
zlib/deflate.c
File diff suppressed because it is too large
Load diff
|
@ -1,5 +1,5 @@
|
|||
/* deflate.h -- internal compression state
|
||||
* Copyright (C) 1995-2012 Jean-loup Gailly
|
||||
* Copyright (C) 1995-2016 Jean-loup Gailly
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
|
@ -51,13 +51,16 @@
|
|||
#define Buf_size 16
|
||||
/* size of bit buffer in bi_buf */
|
||||
|
||||
#define INIT_STATE 42
|
||||
#define EXTRA_STATE 69
|
||||
#define NAME_STATE 73
|
||||
#define COMMENT_STATE 91
|
||||
#define HCRC_STATE 103
|
||||
#define BUSY_STATE 113
|
||||
#define FINISH_STATE 666
|
||||
#define INIT_STATE 42 /* zlib header -> BUSY_STATE */
|
||||
#ifdef GZIP
|
||||
# define GZIP_STATE 57 /* gzip header -> BUSY_STATE | EXTRA_STATE */
|
||||
#endif
|
||||
#define EXTRA_STATE 69 /* gzip extra block -> NAME_STATE */
|
||||
#define NAME_STATE 73 /* gzip file name -> COMMENT_STATE */
|
||||
#define COMMENT_STATE 91 /* gzip comment -> HCRC_STATE */
|
||||
#define HCRC_STATE 103 /* gzip header CRC -> BUSY_STATE */
|
||||
#define BUSY_STATE 113 /* deflate -> FINISH_STATE */
|
||||
#define FINISH_STATE 666 /* stream complete */
|
||||
/* Stream status */
|
||||
|
||||
|
||||
|
@ -83,7 +86,7 @@ typedef struct static_tree_desc_s static_tree_desc;
|
|||
typedef struct tree_desc_s {
|
||||
ct_data *dyn_tree; /* the dynamic tree */
|
||||
int max_code; /* largest code with non zero frequency */
|
||||
static_tree_desc *stat_desc; /* the corresponding static tree */
|
||||
const static_tree_desc *stat_desc; /* the corresponding static tree */
|
||||
} FAR tree_desc;
|
||||
|
||||
typedef ush Pos;
|
||||
|
@ -100,10 +103,10 @@ typedef struct internal_state {
|
|||
Bytef *pending_buf; /* output still pending */
|
||||
ulg pending_buf_size; /* size of pending_buf */
|
||||
Bytef *pending_out; /* next pending byte to output to the stream */
|
||||
uInt pending; /* nb of bytes in the pending buffer */
|
||||
ulg pending; /* nb of bytes in the pending buffer */
|
||||
int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
|
||||
gz_headerp gzhead; /* gzip header information to write */
|
||||
uInt gzindex; /* where in extra, name, or comment */
|
||||
ulg gzindex; /* where in extra, name, or comment */
|
||||
Byte method; /* can only be DEFLATED */
|
||||
int last_flush; /* value of flush param for previous deflate call */
|
||||
|
||||
|
@ -249,7 +252,7 @@ typedef struct internal_state {
|
|||
uInt matches; /* number of string matches in current block */
|
||||
uInt insert; /* bytes at end of window left to insert */
|
||||
|
||||
#ifdef DEBUG
|
||||
#ifdef ZLIB_DEBUG
|
||||
ulg compressed_len; /* total bit length of compressed file mod 2^32 */
|
||||
ulg bits_sent; /* bit length of compressed data sent mod 2^32 */
|
||||
#endif
|
||||
|
@ -275,7 +278,7 @@ typedef struct internal_state {
|
|||
/* Output a byte on the stream.
|
||||
* IN assertion: there is enough room in pending_buf.
|
||||
*/
|
||||
#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
|
||||
#define put_byte(s, c) {s->pending_buf[s->pending++] = (Bytef)(c);}
|
||||
|
||||
|
||||
#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
|
||||
|
@ -309,7 +312,7 @@ void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
|
|||
* used.
|
||||
*/
|
||||
|
||||
#ifndef DEBUG
|
||||
#ifndef ZLIB_DEBUG
|
||||
/* Inline versions of _tr_tally for speed: */
|
||||
|
||||
#if defined(GEN_TREES_H) || !defined(STDC)
|
||||
|
@ -328,8 +331,8 @@ void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
|
|||
flush = (s->last_lit == s->lit_bufsize-1); \
|
||||
}
|
||||
# define _tr_tally_dist(s, distance, length, flush) \
|
||||
{ uch len = (length); \
|
||||
ush dist = (distance); \
|
||||
{ uch len = (uch)(length); \
|
||||
ush dist = (ush)(distance); \
|
||||
s->d_buf[s->last_lit] = dist; \
|
||||
s->l_buf[s->last_lit++] = len; \
|
||||
dist--; \
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/* gzguts.h -- zlib internal header definitions for gz* operations
|
||||
* Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
|
||||
* Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
|
@ -25,6 +25,10 @@
|
|||
# include <stdlib.h>
|
||||
# include <limits.h>
|
||||
#endif
|
||||
|
||||
#ifndef _POSIX_SOURCE
|
||||
# define _POSIX_SOURCE
|
||||
#endif
|
||||
#include <fcntl.h>
|
||||
|
||||
#ifdef _WIN32
|
||||
|
@ -35,6 +39,10 @@
|
|||
# include <io.h>
|
||||
#endif
|
||||
|
||||
#if defined(_WIN32) || defined(__CYGWIN__)
|
||||
# define WIDECHAR
|
||||
#endif
|
||||
|
||||
#ifdef WINAPI_FAMILY
|
||||
# define open _open
|
||||
# define read _read
|
||||
|
@ -95,18 +103,19 @@
|
|||
# endif
|
||||
#endif
|
||||
|
||||
/* unlike snprintf (which is required in C99, yet still not supported by
|
||||
Microsoft more than a decade later!), _snprintf does not guarantee null
|
||||
termination of the result -- however this is only used in gzlib.c where
|
||||
/* unlike snprintf (which is required in C99), _snprintf does not guarantee
|
||||
null termination of the result -- however this is only used in gzlib.c where
|
||||
the result is assured to fit in the space provided */
|
||||
#ifdef _MSC_VER
|
||||
#if defined(_MSC_VER) && _MSC_VER < 1900
|
||||
# define snprintf _snprintf
|
||||
#endif
|
||||
|
||||
#ifndef local
|
||||
# define local static
|
||||
#endif
|
||||
/* compile with -Dlocal if your debugger can't find static symbols */
|
||||
/* since "static" is used to mean two completely different things in C, we
|
||||
define "local" for the non-static meaning of "static", for readability
|
||||
(compile with -Dlocal if your debugger can't find static symbols) */
|
||||
|
||||
/* gz* functions always use library allocation functions */
|
||||
#ifndef STDC
|
||||
|
@ -170,7 +179,7 @@ typedef struct {
|
|||
char *path; /* path or fd for error messages */
|
||||
unsigned size; /* buffer size, zero if not allocated yet */
|
||||
unsigned want; /* requested buffer size, default is GZBUFSIZE */
|
||||
unsigned char *in; /* input buffer */
|
||||
unsigned char *in; /* input buffer (double-sized when writing) */
|
||||
unsigned char *out; /* output buffer (double-sized when reading) */
|
||||
int direct; /* 0 if processing gzip, 1 if transparent */
|
||||
/* just for reading */
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/* infback.c -- inflate using a call-back interface
|
||||
* Copyright (C) 1995-2011 Mark Adler
|
||||
* Copyright (C) 1995-2016 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
|
@ -61,7 +61,7 @@ int stream_size;
|
|||
Tracev((stderr, "inflate: allocated\n"));
|
||||
strm->state = (struct internal_state FAR *)state;
|
||||
state->dmax = 32768U;
|
||||
state->wbits = windowBits;
|
||||
state->wbits = (uInt)windowBits;
|
||||
state->wsize = 1U << windowBits;
|
||||
state->window = window;
|
||||
state->wnext = 0;
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/* inffast.c -- fast decoding
|
||||
* Copyright (C) 1995-2008, 2010, 2013 Mark Adler
|
||||
* Copyright (C) 1995-2017 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
|
@ -8,26 +8,9 @@
|
|||
#include "inflate.h"
|
||||
#include "inffast.h"
|
||||
|
||||
#ifndef ASMINF
|
||||
|
||||
/* Allow machine dependent optimization for post-increment or pre-increment.
|
||||
Based on testing to date,
|
||||
Pre-increment preferred for:
|
||||
- PowerPC G3 (Adler)
|
||||
- MIPS R5000 (Randers-Pehrson)
|
||||
Post-increment preferred for:
|
||||
- none
|
||||
No measurable difference:
|
||||
- Pentium III (Anderson)
|
||||
- M68060 (Nikl)
|
||||
*/
|
||||
#ifdef POSTINC
|
||||
# define OFF 0
|
||||
# define PUP(a) *(a)++
|
||||
#ifdef ASMINF
|
||||
# pragma message("Assembler code may have bugs -- use at your own risk")
|
||||
#else
|
||||
# define OFF 1
|
||||
# define PUP(a) *++(a)
|
||||
#endif
|
||||
|
||||
/*
|
||||
Decode literal, length, and distance codes and write out the resulting
|
||||
|
@ -96,9 +79,9 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
|||
|
||||
/* copy state to local variables */
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
in = strm->next_in - OFF;
|
||||
in = strm->next_in;
|
||||
last = in + (strm->avail_in - 5);
|
||||
out = strm->next_out - OFF;
|
||||
out = strm->next_out;
|
||||
beg = out - (start - strm->avail_out);
|
||||
end = out + (strm->avail_out - 257);
|
||||
#ifdef INFLATE_STRICT
|
||||
|
@ -119,9 +102,9 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
|||
input data or output space */
|
||||
do {
|
||||
if (bits < 15) {
|
||||
hold += (unsigned long)(PUP(in)) << bits;
|
||||
hold += (unsigned long)(*in++) << bits;
|
||||
bits += 8;
|
||||
hold += (unsigned long)(PUP(in)) << bits;
|
||||
hold += (unsigned long)(*in++) << bits;
|
||||
bits += 8;
|
||||
}
|
||||
here = lcode[hold & lmask];
|
||||
|
@ -134,14 +117,14 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
|||
Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
|
||||
"inflate: literal '%c'\n" :
|
||||
"inflate: literal 0x%02x\n", here.val));
|
||||
PUP(out) = (unsigned char)(here.val);
|
||||
*out++ = (unsigned char)(here.val);
|
||||
}
|
||||
else if (op & 16) { /* length base */
|
||||
len = (unsigned)(here.val);
|
||||
op &= 15; /* number of extra bits */
|
||||
if (op) {
|
||||
if (bits < op) {
|
||||
hold += (unsigned long)(PUP(in)) << bits;
|
||||
hold += (unsigned long)(*in++) << bits;
|
||||
bits += 8;
|
||||
}
|
||||
len += (unsigned)hold & ((1U << op) - 1);
|
||||
|
@ -150,9 +133,9 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
|||
}
|
||||
Tracevv((stderr, "inflate: length %u\n", len));
|
||||
if (bits < 15) {
|
||||
hold += (unsigned long)(PUP(in)) << bits;
|
||||
hold += (unsigned long)(*in++) << bits;
|
||||
bits += 8;
|
||||
hold += (unsigned long)(PUP(in)) << bits;
|
||||
hold += (unsigned long)(*in++) << bits;
|
||||
bits += 8;
|
||||
}
|
||||
here = dcode[hold & dmask];
|
||||
|
@ -165,10 +148,10 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
|||
dist = (unsigned)(here.val);
|
||||
op &= 15; /* number of extra bits */
|
||||
if (bits < op) {
|
||||
hold += (unsigned long)(PUP(in)) << bits;
|
||||
hold += (unsigned long)(*in++) << bits;
|
||||
bits += 8;
|
||||
if (bits < op) {
|
||||
hold += (unsigned long)(PUP(in)) << bits;
|
||||
hold += (unsigned long)(*in++) << bits;
|
||||
bits += 8;
|
||||
}
|
||||
}
|
||||
|
@ -196,30 +179,30 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
|||
#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
|
||||
if (len <= op - whave) {
|
||||
do {
|
||||
PUP(out) = 0;
|
||||
*out++ = 0;
|
||||
} while (--len);
|
||||
continue;
|
||||
}
|
||||
len -= op - whave;
|
||||
do {
|
||||
PUP(out) = 0;
|
||||
*out++ = 0;
|
||||
} while (--op > whave);
|
||||
if (op == 0) {
|
||||
from = out - dist;
|
||||
do {
|
||||
PUP(out) = PUP(from);
|
||||
*out++ = *from++;
|
||||
} while (--len);
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
from = window - OFF;
|
||||
from = window;
|
||||
if (wnext == 0) { /* very common case */
|
||||
from += wsize - op;
|
||||
if (op < len) { /* some from window */
|
||||
len -= op;
|
||||
do {
|
||||
PUP(out) = PUP(from);
|
||||
*out++ = *from++;
|
||||
} while (--op);
|
||||
from = out - dist; /* rest from output */
|
||||
}
|
||||
|
@ -230,14 +213,14 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
|||
if (op < len) { /* some from end of window */
|
||||
len -= op;
|
||||
do {
|
||||
PUP(out) = PUP(from);
|
||||
*out++ = *from++;
|
||||
} while (--op);
|
||||
from = window - OFF;
|
||||
from = window;
|
||||
if (wnext < len) { /* some from start of window */
|
||||
op = wnext;
|
||||
len -= op;
|
||||
do {
|
||||
PUP(out) = PUP(from);
|
||||
*out++ = *from++;
|
||||
} while (--op);
|
||||
from = out - dist; /* rest from output */
|
||||
}
|
||||
|
@ -248,35 +231,35 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
|||
if (op < len) { /* some from window */
|
||||
len -= op;
|
||||
do {
|
||||
PUP(out) = PUP(from);
|
||||
*out++ = *from++;
|
||||
} while (--op);
|
||||
from = out - dist; /* rest from output */
|
||||
}
|
||||
}
|
||||
while (len > 2) {
|
||||
PUP(out) = PUP(from);
|
||||
PUP(out) = PUP(from);
|
||||
PUP(out) = PUP(from);
|
||||
*out++ = *from++;
|
||||
*out++ = *from++;
|
||||
*out++ = *from++;
|
||||
len -= 3;
|
||||
}
|
||||
if (len) {
|
||||
PUP(out) = PUP(from);
|
||||
*out++ = *from++;
|
||||
if (len > 1)
|
||||
PUP(out) = PUP(from);
|
||||
*out++ = *from++;
|
||||
}
|
||||
}
|
||||
else {
|
||||
from = out - dist; /* copy direct from output */
|
||||
do { /* minimum length is three */
|
||||
PUP(out) = PUP(from);
|
||||
PUP(out) = PUP(from);
|
||||
PUP(out) = PUP(from);
|
||||
*out++ = *from++;
|
||||
*out++ = *from++;
|
||||
*out++ = *from++;
|
||||
len -= 3;
|
||||
} while (len > 2);
|
||||
if (len) {
|
||||
PUP(out) = PUP(from);
|
||||
*out++ = *from++;
|
||||
if (len > 1)
|
||||
PUP(out) = PUP(from);
|
||||
*out++ = *from++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -313,8 +296,8 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
|||
hold &= (1U << bits) - 1;
|
||||
|
||||
/* update state and return */
|
||||
strm->next_in = in + OFF;
|
||||
strm->next_out = out + OFF;
|
||||
strm->next_in = in;
|
||||
strm->next_out = out;
|
||||
strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
|
||||
strm->avail_out = (unsigned)(out < end ?
|
||||
257 + (end - out) : 257 - (out - end));
|
||||
|
|
123
zlib/inflate.c
123
zlib/inflate.c
|
@ -1,5 +1,5 @@
|
|||
/* inflate.c -- zlib decompression
|
||||
* Copyright (C) 1995-2012 Mark Adler
|
||||
* Copyright (C) 1995-2016 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
|
@ -92,6 +92,7 @@
|
|||
#endif
|
||||
|
||||
/* function prototypes */
|
||||
local int inflateStateCheck OF((z_streamp strm));
|
||||
local void fixedtables OF((struct inflate_state FAR *state));
|
||||
local int updatewindow OF((z_streamp strm, const unsigned char FAR *end,
|
||||
unsigned copy));
|
||||
|
@ -101,12 +102,26 @@ local int updatewindow OF((z_streamp strm, const unsigned char FAR *end,
|
|||
local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf,
|
||||
unsigned len));
|
||||
|
||||
local int inflateStateCheck(strm)
|
||||
z_streamp strm;
|
||||
{
|
||||
struct inflate_state FAR *state;
|
||||
if (strm == Z_NULL ||
|
||||
strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
|
||||
return 1;
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
if (state == Z_NULL || state->strm != strm ||
|
||||
state->mode < HEAD || state->mode > SYNC)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ZEXPORT inflateResetKeep(strm)
|
||||
z_streamp strm;
|
||||
{
|
||||
struct inflate_state FAR *state;
|
||||
|
||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
||||
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
strm->total_in = strm->total_out = state->total = 0;
|
||||
strm->msg = Z_NULL;
|
||||
|
@ -131,7 +146,7 @@ z_streamp strm;
|
|||
{
|
||||
struct inflate_state FAR *state;
|
||||
|
||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
||||
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
state->wsize = 0;
|
||||
state->whave = 0;
|
||||
|
@ -147,7 +162,7 @@ int windowBits;
|
|||
struct inflate_state FAR *state;
|
||||
|
||||
/* get the state */
|
||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
||||
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
|
||||
/* extract wrap request from windowBits parameter */
|
||||
|
@ -156,7 +171,7 @@ int windowBits;
|
|||
windowBits = -windowBits;
|
||||
}
|
||||
else {
|
||||
wrap = (windowBits >> 4) + 1;
|
||||
wrap = (windowBits >> 4) + 5;
|
||||
#ifdef GUNZIP
|
||||
if (windowBits < 48)
|
||||
windowBits &= 15;
|
||||
|
@ -210,7 +225,9 @@ int stream_size;
|
|||
if (state == Z_NULL) return Z_MEM_ERROR;
|
||||
Tracev((stderr, "inflate: allocated\n"));
|
||||
strm->state = (struct internal_state FAR *)state;
|
||||
state->strm = strm;
|
||||
state->window = Z_NULL;
|
||||
state->mode = HEAD; /* to pass state test in inflateReset2() */
|
||||
ret = inflateReset2(strm, windowBits);
|
||||
if (ret != Z_OK) {
|
||||
ZFREE(strm, state);
|
||||
|
@ -234,17 +251,17 @@ int value;
|
|||
{
|
||||
struct inflate_state FAR *state;
|
||||
|
||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
||||
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
if (bits < 0) {
|
||||
state->hold = 0;
|
||||
state->bits = 0;
|
||||
return Z_OK;
|
||||
}
|
||||
if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
|
||||
if (bits > 16 || state->bits + (uInt)bits > 32) return Z_STREAM_ERROR;
|
||||
value &= (1L << bits) - 1;
|
||||
state->hold += value << state->bits;
|
||||
state->bits += bits;
|
||||
state->hold += (unsigned)value << state->bits;
|
||||
state->bits += (uInt)bits;
|
||||
return Z_OK;
|
||||
}
|
||||
|
||||
|
@ -625,7 +642,7 @@ int flush;
|
|||
static const unsigned short order[19] = /* permutation of code lengths */
|
||||
{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
|
||||
|
||||
if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
|
||||
if (inflateStateCheck(strm) || strm->next_out == Z_NULL ||
|
||||
(strm->next_in == Z_NULL && strm->avail_in != 0))
|
||||
return Z_STREAM_ERROR;
|
||||
|
||||
|
@ -645,6 +662,8 @@ int flush;
|
|||
NEEDBITS(16);
|
||||
#ifdef GUNZIP
|
||||
if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
|
||||
if (state->wbits == 0)
|
||||
state->wbits = 15;
|
||||
state->check = crc32(0L, Z_NULL, 0);
|
||||
CRC2(state->check, hold);
|
||||
INITBITS();
|
||||
|
@ -672,7 +691,7 @@ int flush;
|
|||
len = BITS(4) + 8;
|
||||
if (state->wbits == 0)
|
||||
state->wbits = len;
|
||||
else if (len > state->wbits) {
|
||||
if (len > 15 || len > state->wbits) {
|
||||
strm->msg = (char *)"invalid window size";
|
||||
state->mode = BAD;
|
||||
break;
|
||||
|
@ -699,14 +718,16 @@ int flush;
|
|||
}
|
||||
if (state->head != Z_NULL)
|
||||
state->head->text = (int)((hold >> 8) & 1);
|
||||
if (state->flags & 0x0200) CRC2(state->check, hold);
|
||||
if ((state->flags & 0x0200) && (state->wrap & 4))
|
||||
CRC2(state->check, hold);
|
||||
INITBITS();
|
||||
state->mode = TIME;
|
||||
case TIME:
|
||||
NEEDBITS(32);
|
||||
if (state->head != Z_NULL)
|
||||
state->head->time = hold;
|
||||
if (state->flags & 0x0200) CRC4(state->check, hold);
|
||||
if ((state->flags & 0x0200) && (state->wrap & 4))
|
||||
CRC4(state->check, hold);
|
||||
INITBITS();
|
||||
state->mode = OS;
|
||||
case OS:
|
||||
|
@ -715,7 +736,8 @@ int flush;
|
|||
state->head->xflags = (int)(hold & 0xff);
|
||||
state->head->os = (int)(hold >> 8);
|
||||
}
|
||||
if (state->flags & 0x0200) CRC2(state->check, hold);
|
||||
if ((state->flags & 0x0200) && (state->wrap & 4))
|
||||
CRC2(state->check, hold);
|
||||
INITBITS();
|
||||
state->mode = EXLEN;
|
||||
case EXLEN:
|
||||
|
@ -724,7 +746,8 @@ int flush;
|
|||
state->length = (unsigned)(hold);
|
||||
if (state->head != Z_NULL)
|
||||
state->head->extra_len = (unsigned)hold;
|
||||
if (state->flags & 0x0200) CRC2(state->check, hold);
|
||||
if ((state->flags & 0x0200) && (state->wrap & 4))
|
||||
CRC2(state->check, hold);
|
||||
INITBITS();
|
||||
}
|
||||
else if (state->head != Z_NULL)
|
||||
|
@ -742,7 +765,7 @@ int flush;
|
|||
len + copy > state->head->extra_max ?
|
||||
state->head->extra_max - len : copy);
|
||||
}
|
||||
if (state->flags & 0x0200)
|
||||
if ((state->flags & 0x0200) && (state->wrap & 4))
|
||||
state->check = crc32(state->check, next, copy);
|
||||
have -= copy;
|
||||
next += copy;
|
||||
|
@ -761,9 +784,9 @@ int flush;
|
|||
if (state->head != Z_NULL &&
|
||||
state->head->name != Z_NULL &&
|
||||
state->length < state->head->name_max)
|
||||
state->head->name[state->length++] = len;
|
||||
state->head->name[state->length++] = (Bytef)len;
|
||||
} while (len && copy < have);
|
||||
if (state->flags & 0x0200)
|
||||
if ((state->flags & 0x0200) && (state->wrap & 4))
|
||||
state->check = crc32(state->check, next, copy);
|
||||
have -= copy;
|
||||
next += copy;
|
||||
|
@ -782,9 +805,9 @@ int flush;
|
|||
if (state->head != Z_NULL &&
|
||||
state->head->comment != Z_NULL &&
|
||||
state->length < state->head->comm_max)
|
||||
state->head->comment[state->length++] = len;
|
||||
state->head->comment[state->length++] = (Bytef)len;
|
||||
} while (len && copy < have);
|
||||
if (state->flags & 0x0200)
|
||||
if ((state->flags & 0x0200) && (state->wrap & 4))
|
||||
state->check = crc32(state->check, next, copy);
|
||||
have -= copy;
|
||||
next += copy;
|
||||
|
@ -796,7 +819,7 @@ int flush;
|
|||
case HCRC:
|
||||
if (state->flags & 0x0200) {
|
||||
NEEDBITS(16);
|
||||
if (hold != (state->check & 0xffff)) {
|
||||
if ((state->wrap & 4) && hold != (state->check & 0xffff)) {
|
||||
strm->msg = (char *)"header crc mismatch";
|
||||
state->mode = BAD;
|
||||
break;
|
||||
|
@ -1177,11 +1200,11 @@ int flush;
|
|||
out -= left;
|
||||
strm->total_out += out;
|
||||
state->total += out;
|
||||
if (out)
|
||||
if ((state->wrap & 4) && out)
|
||||
strm->adler = state->check =
|
||||
UPDATE(state->check, put - out, out);
|
||||
out = left;
|
||||
if ((
|
||||
if ((state->wrap & 4) && (
|
||||
#ifdef GUNZIP
|
||||
state->flags ? hold :
|
||||
#endif
|
||||
|
@ -1240,10 +1263,10 @@ int flush;
|
|||
strm->total_in += in;
|
||||
strm->total_out += out;
|
||||
state->total += out;
|
||||
if (state->wrap && out)
|
||||
if ((state->wrap & 4) && out)
|
||||
strm->adler = state->check =
|
||||
UPDATE(state->check, strm->next_out - out, out);
|
||||
strm->data_type = state->bits + (state->last ? 64 : 0) +
|
||||
strm->data_type = (int)state->bits + (state->last ? 64 : 0) +
|
||||
(state->mode == TYPE ? 128 : 0) +
|
||||
(state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
|
||||
if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
|
||||
|
@ -1255,7 +1278,7 @@ int ZEXPORT inflateEnd(strm)
|
|||
z_streamp strm;
|
||||
{
|
||||
struct inflate_state FAR *state;
|
||||
if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
|
||||
if (inflateStateCheck(strm))
|
||||
return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
if (state->window != Z_NULL) ZFREE(strm, state->window);
|
||||
|
@ -1273,7 +1296,7 @@ uInt *dictLength;
|
|||
struct inflate_state FAR *state;
|
||||
|
||||
/* check state */
|
||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
||||
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
|
||||
/* copy dictionary */
|
||||
|
@ -1298,7 +1321,7 @@ uInt dictLength;
|
|||
int ret;
|
||||
|
||||
/* check state */
|
||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
||||
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
if (state->wrap != 0 && state->mode != DICT)
|
||||
return Z_STREAM_ERROR;
|
||||
|
@ -1330,7 +1353,7 @@ gz_headerp head;
|
|||
struct inflate_state FAR *state;
|
||||
|
||||
/* check state */
|
||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
||||
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
|
||||
|
||||
|
@ -1383,7 +1406,7 @@ z_streamp strm;
|
|||
struct inflate_state FAR *state;
|
||||
|
||||
/* check parameters */
|
||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
||||
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
|
||||
|
||||
|
@ -1430,7 +1453,7 @@ z_streamp strm;
|
|||
{
|
||||
struct inflate_state FAR *state;
|
||||
|
||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
||||
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
return state->mode == STORED && state->bits == 0;
|
||||
}
|
||||
|
@ -1445,8 +1468,7 @@ z_streamp source;
|
|||
unsigned wsize;
|
||||
|
||||
/* check input */
|
||||
if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
|
||||
source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
|
||||
if (inflateStateCheck(source) || dest == Z_NULL)
|
||||
return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state FAR *)source->state;
|
||||
|
||||
|
@ -1467,6 +1489,7 @@ z_streamp source;
|
|||
/* copy state */
|
||||
zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
|
||||
zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state));
|
||||
copy->strm = dest;
|
||||
if (state->lencode >= state->codes &&
|
||||
state->lencode <= state->codes + ENOUGH - 1) {
|
||||
copy->lencode = copy->codes + (state->lencode - state->codes);
|
||||
|
@ -1488,25 +1511,51 @@ int subvert;
|
|||
{
|
||||
struct inflate_state FAR *state;
|
||||
|
||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
||||
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
state->sane = !subvert;
|
||||
#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
|
||||
state->sane = !subvert;
|
||||
return Z_OK;
|
||||
#else
|
||||
(void)subvert;
|
||||
state->sane = 1;
|
||||
return Z_DATA_ERROR;
|
||||
#endif
|
||||
}
|
||||
|
||||
int ZEXPORT inflateValidate(strm, check)
|
||||
z_streamp strm;
|
||||
int check;
|
||||
{
|
||||
struct inflate_state FAR *state;
|
||||
|
||||
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
if (check)
|
||||
state->wrap |= 4;
|
||||
else
|
||||
state->wrap &= ~4;
|
||||
return Z_OK;
|
||||
}
|
||||
|
||||
long ZEXPORT inflateMark(strm)
|
||||
z_streamp strm;
|
||||
{
|
||||
struct inflate_state FAR *state;
|
||||
|
||||
if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16;
|
||||
if (inflateStateCheck(strm))
|
||||
return -(1L << 16);
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
return ((long)(state->back) << 16) +
|
||||
return (long)(((unsigned long)((long)state->back)) << 16) +
|
||||
(state->mode == COPY ? state->length :
|
||||
(state->mode == MATCH ? state->was - state->length : 0));
|
||||
}
|
||||
|
||||
unsigned long ZEXPORT inflateCodesUsed(strm)
|
||||
z_streamp strm;
|
||||
{
|
||||
struct inflate_state FAR *state;
|
||||
if (inflateStateCheck(strm)) return (unsigned long)-1;
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
return (unsigned long)(state->next - state->codes);
|
||||
}
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/* inflate.h -- internal inflate state definition
|
||||
* Copyright (C) 1995-2009 Mark Adler
|
||||
* Copyright (C) 1995-2016 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
|
@ -18,7 +18,7 @@
|
|||
|
||||
/* Possible inflate modes between inflate() calls */
|
||||
typedef enum {
|
||||
HEAD, /* i: waiting for magic header */
|
||||
HEAD = 16180, /* i: waiting for magic header */
|
||||
FLAGS, /* i: waiting for method and flags (gzip) */
|
||||
TIME, /* i: waiting for modification time (gzip) */
|
||||
OS, /* i: waiting for extra flags and operating system (gzip) */
|
||||
|
@ -77,11 +77,14 @@ typedef enum {
|
|||
CHECK -> LENGTH -> DONE
|
||||
*/
|
||||
|
||||
/* state maintained between inflate() calls. Approximately 10K bytes. */
|
||||
/* State maintained between inflate() calls -- approximately 7K bytes, not
|
||||
including the allocated sliding window, which is up to 32K bytes. */
|
||||
struct inflate_state {
|
||||
z_streamp strm; /* pointer back to this zlib stream */
|
||||
inflate_mode mode; /* current inflate mode */
|
||||
int last; /* true if processing last block */
|
||||
int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
|
||||
int wrap; /* bit 0 true for zlib, bit 1 true for gzip,
|
||||
bit 2 true to validate check value */
|
||||
int havedict; /* true if dictionary provided */
|
||||
int flags; /* gzip header method and flags (0 if zlib) */
|
||||
unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/* inftrees.c -- generate Huffman trees for efficient decoding
|
||||
* Copyright (C) 1995-2013 Mark Adler
|
||||
* Copyright (C) 1995-2017 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
|
@ -9,7 +9,7 @@
|
|||
#define MAXBITS 15
|
||||
|
||||
const char inflate_copyright[] =
|
||||
" inflate 1.2.8 Copyright 1995-2013 Mark Adler ";
|
||||
" inflate 1.2.11 Copyright 1995-2017 Mark Adler ";
|
||||
/*
|
||||
If you use the zlib library in a product, an acknowledgment is welcome
|
||||
in the documentation of your product. If for some reason you cannot
|
||||
|
@ -54,7 +54,7 @@ unsigned short FAR *work;
|
|||
code FAR *next; /* next available space in table */
|
||||
const unsigned short FAR *base; /* base value table to use */
|
||||
const unsigned short FAR *extra; /* extra bits table to use */
|
||||
int end; /* use base and extra for symbol > end */
|
||||
unsigned match; /* use base and extra for symbol >= match */
|
||||
unsigned short count[MAXBITS+1]; /* number of codes of each length */
|
||||
unsigned short offs[MAXBITS+1]; /* offsets in table for each length */
|
||||
static const unsigned short lbase[31] = { /* Length codes 257..285 base */
|
||||
|
@ -62,7 +62,7 @@ unsigned short FAR *work;
|
|||
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
|
||||
static const unsigned short lext[31] = { /* Length codes 257..285 extra */
|
||||
16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
|
||||
19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78};
|
||||
19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 77, 202};
|
||||
static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
|
||||
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
|
||||
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
|
||||
|
@ -181,19 +181,17 @@ unsigned short FAR *work;
|
|||
switch (type) {
|
||||
case CODES:
|
||||
base = extra = work; /* dummy value--not used */
|
||||
end = 19;
|
||||
match = 20;
|
||||
break;
|
||||
case LENS:
|
||||
base = lbase;
|
||||
base -= 257;
|
||||
extra = lext;
|
||||
extra -= 257;
|
||||
end = 256;
|
||||
match = 257;
|
||||
break;
|
||||
default: /* DISTS */
|
||||
default: /* DISTS */
|
||||
base = dbase;
|
||||
extra = dext;
|
||||
end = -1;
|
||||
match = 0;
|
||||
}
|
||||
|
||||
/* initialize state for loop */
|
||||
|
@ -216,13 +214,13 @@ unsigned short FAR *work;
|
|||
for (;;) {
|
||||
/* create table entry */
|
||||
here.bits = (unsigned char)(len - drop);
|
||||
if ((int)(work[sym]) < end) {
|
||||
if (work[sym] + 1U < match) {
|
||||
here.op = (unsigned char)0;
|
||||
here.val = work[sym];
|
||||
}
|
||||
else if ((int)(work[sym]) > end) {
|
||||
here.op = (unsigned char)(extra[work[sym]]);
|
||||
here.val = base[work[sym]];
|
||||
else if (work[sym] >= match) {
|
||||
here.op = (unsigned char)(extra[work[sym] - match]);
|
||||
here.val = base[work[sym] - match];
|
||||
}
|
||||
else {
|
||||
here.op = (unsigned char)(32 + 64); /* end of block */
|
||||
|
|
99
zlib/trees.c
99
zlib/trees.c
|
@ -1,5 +1,5 @@
|
|||
/* trees.c -- output deflated data using Huffman coding
|
||||
* Copyright (C) 1995-2012 Jean-loup Gailly
|
||||
* Copyright (C) 1995-2017 Jean-loup Gailly
|
||||
* detect_data_type() function provided freely by Cosmin Truta, 2006
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
@ -36,7 +36,7 @@
|
|||
|
||||
#include "deflate.h"
|
||||
|
||||
#ifdef DEBUG
|
||||
#ifdef ZLIB_DEBUG
|
||||
# include <ctype.h>
|
||||
#endif
|
||||
|
||||
|
@ -122,13 +122,13 @@ struct static_tree_desc_s {
|
|||
int max_length; /* max bit length for the codes */
|
||||
};
|
||||
|
||||
local static_tree_desc static_l_desc =
|
||||
local const static_tree_desc static_l_desc =
|
||||
{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
|
||||
|
||||
local static_tree_desc static_d_desc =
|
||||
local const static_tree_desc static_d_desc =
|
||||
{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS};
|
||||
|
||||
local static_tree_desc static_bl_desc =
|
||||
local const static_tree_desc static_bl_desc =
|
||||
{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS};
|
||||
|
||||
/* ===========================================================================
|
||||
|
@ -152,18 +152,16 @@ local int detect_data_type OF((deflate_state *s));
|
|||
local unsigned bi_reverse OF((unsigned value, int length));
|
||||
local void bi_windup OF((deflate_state *s));
|
||||
local void bi_flush OF((deflate_state *s));
|
||||
local void copy_block OF((deflate_state *s, charf *buf, unsigned len,
|
||||
int header));
|
||||
|
||||
#ifdef GEN_TREES_H
|
||||
local void gen_trees_header OF((void));
|
||||
#endif
|
||||
|
||||
#ifndef DEBUG
|
||||
#ifndef ZLIB_DEBUG
|
||||
# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
|
||||
/* Send a code of the given tree. c and tree must not have side effects */
|
||||
|
||||
#else /* DEBUG */
|
||||
#else /* !ZLIB_DEBUG */
|
||||
# define send_code(s, c, tree) \
|
||||
{ if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \
|
||||
send_bits(s, tree[c].Code, tree[c].Len); }
|
||||
|
@ -182,7 +180,7 @@ local void gen_trees_header OF((void));
|
|||
* Send a value on a given number of bits.
|
||||
* IN assertion: length <= 16 and value fits in length bits.
|
||||
*/
|
||||
#ifdef DEBUG
|
||||
#ifdef ZLIB_DEBUG
|
||||
local void send_bits OF((deflate_state *s, int value, int length));
|
||||
|
||||
local void send_bits(s, value, length)
|
||||
|
@ -208,12 +206,12 @@ local void send_bits(s, value, length)
|
|||
s->bi_valid += length;
|
||||
}
|
||||
}
|
||||
#else /* !DEBUG */
|
||||
#else /* !ZLIB_DEBUG */
|
||||
|
||||
#define send_bits(s, value, length) \
|
||||
{ int len = length;\
|
||||
if (s->bi_valid > (int)Buf_size - len) {\
|
||||
int val = value;\
|
||||
int val = (int)value;\
|
||||
s->bi_buf |= (ush)val << s->bi_valid;\
|
||||
put_short(s, s->bi_buf);\
|
||||
s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
|
||||
|
@ -223,7 +221,7 @@ local void send_bits(s, value, length)
|
|||
s->bi_valid += len;\
|
||||
}\
|
||||
}
|
||||
#endif /* DEBUG */
|
||||
#endif /* ZLIB_DEBUG */
|
||||
|
||||
|
||||
/* the arguments must not have side effects */
|
||||
|
@ -317,7 +315,7 @@ local void tr_static_init()
|
|||
* Genererate the file trees.h describing the static trees.
|
||||
*/
|
||||
#ifdef GEN_TREES_H
|
||||
# ifndef DEBUG
|
||||
# ifndef ZLIB_DEBUG
|
||||
# include <stdio.h>
|
||||
# endif
|
||||
|
||||
|
@ -394,7 +392,7 @@ void ZLIB_INTERNAL _tr_init(s)
|
|||
|
||||
s->bi_buf = 0;
|
||||
s->bi_valid = 0;
|
||||
#ifdef DEBUG
|
||||
#ifdef ZLIB_DEBUG
|
||||
s->compressed_len = 0L;
|
||||
s->bits_sent = 0L;
|
||||
#endif
|
||||
|
@ -522,12 +520,12 @@ local void gen_bitlen(s, desc)
|
|||
xbits = 0;
|
||||
if (n >= base) xbits = extra[n-base];
|
||||
f = tree[n].Freq;
|
||||
s->opt_len += (ulg)f * (bits + xbits);
|
||||
if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);
|
||||
s->opt_len += (ulg)f * (unsigned)(bits + xbits);
|
||||
if (stree) s->static_len += (ulg)f * (unsigned)(stree[n].Len + xbits);
|
||||
}
|
||||
if (overflow == 0) return;
|
||||
|
||||
Trace((stderr,"\nbit length overflow\n"));
|
||||
Tracev((stderr,"\nbit length overflow\n"));
|
||||
/* This happens for example on obj2 and pic of the Calgary corpus */
|
||||
|
||||
/* Find the first bit length which could increase: */
|
||||
|
@ -554,9 +552,8 @@ local void gen_bitlen(s, desc)
|
|||
m = s->heap[--h];
|
||||
if (m > max_code) continue;
|
||||
if ((unsigned) tree[m].Len != (unsigned) bits) {
|
||||
Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
|
||||
s->opt_len += ((long)bits - (long)tree[m].Len)
|
||||
*(long)tree[m].Freq;
|
||||
Tracev((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
|
||||
s->opt_len += ((ulg)bits - tree[m].Len) * tree[m].Freq;
|
||||
tree[m].Len = (ush)bits;
|
||||
}
|
||||
n--;
|
||||
|
@ -578,7 +575,7 @@ local void gen_codes (tree, max_code, bl_count)
|
|||
ushf *bl_count; /* number of codes at each bit length */
|
||||
{
|
||||
ush next_code[MAX_BITS+1]; /* next code value for each bit length */
|
||||
ush code = 0; /* running code value */
|
||||
unsigned code = 0; /* running code value */
|
||||
int bits; /* bit index */
|
||||
int n; /* code index */
|
||||
|
||||
|
@ -586,7 +583,8 @@ local void gen_codes (tree, max_code, bl_count)
|
|||
* without bit reversal.
|
||||
*/
|
||||
for (bits = 1; bits <= MAX_BITS; bits++) {
|
||||
next_code[bits] = code = (code + bl_count[bits-1]) << 1;
|
||||
code = (code + bl_count[bits-1]) << 1;
|
||||
next_code[bits] = (ush)code;
|
||||
}
|
||||
/* Check that the bit counts in bl_count are consistent. The last code
|
||||
* must be all ones.
|
||||
|
@ -599,7 +597,7 @@ local void gen_codes (tree, max_code, bl_count)
|
|||
int len = tree[n].Len;
|
||||
if (len == 0) continue;
|
||||
/* Now reverse the bits */
|
||||
tree[n].Code = bi_reverse(next_code[len]++, len);
|
||||
tree[n].Code = (ush)bi_reverse(next_code[len]++, len);
|
||||
|
||||
Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
|
||||
n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
|
||||
|
@ -821,7 +819,7 @@ local int build_bl_tree(s)
|
|||
if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
|
||||
}
|
||||
/* Update opt_len to include the bit length tree and counts */
|
||||
s->opt_len += 3*(max_blindex+1) + 5+5+4;
|
||||
s->opt_len += 3*((ulg)max_blindex+1) + 5+5+4;
|
||||
Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
|
||||
s->opt_len, s->static_len));
|
||||
|
||||
|
@ -869,11 +867,17 @@ void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last)
|
|||
int last; /* one if this is the last block for a file */
|
||||
{
|
||||
send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */
|
||||
#ifdef DEBUG
|
||||
bi_windup(s); /* align on byte boundary */
|
||||
put_short(s, (ush)stored_len);
|
||||
put_short(s, (ush)~stored_len);
|
||||
zmemcpy(s->pending_buf + s->pending, (Bytef *)buf, stored_len);
|
||||
s->pending += stored_len;
|
||||
#ifdef ZLIB_DEBUG
|
||||
s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
|
||||
s->compressed_len += (stored_len + 4) << 3;
|
||||
s->bits_sent += 2*16;
|
||||
s->bits_sent += stored_len<<3;
|
||||
#endif
|
||||
copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
|
||||
}
|
||||
|
||||
/* ===========================================================================
|
||||
|
@ -894,7 +898,7 @@ void ZLIB_INTERNAL _tr_align(s)
|
|||
{
|
||||
send_bits(s, STATIC_TREES<<1, 3);
|
||||
send_code(s, END_BLOCK, static_ltree);
|
||||
#ifdef DEBUG
|
||||
#ifdef ZLIB_DEBUG
|
||||
s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
|
||||
#endif
|
||||
bi_flush(s);
|
||||
|
@ -902,7 +906,7 @@ void ZLIB_INTERNAL _tr_align(s)
|
|||
|
||||
/* ===========================================================================
|
||||
* Determine the best encoding for the current block: dynamic trees, static
|
||||
* trees or store, and output the encoded block to the zip file.
|
||||
* trees or store, and write out the encoded block.
|
||||
*/
|
||||
void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
|
||||
deflate_state *s;
|
||||
|
@ -974,7 +978,7 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
|
|||
send_bits(s, (STATIC_TREES<<1)+last, 3);
|
||||
compress_block(s, (const ct_data *)static_ltree,
|
||||
(const ct_data *)static_dtree);
|
||||
#ifdef DEBUG
|
||||
#ifdef ZLIB_DEBUG
|
||||
s->compressed_len += 3 + s->static_len;
|
||||
#endif
|
||||
} else {
|
||||
|
@ -983,7 +987,7 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
|
|||
max_blindex+1);
|
||||
compress_block(s, (const ct_data *)s->dyn_ltree,
|
||||
(const ct_data *)s->dyn_dtree);
|
||||
#ifdef DEBUG
|
||||
#ifdef ZLIB_DEBUG
|
||||
s->compressed_len += 3 + s->opt_len;
|
||||
#endif
|
||||
}
|
||||
|
@ -995,7 +999,7 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
|
|||
|
||||
if (last) {
|
||||
bi_windup(s);
|
||||
#ifdef DEBUG
|
||||
#ifdef ZLIB_DEBUG
|
||||
s->compressed_len += 7; /* align on byte boundary */
|
||||
#endif
|
||||
}
|
||||
|
@ -1090,7 +1094,7 @@ local void compress_block(s, ltree, dtree)
|
|||
send_code(s, code, dtree); /* send the distance code */
|
||||
extra = extra_dbits[code];
|
||||
if (extra != 0) {
|
||||
dist -= base_dist[code];
|
||||
dist -= (unsigned)base_dist[code];
|
||||
send_bits(s, dist, extra); /* send the extra distance bits */
|
||||
}
|
||||
} /* literal or match pair ? */
|
||||
|
@ -1193,34 +1197,7 @@ local void bi_windup(s)
|
|||
}
|
||||
s->bi_buf = 0;
|
||||
s->bi_valid = 0;
|
||||
#ifdef DEBUG
|
||||
#ifdef ZLIB_DEBUG
|
||||
s->bits_sent = (s->bits_sent+7) & ~7;
|
||||
#endif
|
||||
}
|
||||
|
||||
/* ===========================================================================
|
||||
* Copy a stored block, storing first the length and its
|
||||
* one's complement if requested.
|
||||
*/
|
||||
local void copy_block(s, buf, len, header)
|
||||
deflate_state *s;
|
||||
charf *buf; /* the input data */
|
||||
unsigned len; /* its length */
|
||||
int header; /* true if block header must be written */
|
||||
{
|
||||
bi_windup(s); /* align on byte boundary */
|
||||
|
||||
if (header) {
|
||||
put_short(s, (ush)len);
|
||||
put_short(s, (ush)~len);
|
||||
#ifdef DEBUG
|
||||
s->bits_sent += 2*16;
|
||||
#endif
|
||||
}
|
||||
#ifdef DEBUG
|
||||
s->bits_sent += (ulg)len<<3;
|
||||
#endif
|
||||
while (len--) {
|
||||
put_byte(s, *buf++);
|
||||
}
|
||||
}
|
||||
|
|
114
zlib/uncompr.c
114
zlib/uncompr.c
|
@ -1,5 +1,5 @@
|
|||
/* uncompr.c -- decompress a memory buffer
|
||||
* Copyright (C) 1995-2003, 2010 Jean-loup Gailly.
|
||||
* Copyright (C) 1995-2003, 2010, 2014, 2016 Jean-loup Gailly, Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
|
@ -9,51 +9,85 @@
|
|||
#include "zlib.h"
|
||||
|
||||
/* ===========================================================================
|
||||
Decompresses the source buffer into the destination buffer. sourceLen is
|
||||
the byte length of the source buffer. Upon entry, destLen is the total
|
||||
size of the destination buffer, which must be large enough to hold the
|
||||
entire uncompressed data. (The size of the uncompressed data must have
|
||||
been saved previously by the compressor and transmitted to the decompressor
|
||||
by some mechanism outside the scope of this compression library.)
|
||||
Upon exit, destLen is the actual size of the compressed buffer.
|
||||
Decompresses the source buffer into the destination buffer. *sourceLen is
|
||||
the byte length of the source buffer. Upon entry, *destLen is the total size
|
||||
of the destination buffer, which must be large enough to hold the entire
|
||||
uncompressed data. (The size of the uncompressed data must have been saved
|
||||
previously by the compressor and transmitted to the decompressor by some
|
||||
mechanism outside the scope of this compression library.) Upon exit,
|
||||
*destLen is the size of the decompressed data and *sourceLen is the number
|
||||
of source bytes consumed. Upon return, source + *sourceLen points to the
|
||||
first unused input byte.
|
||||
|
||||
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
|
||||
enough memory, Z_BUF_ERROR if there was not enough room in the output
|
||||
buffer, or Z_DATA_ERROR if the input data was corrupted.
|
||||
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
||||
memory, Z_BUF_ERROR if there was not enough room in the output buffer, or
|
||||
Z_DATA_ERROR if the input data was corrupted, including if the input data is
|
||||
an incomplete zlib stream.
|
||||
*/
|
||||
int ZEXPORT uncompress2 (dest, destLen, source, sourceLen)
|
||||
Bytef *dest;
|
||||
uLongf *destLen;
|
||||
const Bytef *source;
|
||||
uLong *sourceLen;
|
||||
{
|
||||
z_stream stream;
|
||||
int err;
|
||||
const uInt max = (uInt)-1;
|
||||
uLong len, left;
|
||||
Byte buf[1]; /* for detection of incomplete stream when *destLen == 0 */
|
||||
|
||||
len = *sourceLen;
|
||||
if (*destLen) {
|
||||
left = *destLen;
|
||||
*destLen = 0;
|
||||
}
|
||||
else {
|
||||
left = 1;
|
||||
dest = buf;
|
||||
}
|
||||
|
||||
stream.next_in = (z_const Bytef *)source;
|
||||
stream.avail_in = 0;
|
||||
stream.zalloc = (alloc_func)0;
|
||||
stream.zfree = (free_func)0;
|
||||
stream.opaque = (voidpf)0;
|
||||
|
||||
err = inflateInit(&stream);
|
||||
if (err != Z_OK) return err;
|
||||
|
||||
stream.next_out = dest;
|
||||
stream.avail_out = 0;
|
||||
|
||||
do {
|
||||
if (stream.avail_out == 0) {
|
||||
stream.avail_out = left > (uLong)max ? max : (uInt)left;
|
||||
left -= stream.avail_out;
|
||||
}
|
||||
if (stream.avail_in == 0) {
|
||||
stream.avail_in = len > (uLong)max ? max : (uInt)len;
|
||||
len -= stream.avail_in;
|
||||
}
|
||||
err = inflate(&stream, Z_NO_FLUSH);
|
||||
} while (err == Z_OK);
|
||||
|
||||
*sourceLen -= len + stream.avail_in;
|
||||
if (dest != buf)
|
||||
*destLen = stream.total_out;
|
||||
else if (stream.total_out && err == Z_BUF_ERROR)
|
||||
left = 1;
|
||||
|
||||
inflateEnd(&stream);
|
||||
return err == Z_STREAM_END ? Z_OK :
|
||||
err == Z_NEED_DICT ? Z_DATA_ERROR :
|
||||
err == Z_BUF_ERROR && left + stream.avail_out ? Z_DATA_ERROR :
|
||||
err;
|
||||
}
|
||||
|
||||
int ZEXPORT uncompress (dest, destLen, source, sourceLen)
|
||||
Bytef *dest;
|
||||
uLongf *destLen;
|
||||
const Bytef *source;
|
||||
uLong sourceLen;
|
||||
{
|
||||
z_stream stream;
|
||||
int err;
|
||||
|
||||
stream.next_in = (z_const Bytef *)source;
|
||||
stream.avail_in = (uInt)sourceLen;
|
||||
/* Check for source > 64K on 16-bit machine: */
|
||||
if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
|
||||
|
||||
stream.next_out = dest;
|
||||
stream.avail_out = (uInt)*destLen;
|
||||
if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
|
||||
|
||||
stream.zalloc = (alloc_func)0;
|
||||
stream.zfree = (free_func)0;
|
||||
|
||||
err = inflateInit(&stream);
|
||||
if (err != Z_OK) return err;
|
||||
|
||||
err = inflate(&stream, Z_FINISH);
|
||||
if (err != Z_STREAM_END) {
|
||||
inflateEnd(&stream);
|
||||
if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0))
|
||||
return Z_DATA_ERROR;
|
||||
return err;
|
||||
}
|
||||
*destLen = stream.total_out;
|
||||
|
||||
err = inflateEnd(&stream);
|
||||
return err;
|
||||
return uncompress2(dest, destLen, source, &sourceLen);
|
||||
}
|
||||
|
|
|
@ -8,6 +8,7 @@ EXPORTS
|
|||
inflateEnd
|
||||
; advanced functions
|
||||
deflateSetDictionary
|
||||
deflateGetDictionary
|
||||
deflateCopy
|
||||
deflateReset
|
||||
deflateParams
|
||||
|
@ -33,12 +34,15 @@ EXPORTS
|
|||
compress2
|
||||
compressBound
|
||||
uncompress
|
||||
uncompress2
|
||||
gzopen
|
||||
gzdopen
|
||||
gzbuffer
|
||||
gzsetparams
|
||||
gzread
|
||||
gzfread
|
||||
gzwrite
|
||||
gzfwrite
|
||||
gzprintf
|
||||
gzvprintf
|
||||
gzputs
|
||||
|
@ -67,7 +71,9 @@ EXPORTS
|
|||
crc32_combine64
|
||||
; checksum functions
|
||||
adler32
|
||||
adler32_z
|
||||
crc32
|
||||
crc32_z
|
||||
adler32_combine
|
||||
crc32_combine
|
||||
; various hacks, don't look :)
|
||||
|
@ -81,6 +87,8 @@ EXPORTS
|
|||
inflateSyncPoint
|
||||
get_crc_table
|
||||
inflateUndermine
|
||||
inflateValidate
|
||||
inflateCodesUsed
|
||||
inflateResetKeep
|
||||
deflateResetKeep
|
||||
gzopen_w
|
||||
|
|
|
@ -26,7 +26,7 @@ BEGIN
|
|||
VALUE "FileDescription", "zlib data compression library\0"
|
||||
VALUE "FileVersion", ZLIB_VERSION "\0"
|
||||
VALUE "InternalName", "zlib1.dll\0"
|
||||
VALUE "LegalCopyright", "(C) 1995-2013 Jean-loup Gailly & Mark Adler\0"
|
||||
VALUE "LegalCopyright", "(C) 1995-2017 Jean-loup Gailly & Mark Adler\0"
|
||||
VALUE "OriginalFilename", "zlib1.dll\0"
|
||||
VALUE "ProductName", "zlib\0"
|
||||
VALUE "ProductVersion", ZLIB_VERSION "\0"
|
||||
|
|
41
zlib/zconf.h
41
zlib/zconf.h
|
@ -1,5 +1,5 @@
|
|||
/* zconf.h -- configuration of the zlib compression library
|
||||
* Copyright (C) 1995-2013 Jean-loup Gailly.
|
||||
* Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
|
@ -17,7 +17,7 @@
|
|||
#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */
|
||||
# define Z_PREFIX_SET
|
||||
|
||||
/* all linked symbols */
|
||||
/* all linked symbols and init macros */
|
||||
# define _dist_code z__dist_code
|
||||
# define _length_code z__length_code
|
||||
# define _tr_align z__tr_align
|
||||
|
@ -29,6 +29,7 @@
|
|||
# define adler32 z_adler32
|
||||
# define adler32_combine z_adler32_combine
|
||||
# define adler32_combine64 z_adler32_combine64
|
||||
# define adler32_z z_adler32_z
|
||||
# ifndef Z_SOLO
|
||||
# define compress z_compress
|
||||
# define compress2 z_compress2
|
||||
|
@ -37,10 +38,14 @@
|
|||
# define crc32 z_crc32
|
||||
# define crc32_combine z_crc32_combine
|
||||
# define crc32_combine64 z_crc32_combine64
|
||||
# define crc32_z z_crc32_z
|
||||
# define deflate z_deflate
|
||||
# define deflateBound z_deflateBound
|
||||
# define deflateCopy z_deflateCopy
|
||||
# define deflateEnd z_deflateEnd
|
||||
# define deflateGetDictionary z_deflateGetDictionary
|
||||
# define deflateInit z_deflateInit
|
||||
# define deflateInit2 z_deflateInit2
|
||||
# define deflateInit2_ z_deflateInit2_
|
||||
# define deflateInit_ z_deflateInit_
|
||||
# define deflateParams z_deflateParams
|
||||
|
@ -67,6 +72,8 @@
|
|||
# define gzeof z_gzeof
|
||||
# define gzerror z_gzerror
|
||||
# define gzflush z_gzflush
|
||||
# define gzfread z_gzfread
|
||||
# define gzfwrite z_gzfwrite
|
||||
# define gzgetc z_gzgetc
|
||||
# define gzgetc_ z_gzgetc_
|
||||
# define gzgets z_gzgets
|
||||
|
@ -78,7 +85,6 @@
|
|||
# define gzopen_w z_gzopen_w
|
||||
# endif
|
||||
# define gzprintf z_gzprintf
|
||||
# define gzvprintf z_gzvprintf
|
||||
# define gzputc z_gzputc
|
||||
# define gzputs z_gzputs
|
||||
# define gzread z_gzread
|
||||
|
@ -89,32 +95,39 @@
|
|||
# define gztell z_gztell
|
||||
# define gztell64 z_gztell64
|
||||
# define gzungetc z_gzungetc
|
||||
# define gzvprintf z_gzvprintf
|
||||
# define gzwrite z_gzwrite
|
||||
# endif
|
||||
# define inflate z_inflate
|
||||
# define inflateBack z_inflateBack
|
||||
# define inflateBackEnd z_inflateBackEnd
|
||||
# define inflateBackInit z_inflateBackInit
|
||||
# define inflateBackInit_ z_inflateBackInit_
|
||||
# define inflateCodesUsed z_inflateCodesUsed
|
||||
# define inflateCopy z_inflateCopy
|
||||
# define inflateEnd z_inflateEnd
|
||||
# define inflateGetDictionary z_inflateGetDictionary
|
||||
# define inflateGetHeader z_inflateGetHeader
|
||||
# define inflateInit z_inflateInit
|
||||
# define inflateInit2 z_inflateInit2
|
||||
# define inflateInit2_ z_inflateInit2_
|
||||
# define inflateInit_ z_inflateInit_
|
||||
# define inflateMark z_inflateMark
|
||||
# define inflatePrime z_inflatePrime
|
||||
# define inflateReset z_inflateReset
|
||||
# define inflateReset2 z_inflateReset2
|
||||
# define inflateResetKeep z_inflateResetKeep
|
||||
# define inflateSetDictionary z_inflateSetDictionary
|
||||
# define inflateGetDictionary z_inflateGetDictionary
|
||||
# define inflateSync z_inflateSync
|
||||
# define inflateSyncPoint z_inflateSyncPoint
|
||||
# define inflateUndermine z_inflateUndermine
|
||||
# define inflateResetKeep z_inflateResetKeep
|
||||
# define inflateValidate z_inflateValidate
|
||||
# define inflate_copyright z_inflate_copyright
|
||||
# define inflate_fast z_inflate_fast
|
||||
# define inflate_table z_inflate_table
|
||||
# ifndef Z_SOLO
|
||||
# define uncompress z_uncompress
|
||||
# define uncompress2 z_uncompress2
|
||||
# endif
|
||||
# define zError z_zError
|
||||
# ifndef Z_SOLO
|
||||
|
@ -224,9 +237,19 @@
|
|||
# define z_const
|
||||
#endif
|
||||
|
||||
/* Some Mac compilers merge all .h files incorrectly: */
|
||||
#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
|
||||
# define NO_DUMMY_DECL
|
||||
#ifdef Z_SOLO
|
||||
typedef unsigned long z_size_t;
|
||||
#else
|
||||
# define z_longlong long long
|
||||
# if defined(NO_SIZE_T)
|
||||
typedef unsigned NO_SIZE_T z_size_t;
|
||||
# elif defined(STDC)
|
||||
# include <stddef.h>
|
||||
typedef size_t z_size_t;
|
||||
# else
|
||||
typedef unsigned long z_size_t;
|
||||
# endif
|
||||
# undef z_longlong
|
||||
#endif
|
||||
|
||||
/* Maximum value for memLevel in deflateInit2 */
|
||||
|
@ -256,7 +279,7 @@
|
|||
Of course this will generally degrade compression (there's no free lunch).
|
||||
|
||||
The memory requirements for inflate are (in bytes) 1 << windowBits
|
||||
that is, 32K for windowBits=15 (default value) plus a few kilobytes
|
||||
that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
|
||||
for small objects.
|
||||
*/
|
||||
|
||||
|
|
70
zlib/zlib.3
70
zlib/zlib.3
|
@ -1,4 +1,4 @@
|
|||
.TH ZLIB 3 "28 Apr 2013"
|
||||
.TH ZLIB 3 "15 Jan 2017"
|
||||
.SH NAME
|
||||
zlib \- compression/decompression library
|
||||
.SH SYNOPSIS
|
||||
|
@ -48,32 +48,10 @@ Changes to this version are documented in the file
|
|||
that accompanies the source.
|
||||
.LP
|
||||
.I zlib
|
||||
is available in Java using the java.util.zip package:
|
||||
.IP
|
||||
http://java.sun.com/developer/technicalArticles/Programming/compression/
|
||||
is built in to many languages and operating systems, including but not limited to
|
||||
Java, Python, .NET, PHP, Perl, Ruby, Swift, and Go.
|
||||
.LP
|
||||
A Perl interface to
|
||||
.IR zlib ,
|
||||
written by Paul Marquess (pmqs@cpan.org),
|
||||
is available at CPAN (Comprehensive Perl Archive Network) sites,
|
||||
including:
|
||||
.IP
|
||||
http://search.cpan.org/~pmqs/IO-Compress-Zlib/
|
||||
.LP
|
||||
A Python interface to
|
||||
.IR zlib ,
|
||||
written by A.M. Kuchling (amk@magnet.com),
|
||||
is available in Python 1.5 and later versions:
|
||||
.IP
|
||||
http://docs.python.org/library/zlib.html
|
||||
.LP
|
||||
.I zlib
|
||||
is built into
|
||||
.IR tcl:
|
||||
.IP
|
||||
http://wiki.tcl.tk/4610
|
||||
.LP
|
||||
An experimental package to read and write files in .zip format,
|
||||
An experimental package to read and write files in the .zip format,
|
||||
written on top of
|
||||
.I zlib
|
||||
by Gilles Vollant (info@winimage.com),
|
||||
|
@ -92,7 +70,9 @@ web site can be found at:
|
|||
.IP
|
||||
http://zlib.net/
|
||||
.LP
|
||||
The data format used by the zlib library is described by RFC
|
||||
The data format used by the
|
||||
.I zlib
|
||||
library is described by RFC
|
||||
(Request for Comments) 1950 to 1952 in the files:
|
||||
.IP
|
||||
http://tools.ietf.org/html/rfc1950 (for the zlib header and trailer format)
|
||||
|
@ -124,17 +104,35 @@ http://zlib.net/zlib_faq.html
|
|||
before asking for help.
|
||||
Send questions and/or comments to zlib@gzip.org,
|
||||
or (for the Windows DLL version) to Gilles Vollant (info@winimage.com).
|
||||
.SH AUTHORS
|
||||
Version 1.2.8
|
||||
Copyright (C) 1995-2013 Jean-loup Gailly (jloup@gzip.org)
|
||||
and Mark Adler (madler@alumni.caltech.edu).
|
||||
.SH AUTHORS AND LICENSE
|
||||
Version 1.2.11
|
||||
.LP
|
||||
This software is provided "as-is,"
|
||||
without any express or implied warranty.
|
||||
In no event will the authors be held liable for any damages
|
||||
Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
|
||||
.LP
|
||||
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.
|
||||
See the distribution directory with respect to requirements
|
||||
governing redistribution.
|
||||
.LP
|
||||
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:
|
||||
.LP
|
||||
.nr step 1 1
|
||||
.IP \n[step]. 3
|
||||
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.
|
||||
.IP \n+[step].
|
||||
Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
.IP \n+[step].
|
||||
This notice may not be removed or altered from any source distribution.
|
||||
.LP
|
||||
Jean-loup Gailly Mark Adler
|
||||
.br
|
||||
jloup@gzip.org madler@alumni.caltech.edu
|
||||
.LP
|
||||
The deflate format used by
|
||||
.I zlib
|
||||
was defined by Phil Katz.
|
||||
|
|
BIN
zlib/zlib.3.pdf
BIN
zlib/zlib.3.pdf
Binary file not shown.
444
zlib/zlib.h
444
zlib/zlib.h
|
@ -1,7 +1,7 @@
|
|||
/* zlib.h -- interface of the 'zlib' general purpose compression library
|
||||
version 1.2.8, April 28th, 2013
|
||||
version 1.2.11, January 15th, 2017
|
||||
|
||||
Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
|
||||
Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
|
@ -37,11 +37,11 @@
|
|||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define ZLIB_VERSION "1.2.8"
|
||||
#define ZLIB_VERNUM 0x1280
|
||||
#define ZLIB_VERSION "1.2.11"
|
||||
#define ZLIB_VERNUM 0x12b0
|
||||
#define ZLIB_VER_MAJOR 1
|
||||
#define ZLIB_VER_MINOR 2
|
||||
#define ZLIB_VER_REVISION 8
|
||||
#define ZLIB_VER_REVISION 11
|
||||
#define ZLIB_VER_SUBREVISION 0
|
||||
|
||||
/*
|
||||
|
@ -65,7 +65,8 @@ extern "C" {
|
|||
with "gz". The gzip format is different from the zlib format. gzip is a
|
||||
gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
|
||||
|
||||
This library can optionally read and write gzip streams in memory as well.
|
||||
This library can optionally read and write gzip and raw deflate streams in
|
||||
memory as well.
|
||||
|
||||
The zlib format was designed to be compact and fast for use in memory
|
||||
and on communications channels. The gzip format was designed for single-
|
||||
|
@ -74,7 +75,7 @@ extern "C" {
|
|||
|
||||
The library does not install any signal handler. The decoder checks
|
||||
the consistency of the compressed data, so the library should never crash
|
||||
even in case of corrupted input.
|
||||
even in the case of corrupted input.
|
||||
*/
|
||||
|
||||
typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
|
||||
|
@ -87,7 +88,7 @@ typedef struct z_stream_s {
|
|||
uInt avail_in; /* number of bytes available at next_in */
|
||||
uLong total_in; /* total number of input bytes read so far */
|
||||
|
||||
Bytef *next_out; /* next output byte should be put there */
|
||||
Bytef *next_out; /* next output byte will go here */
|
||||
uInt avail_out; /* remaining free space at next_out */
|
||||
uLong total_out; /* total number of bytes output so far */
|
||||
|
||||
|
@ -98,8 +99,9 @@ typedef struct z_stream_s {
|
|||
free_func zfree; /* used to free the internal state */
|
||||
voidpf opaque; /* private data object passed to zalloc and zfree */
|
||||
|
||||
int data_type; /* best guess about the data type: binary or text */
|
||||
uLong adler; /* adler32 value of the uncompressed data */
|
||||
int data_type; /* best guess about the data type: binary or text
|
||||
for deflate, or the decoding state for inflate */
|
||||
uLong adler; /* Adler-32 or CRC-32 value of the uncompressed data */
|
||||
uLong reserved; /* reserved for future use */
|
||||
} z_stream;
|
||||
|
||||
|
@ -142,7 +144,9 @@ typedef gz_header FAR *gz_headerp;
|
|||
|
||||
zalloc must return Z_NULL if there is not enough memory for the object.
|
||||
If zlib is used in a multi-threaded application, zalloc and zfree must be
|
||||
thread safe.
|
||||
thread safe. In that case, zlib is thread-safe. When zalloc and zfree are
|
||||
Z_NULL on entry to the initialization function, they are set to internal
|
||||
routines that use the standard library functions malloc() and free().
|
||||
|
||||
On 16-bit systems, the functions zalloc and zfree must be able to allocate
|
||||
exactly 65536 bytes, but will not be required to allocate more than this if
|
||||
|
@ -155,7 +159,7 @@ typedef gz_header FAR *gz_headerp;
|
|||
|
||||
The fields total_in and total_out can be used for statistics or progress
|
||||
reports. After compression, total_in holds the total size of the
|
||||
uncompressed data and may be saved for use in the decompressor (particularly
|
||||
uncompressed data and may be saved for use by the decompressor (particularly
|
||||
if the decompressor wants to decompress everything in a single step).
|
||||
*/
|
||||
|
||||
|
@ -200,7 +204,7 @@ typedef gz_header FAR *gz_headerp;
|
|||
#define Z_TEXT 1
|
||||
#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */
|
||||
#define Z_UNKNOWN 2
|
||||
/* Possible values of the data_type field (though see inflate()) */
|
||||
/* Possible values of the data_type field for deflate() */
|
||||
|
||||
#define Z_DEFLATED 8
|
||||
/* The deflate compression method (the only one supported in this version) */
|
||||
|
@ -258,11 +262,11 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
|
|||
enough room in the output buffer), next_in and avail_in are updated and
|
||||
processing will resume at this point for the next call of deflate().
|
||||
|
||||
- Provide more output starting at next_out and update next_out and avail_out
|
||||
- Generate more output starting at next_out and update next_out and avail_out
|
||||
accordingly. This action is forced if the parameter flush is non zero.
|
||||
Forcing flush frequently degrades the compression ratio, so this parameter
|
||||
should be set only when necessary (in interactive applications). Some
|
||||
output may be provided even if flush is not set.
|
||||
should be set only when necessary. Some output may be provided even if
|
||||
flush is zero.
|
||||
|
||||
Before the call of deflate(), the application should ensure that at least
|
||||
one of the actions is possible, by providing more input and/or consuming more
|
||||
|
@ -271,7 +275,9 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
|
|||
output when it wants, for example when the output buffer is full (avail_out
|
||||
== 0), or after each call of deflate(). If deflate returns Z_OK and with
|
||||
zero avail_out, it must be called again after making room in the output
|
||||
buffer because there might be more output pending.
|
||||
buffer because there might be more output pending. See deflatePending(),
|
||||
which can be used if desired to determine whether or not there is more ouput
|
||||
in that case.
|
||||
|
||||
Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
|
||||
decide how much data to accumulate before producing output, in order to
|
||||
|
@ -292,8 +298,8 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
|
|||
input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
|
||||
This completes the current deflate block and follows it with an empty fixed
|
||||
codes block that is 10 bits long. This assures that enough bytes are output
|
||||
in order for the decompressor to finish the block before the empty fixed code
|
||||
block.
|
||||
in order for the decompressor to finish the block before the empty fixed
|
||||
codes block.
|
||||
|
||||
If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
|
||||
for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
|
||||
|
@ -319,34 +325,38 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
|
|||
|
||||
If the parameter flush is set to Z_FINISH, pending input is processed,
|
||||
pending output is flushed and deflate returns with Z_STREAM_END if there was
|
||||
enough output space; if deflate returns with Z_OK, this function must be
|
||||
called again with Z_FINISH and more output space (updated avail_out) but no
|
||||
more input data, until it returns with Z_STREAM_END or an error. After
|
||||
deflate has returned Z_STREAM_END, the only possible operations on the stream
|
||||
are deflateReset or deflateEnd.
|
||||
enough output space. If deflate returns with Z_OK or Z_BUF_ERROR, this
|
||||
function must be called again with Z_FINISH and more output space (updated
|
||||
avail_out) but no more input data, until it returns with Z_STREAM_END or an
|
||||
error. After deflate has returned Z_STREAM_END, the only possible operations
|
||||
on the stream are deflateReset or deflateEnd.
|
||||
|
||||
Z_FINISH can be used immediately after deflateInit if all the compression
|
||||
is to be done in a single step. In this case, avail_out must be at least the
|
||||
value returned by deflateBound (see below). Then deflate is guaranteed to
|
||||
return Z_STREAM_END. If not enough output space is provided, deflate will
|
||||
not return Z_STREAM_END, and it must be called again as described above.
|
||||
Z_FINISH can be used in the first deflate call after deflateInit if all the
|
||||
compression is to be done in a single step. In order to complete in one
|
||||
call, avail_out must be at least the value returned by deflateBound (see
|
||||
below). Then deflate is guaranteed to return Z_STREAM_END. If not enough
|
||||
output space is provided, deflate will not return Z_STREAM_END, and it must
|
||||
be called again as described above.
|
||||
|
||||
deflate() sets strm->adler to the adler32 checksum of all input read
|
||||
so far (that is, total_in bytes).
|
||||
deflate() sets strm->adler to the Adler-32 checksum of all input read
|
||||
so far (that is, total_in bytes). If a gzip stream is being generated, then
|
||||
strm->adler will be the CRC-32 checksum of the input read so far. (See
|
||||
deflateInit2 below.)
|
||||
|
||||
deflate() may update strm->data_type if it can make a good guess about
|
||||
the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered
|
||||
binary. This field is only for information purposes and does not affect the
|
||||
compression algorithm in any manner.
|
||||
the input data type (Z_BINARY or Z_TEXT). If in doubt, the data is
|
||||
considered binary. This field is only for information purposes and does not
|
||||
affect the compression algorithm in any manner.
|
||||
|
||||
deflate() returns Z_OK if some progress has been made (more input
|
||||
processed or more output produced), Z_STREAM_END if all input has been
|
||||
consumed and all output has been produced (only when flush is set to
|
||||
Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
|
||||
if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible
|
||||
(for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not
|
||||
fatal, and deflate() can be called again with more input and more output
|
||||
space to continue compressing.
|
||||
if next_in or next_out was Z_NULL or the state was inadvertently written over
|
||||
by the application), or Z_BUF_ERROR if no progress is possible (for example
|
||||
avail_in or avail_out was zero). Note that Z_BUF_ERROR is not fatal, and
|
||||
deflate() can be called again with more input and more output space to
|
||||
continue compressing.
|
||||
*/
|
||||
|
||||
|
||||
|
@ -369,23 +379,21 @@ ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
|
|||
|
||||
Initializes the internal stream state for decompression. The fields
|
||||
next_in, avail_in, zalloc, zfree and opaque must be initialized before by
|
||||
the caller. If next_in is not Z_NULL and avail_in is large enough (the
|
||||
exact value depends on the compression method), inflateInit determines the
|
||||
compression method from the zlib header and allocates all data structures
|
||||
accordingly; otherwise the allocation will be deferred to the first call of
|
||||
inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to
|
||||
use default allocation functions.
|
||||
the caller. In the current version of inflate, the provided input is not
|
||||
read or consumed. The allocation of a sliding window will be deferred to
|
||||
the first call of inflate (if the decompression does not complete on the
|
||||
first call). If zalloc and zfree are set to Z_NULL, inflateInit updates
|
||||
them to use default allocation functions.
|
||||
|
||||
inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
||||
memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
|
||||
version assumed by the caller, or Z_STREAM_ERROR if the parameters are
|
||||
invalid, such as a null pointer to the structure. msg is set to null if
|
||||
there is no error message. inflateInit does not perform any decompression
|
||||
apart from possibly reading the zlib header if present: actual decompression
|
||||
will be done by inflate(). (So next_in and avail_in may be modified, but
|
||||
next_out and avail_out are unused and unchanged.) The current implementation
|
||||
of inflateInit() does not process any header information -- that is deferred
|
||||
until inflate() is called.
|
||||
there is no error message. inflateInit does not perform any decompression.
|
||||
Actual decompression will be done by inflate(). So next_in, and avail_in,
|
||||
next_out, and avail_out are unused and unchanged. The current
|
||||
implementation of inflateInit() does not process any header information --
|
||||
that is deferred until inflate() is called.
|
||||
*/
|
||||
|
||||
|
||||
|
@ -401,17 +409,20 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
|
|||
|
||||
- Decompress more input starting at next_in and update next_in and avail_in
|
||||
accordingly. If not all input can be processed (because there is not
|
||||
enough room in the output buffer), next_in is updated and processing will
|
||||
resume at this point for the next call of inflate().
|
||||
enough room in the output buffer), then next_in and avail_in are updated
|
||||
accordingly, and processing will resume at this point for the next call of
|
||||
inflate().
|
||||
|
||||
- Provide more output starting at next_out and update next_out and avail_out
|
||||
- Generate more output starting at next_out and update next_out and avail_out
|
||||
accordingly. inflate() provides as much output as possible, until there is
|
||||
no more input data or no more space in the output buffer (see below about
|
||||
the flush parameter).
|
||||
|
||||
Before the call of inflate(), the application should ensure that at least
|
||||
one of the actions is possible, by providing more input and/or consuming more
|
||||
output, and updating the next_* and avail_* values accordingly. The
|
||||
output, and updating the next_* and avail_* values accordingly. If the
|
||||
caller of inflate() does not provide both available input and available
|
||||
output space, it is possible that there will be no progress made. The
|
||||
application can consume the uncompressed output when it wants, for example
|
||||
when the output buffer is full (avail_out == 0), or after each call of
|
||||
inflate(). If inflate returns Z_OK and with zero avail_out, it must be
|
||||
|
@ -428,7 +439,7 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
|
|||
gets to the end of that block, or when it runs out of data.
|
||||
|
||||
The Z_BLOCK option assists in appending to or combining deflate streams.
|
||||
Also to assist in this, on return inflate() will set strm->data_type to the
|
||||
To assist in this, on return inflate() always sets strm->data_type to the
|
||||
number of unused bits in the last byte taken from strm->next_in, plus 64 if
|
||||
inflate() is currently decoding the last block in the deflate stream, plus
|
||||
128 if inflate() returned immediately after decoding an end-of-block code or
|
||||
|
@ -454,7 +465,7 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
|
|||
this case all pending input is processed and all pending output is flushed;
|
||||
avail_out must be large enough to hold all of the uncompressed data for the
|
||||
operation to complete. (The size of the uncompressed data may have been
|
||||
saved by the compressor for this purpose.) The use of Z_FINISH is not
|
||||
saved by the compressor for this purpose.) The use of Z_FINISH is not
|
||||
required to perform an inflation in one step. However it may be used to
|
||||
inform inflate that a faster approach can be used for the single inflate()
|
||||
call. Z_FINISH also informs inflate to not maintain a sliding window if the
|
||||
|
@ -476,32 +487,33 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
|
|||
chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
|
||||
strm->adler to the Adler-32 checksum of all output produced so far (that is,
|
||||
total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
|
||||
below. At the end of the stream, inflate() checks that its computed adler32
|
||||
below. At the end of the stream, inflate() checks that its computed Adler-32
|
||||
checksum is equal to that saved by the compressor and returns Z_STREAM_END
|
||||
only if the checksum is correct.
|
||||
|
||||
inflate() can decompress and check either zlib-wrapped or gzip-wrapped
|
||||
deflate data. The header type is detected automatically, if requested when
|
||||
initializing with inflateInit2(). Any information contained in the gzip
|
||||
header is not retained, so applications that need that information should
|
||||
instead use raw inflate, see inflateInit2() below, or inflateBack() and
|
||||
perform their own processing of the gzip header and trailer. When processing
|
||||
header is not retained unless inflateGetHeader() is used. When processing
|
||||
gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
|
||||
producted so far. The CRC-32 is checked against the gzip trailer.
|
||||
produced so far. The CRC-32 is checked against the gzip trailer, as is the
|
||||
uncompressed length, modulo 2^32.
|
||||
|
||||
inflate() returns Z_OK if some progress has been made (more input processed
|
||||
or more output produced), Z_STREAM_END if the end of the compressed data has
|
||||
been reached and all uncompressed output has been produced, Z_NEED_DICT if a
|
||||
preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
|
||||
corrupted (input stream not conforming to the zlib format or incorrect check
|
||||
value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
|
||||
next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory,
|
||||
Z_BUF_ERROR if no progress is possible or if there was not enough room in the
|
||||
output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
|
||||
value, in which case strm->msg points to a string with a more specific
|
||||
error), Z_STREAM_ERROR if the stream structure was inconsistent (for example
|
||||
next_in or next_out was Z_NULL, or the state was inadvertently written over
|
||||
by the application), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR
|
||||
if no progress was possible or if there was not enough room in the output
|
||||
buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
|
||||
inflate() can be called again with more input and more output space to
|
||||
continue decompressing. If Z_DATA_ERROR is returned, the application may
|
||||
then call inflateSync() to look for a good compression block if a partial
|
||||
recovery of the data is desired.
|
||||
recovery of the data is to be attempted.
|
||||
*/
|
||||
|
||||
|
||||
|
@ -511,9 +523,8 @@ ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
|
|||
This function discards any unprocessed input and does not flush any pending
|
||||
output.
|
||||
|
||||
inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
|
||||
was inconsistent. In the error case, msg may be set but then points to a
|
||||
static string (which must not be deallocated).
|
||||
inflateEnd returns Z_OK if success, or Z_STREAM_ERROR if the stream state
|
||||
was inconsistent.
|
||||
*/
|
||||
|
||||
|
||||
|
@ -544,16 +555,29 @@ ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
|
|||
compression at the expense of memory usage. The default value is 15 if
|
||||
deflateInit is used instead.
|
||||
|
||||
For the current implementation of deflate(), a windowBits value of 8 (a
|
||||
window size of 256 bytes) is not supported. As a result, a request for 8
|
||||
will result in 9 (a 512-byte window). In that case, providing 8 to
|
||||
inflateInit2() will result in an error when the zlib header with 9 is
|
||||
checked against the initialization of inflate(). The remedy is to not use 8
|
||||
with deflateInit2() with this initialization, or at least in that case use 9
|
||||
with inflateInit2().
|
||||
|
||||
windowBits can also be -8..-15 for raw deflate. In this case, -windowBits
|
||||
determines the window size. deflate() will then generate raw deflate data
|
||||
with no zlib header or trailer, and will not compute an adler32 check value.
|
||||
with no zlib header or trailer, and will not compute a check value.
|
||||
|
||||
windowBits can also be greater than 15 for optional gzip encoding. Add
|
||||
16 to windowBits to write a simple gzip header and trailer around the
|
||||
compressed data instead of a zlib wrapper. The gzip header will have no
|
||||
file name, no extra data, no comment, no modification time (set to zero), no
|
||||
header crc, and the operating system will be set to 255 (unknown). If a
|
||||
gzip stream is being written, strm->adler is a crc32 instead of an adler32.
|
||||
header crc, and the operating system will be set to the appropriate value,
|
||||
if the operating system was determined at compile time. If a gzip stream is
|
||||
being written, strm->adler is a CRC-32 instead of an Adler-32.
|
||||
|
||||
For raw deflate or gzip encoding, a request for a 256-byte window is
|
||||
rejected as invalid, since only the zlib header provides a means of
|
||||
transmitting the window size to the decompressor.
|
||||
|
||||
The memLevel parameter specifies how much memory should be allocated
|
||||
for the internal compression state. memLevel=1 uses minimum memory but is
|
||||
|
@ -614,12 +638,12 @@ ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
|
|||
addition, the current implementation of deflate will use at most the window
|
||||
size minus 262 bytes of the provided dictionary.
|
||||
|
||||
Upon return of this function, strm->adler is set to the adler32 value
|
||||
Upon return of this function, strm->adler is set to the Adler-32 value
|
||||
of the dictionary; the decompressor may later use this value to determine
|
||||
which dictionary has been used by the compressor. (The adler32 value
|
||||
which dictionary has been used by the compressor. (The Adler-32 value
|
||||
applies to the whole dictionary even if only a subset of the dictionary is
|
||||
actually used by the compressor.) If a raw deflate was requested, then the
|
||||
adler32 value is not computed and strm->adler is not set.
|
||||
Adler-32 value is not computed and strm->adler is not set.
|
||||
|
||||
deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
|
||||
parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is
|
||||
|
@ -628,6 +652,28 @@ ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
|
|||
not perform any compression: this will be done by deflate().
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm,
|
||||
Bytef *dictionary,
|
||||
uInt *dictLength));
|
||||
/*
|
||||
Returns the sliding dictionary being maintained by deflate. dictLength is
|
||||
set to the number of bytes in the dictionary, and that many bytes are copied
|
||||
to dictionary. dictionary must have enough space, where 32768 bytes is
|
||||
always enough. If deflateGetDictionary() is called with dictionary equal to
|
||||
Z_NULL, then only the dictionary length is returned, and nothing is copied.
|
||||
Similary, if dictLength is Z_NULL, then it is not set.
|
||||
|
||||
deflateGetDictionary() may return a length less than the window size, even
|
||||
when more than the window size in input has been provided. It may return up
|
||||
to 258 bytes less in that case, due to how zlib's implementation of deflate
|
||||
manages the sliding window and lookahead for matches, where matches can be
|
||||
up to 258 bytes long. If the application needs the last window-size bytes of
|
||||
input, then that would need to be saved by the application outside of zlib.
|
||||
|
||||
deflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
|
||||
stream state is inconsistent.
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
|
||||
z_streamp source));
|
||||
/*
|
||||
|
@ -648,10 +694,10 @@ ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
|
|||
|
||||
ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
|
||||
/*
|
||||
This function is equivalent to deflateEnd followed by deflateInit,
|
||||
but does not free and reallocate all the internal compression state. The
|
||||
stream will keep the same compression level and any other attributes that
|
||||
may have been set by deflateInit2.
|
||||
This function is equivalent to deflateEnd followed by deflateInit, but
|
||||
does not free and reallocate the internal compression state. The stream
|
||||
will leave the compression level and any other attributes that may have been
|
||||
set unchanged.
|
||||
|
||||
deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
|
||||
stream state was inconsistent (such as zalloc or state being Z_NULL).
|
||||
|
@ -662,20 +708,36 @@ ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
|
|||
int strategy));
|
||||
/*
|
||||
Dynamically update the compression level and compression strategy. The
|
||||
interpretation of level and strategy is as in deflateInit2. This can be
|
||||
interpretation of level and strategy is as in deflateInit2(). This can be
|
||||
used to switch between compression and straight copy of the input data, or
|
||||
to switch to a different kind of input data requiring a different strategy.
|
||||
If the compression level is changed, the input available so far is
|
||||
compressed with the old level (and may be flushed); the new level will take
|
||||
effect only at the next call of deflate().
|
||||
If the compression approach (which is a function of the level) or the
|
||||
strategy is changed, and if any input has been consumed in a previous
|
||||
deflate() call, then the input available so far is compressed with the old
|
||||
level and strategy using deflate(strm, Z_BLOCK). There are three approaches
|
||||
for the compression levels 0, 1..3, and 4..9 respectively. The new level
|
||||
and strategy will take effect at the next call of deflate().
|
||||
|
||||
Before the call of deflateParams, the stream state must be set as for
|
||||
a call of deflate(), since the currently available input may have to be
|
||||
compressed and flushed. In particular, strm->avail_out must be non-zero.
|
||||
If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does
|
||||
not have enough output space to complete, then the parameter change will not
|
||||
take effect. In this case, deflateParams() can be called again with the
|
||||
same parameters and more output space to try again.
|
||||
|
||||
deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
|
||||
stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if
|
||||
strm->avail_out was zero.
|
||||
In order to assure a change in the parameters on the first try, the
|
||||
deflate stream should be flushed using deflate() with Z_BLOCK or other flush
|
||||
request until strm.avail_out is not zero, before calling deflateParams().
|
||||
Then no more input data should be provided before the deflateParams() call.
|
||||
If this is done, the old level and strategy will be applied to the data
|
||||
compressed before deflateParams(), and the new level and strategy will be
|
||||
applied to the the data compressed after deflateParams().
|
||||
|
||||
deflateParams returns Z_OK on success, Z_STREAM_ERROR if the source stream
|
||||
state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if
|
||||
there was not enough output space to complete the compression of the
|
||||
available input data before a change in the strategy or approach. Note that
|
||||
in the case of a Z_BUF_ERROR, the parameters are not changed. A return
|
||||
value of Z_BUF_ERROR is not fatal, in which case deflateParams() can be
|
||||
retried with more output space.
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
|
||||
|
@ -793,7 +855,7 @@ ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
|
|||
is for use with other formats that use the deflate compressed data format
|
||||
such as zip. Those formats provide their own check values. If a custom
|
||||
format is developed using the raw deflate format for compressed data, it is
|
||||
recommended that a check value such as an adler32 or a crc32 be applied to
|
||||
recommended that a check value such as an Adler-32 or a CRC-32 be applied to
|
||||
the uncompressed data as is done in the zlib, gzip, and zip formats. For
|
||||
most applications, the zlib format should be used as is. Note that comments
|
||||
above on the use in deflateInit2() applies to the magnitude of windowBits.
|
||||
|
@ -802,7 +864,10 @@ ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
|
|||
32 to windowBits to enable zlib and gzip decoding with automatic header
|
||||
detection, or add 16 to decode only the gzip format (the zlib format will
|
||||
return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a
|
||||
crc32 instead of an adler32.
|
||||
CRC-32 instead of an Adler-32. Unlike the gunzip utility and gzread() (see
|
||||
below), inflate() will not automatically decode concatenated gzip streams.
|
||||
inflate() will return Z_STREAM_END at the end of the gzip stream. The state
|
||||
would need to be reset to continue decoding a subsequent gzip stream.
|
||||
|
||||
inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
||||
memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
|
||||
|
@ -823,7 +888,7 @@ ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
|
|||
Initializes the decompression dictionary from the given uncompressed byte
|
||||
sequence. This function must be called immediately after a call of inflate,
|
||||
if that call returned Z_NEED_DICT. The dictionary chosen by the compressor
|
||||
can be determined from the adler32 value returned by that call of inflate.
|
||||
can be determined from the Adler-32 value returned by that call of inflate.
|
||||
The compressor and decompressor must use exactly the same dictionary (see
|
||||
deflateSetDictionary). For raw inflate, this function can be called at any
|
||||
time to set the dictionary. If the provided dictionary is smaller than the
|
||||
|
@ -834,7 +899,7 @@ ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
|
|||
inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
|
||||
parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is
|
||||
inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
|
||||
expected one (incorrect adler32 value). inflateSetDictionary does not
|
||||
expected one (incorrect Adler-32 value). inflateSetDictionary does not
|
||||
perform any decompression: this will be done by subsequent calls of
|
||||
inflate().
|
||||
*/
|
||||
|
@ -892,7 +957,7 @@ ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
|
|||
ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
|
||||
/*
|
||||
This function is equivalent to inflateEnd followed by inflateInit,
|
||||
but does not free and reallocate all the internal decompression state. The
|
||||
but does not free and reallocate the internal decompression state. The
|
||||
stream will keep attributes that may have been set by inflateInit2.
|
||||
|
||||
inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
|
||||
|
@ -904,7 +969,9 @@ ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm,
|
|||
/*
|
||||
This function is the same as inflateReset, but it also permits changing
|
||||
the wrap and window size requests. The windowBits parameter is interpreted
|
||||
the same as it is for inflateInit2.
|
||||
the same as it is for inflateInit2. If the window size is changed, then the
|
||||
memory allocated for the window is freed, and the window will be reallocated
|
||||
by inflate() if needed.
|
||||
|
||||
inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
|
||||
stream state was inconsistent (such as zalloc or state being Z_NULL), or if
|
||||
|
@ -956,7 +1023,7 @@ ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm));
|
|||
location in the input stream can be determined from avail_in and data_type
|
||||
as noted in the description for the Z_BLOCK flush parameter for inflate.
|
||||
|
||||
inflateMark returns the value noted above or -1 << 16 if the provided
|
||||
inflateMark returns the value noted above, or -65536 if the provided
|
||||
source stream state was inconsistent.
|
||||
*/
|
||||
|
||||
|
@ -1048,9 +1115,9 @@ ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
|
|||
This routine would normally be used in a utility that reads zip or gzip
|
||||
files and writes out uncompressed files. The utility would decode the
|
||||
header and process the trailer on its own, hence this routine expects only
|
||||
the raw deflate stream to decompress. This is different from the normal
|
||||
behavior of inflate(), which expects either a zlib or gzip header and
|
||||
trailer around the deflate stream.
|
||||
the raw deflate stream to decompress. This is different from the default
|
||||
behavior of inflate(), which expects a zlib header and trailer around the
|
||||
deflate stream.
|
||||
|
||||
inflateBack() uses two subroutines supplied by the caller that are then
|
||||
called by inflateBack() for input and output. inflateBack() calls those
|
||||
|
@ -1059,12 +1126,12 @@ ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
|
|||
parameters and return types are defined above in the in_func and out_func
|
||||
typedefs. inflateBack() will call in(in_desc, &buf) which should return the
|
||||
number of bytes of provided input, and a pointer to that input in buf. If
|
||||
there is no input available, in() must return zero--buf is ignored in that
|
||||
case--and inflateBack() will return a buffer error. inflateBack() will call
|
||||
out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out()
|
||||
should return zero on success, or non-zero on failure. If out() returns
|
||||
non-zero, inflateBack() will return with an error. Neither in() nor out()
|
||||
are permitted to change the contents of the window provided to
|
||||
there is no input available, in() must return zero -- buf is ignored in that
|
||||
case -- and inflateBack() will return a buffer error. inflateBack() will
|
||||
call out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].
|
||||
out() should return zero on success, or non-zero on failure. If out()
|
||||
returns non-zero, inflateBack() will return with an error. Neither in() nor
|
||||
out() are permitted to change the contents of the window provided to
|
||||
inflateBackInit(), which is also the buffer that out() uses to write from.
|
||||
The length written by out() will be at most the window size. Any non-zero
|
||||
amount of input may be provided by in().
|
||||
|
@ -1092,7 +1159,7 @@ ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
|
|||
using strm->next_in which will be Z_NULL only if in() returned an error. If
|
||||
strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
|
||||
non-zero. (in() will always be called before out(), so strm->next_in is
|
||||
assured to be defined if out() returns non-zero.) Note that inflateBack()
|
||||
assured to be defined if out() returns non-zero.) Note that inflateBack()
|
||||
cannot return Z_OK.
|
||||
*/
|
||||
|
||||
|
@ -1114,7 +1181,7 @@ ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
|
|||
7.6: size of z_off_t
|
||||
|
||||
Compiler, assembler, and debug options:
|
||||
8: DEBUG
|
||||
8: ZLIB_DEBUG
|
||||
9: ASMV or ASMINF -- use ASM code
|
||||
10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
|
||||
11: 0 (reserved)
|
||||
|
@ -1164,7 +1231,8 @@ ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen,
|
|||
the byte length of the source buffer. Upon entry, destLen is the total size
|
||||
of the destination buffer, which must be at least the value returned by
|
||||
compressBound(sourceLen). Upon exit, destLen is the actual size of the
|
||||
compressed buffer.
|
||||
compressed data. compress() is equivalent to compress2() with a level
|
||||
parameter of Z_DEFAULT_COMPRESSION.
|
||||
|
||||
compress returns Z_OK if success, Z_MEM_ERROR if there was not
|
||||
enough memory, Z_BUF_ERROR if there was not enough room in the output
|
||||
|
@ -1180,7 +1248,7 @@ ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen,
|
|||
length of the source buffer. Upon entry, destLen is the total size of the
|
||||
destination buffer, which must be at least the value returned by
|
||||
compressBound(sourceLen). Upon exit, destLen is the actual size of the
|
||||
compressed buffer.
|
||||
compressed data.
|
||||
|
||||
compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
||||
memory, Z_BUF_ERROR if there was not enough room in the output buffer,
|
||||
|
@ -1203,7 +1271,7 @@ ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
|
|||
uncompressed data. (The size of the uncompressed data must have been saved
|
||||
previously by the compressor and transmitted to the decompressor by some
|
||||
mechanism outside the scope of this compression library.) Upon exit, destLen
|
||||
is the actual size of the uncompressed buffer.
|
||||
is the actual size of the uncompressed data.
|
||||
|
||||
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
|
||||
enough memory, Z_BUF_ERROR if there was not enough room in the output
|
||||
|
@ -1212,6 +1280,14 @@ ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
|
|||
buffer with the uncompressed data up to that point.
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest, uLongf *destLen,
|
||||
const Bytef *source, uLong *sourceLen));
|
||||
/*
|
||||
Same as uncompress, except that sourceLen is a pointer, where the
|
||||
length of the source is *sourceLen. On return, *sourceLen is the number of
|
||||
source bytes consumed.
|
||||
*/
|
||||
|
||||
/* gzip file access functions */
|
||||
|
||||
/*
|
||||
|
@ -1290,10 +1366,9 @@ ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size));
|
|||
default buffer size is 8192 bytes. This function must be called after
|
||||
gzopen() or gzdopen(), and before any other calls that read or write the
|
||||
file. The buffer memory allocation is always deferred to the first read or
|
||||
write. Two buffers are allocated, either both of the specified size when
|
||||
writing, or one of the specified size and the other twice that size when
|
||||
reading. A larger buffer size of, for example, 64K or 128K bytes will
|
||||
noticeably increase the speed of decompression (reading).
|
||||
write. Three times that size in buffer space is allocated. A larger buffer
|
||||
size of, for example, 64K or 128K bytes will noticeably increase the speed
|
||||
of decompression (reading).
|
||||
|
||||
The new buffer size also affects the maximum length for gzprintf().
|
||||
|
||||
|
@ -1304,10 +1379,12 @@ ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size));
|
|||
ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
|
||||
/*
|
||||
Dynamically update the compression level or strategy. See the description
|
||||
of deflateInit2 for the meaning of these parameters.
|
||||
of deflateInit2 for the meaning of these parameters. Previously provided
|
||||
data is flushed before the parameter change.
|
||||
|
||||
gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
|
||||
opened for writing.
|
||||
gzsetparams returns Z_OK if success, Z_STREAM_ERROR if the file was not
|
||||
opened for writing, Z_ERRNO if there is an error writing the flushed data,
|
||||
or Z_MEM_ERROR if there is a memory allocation error.
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
|
||||
|
@ -1335,7 +1412,35 @@ ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
|
|||
case.
|
||||
|
||||
gzread returns the number of uncompressed bytes actually read, less than
|
||||
len for end of file, or -1 for error.
|
||||
len for end of file, or -1 for error. If len is too large to fit in an int,
|
||||
then nothing is read, -1 is returned, and the error state is set to
|
||||
Z_STREAM_ERROR.
|
||||
*/
|
||||
|
||||
ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems,
|
||||
gzFile file));
|
||||
/*
|
||||
Read up to nitems items of size size from file to buf, otherwise operating
|
||||
as gzread() does. This duplicates the interface of stdio's fread(), with
|
||||
size_t request and return types. If the library defines size_t, then
|
||||
z_size_t is identical to size_t. If not, then z_size_t is an unsigned
|
||||
integer type that can contain a pointer.
|
||||
|
||||
gzfread() returns the number of full items read of size size, or zero if
|
||||
the end of the file was reached and a full item could not be read, or if
|
||||
there was an error. gzerror() must be consulted if zero is returned in
|
||||
order to determine if there was an error. If the multiplication of size and
|
||||
nitems overflows, i.e. the product does not fit in a z_size_t, then nothing
|
||||
is read, zero is returned, and the error state is set to Z_STREAM_ERROR.
|
||||
|
||||
In the event that the end of file is reached and only a partial item is
|
||||
available at the end, i.e. the remaining uncompressed data length is not a
|
||||
multiple of size, then the final partial item is nevetheless read into buf
|
||||
and the end-of-file flag is set. The length of the partial item read is not
|
||||
provided, but could be inferred from the result of gztell(). This behavior
|
||||
is the same as the behavior of fread() implementations in common libraries,
|
||||
but it prevents the direct use of gzfread() to read a concurrently written
|
||||
file, reseting and retrying on end-of-file, when size is not 1.
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
|
||||
|
@ -1346,19 +1451,33 @@ ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
|
|||
error.
|
||||
*/
|
||||
|
||||
ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size,
|
||||
z_size_t nitems, gzFile file));
|
||||
/*
|
||||
gzfwrite() writes nitems items of size size from buf to file, duplicating
|
||||
the interface of stdio's fwrite(), with size_t request and return types. If
|
||||
the library defines size_t, then z_size_t is identical to size_t. If not,
|
||||
then z_size_t is an unsigned integer type that can contain a pointer.
|
||||
|
||||
gzfwrite() returns the number of full items written of size size, or zero
|
||||
if there was an error. If the multiplication of size and nitems overflows,
|
||||
i.e. the product does not fit in a z_size_t, then nothing is written, zero
|
||||
is returned, and the error state is set to Z_STREAM_ERROR.
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...));
|
||||
/*
|
||||
Converts, formats, and writes the arguments to the compressed file under
|
||||
control of the format string, as in fprintf. gzprintf returns the number of
|
||||
uncompressed bytes actually written, or 0 in case of error. The number of
|
||||
uncompressed bytes written is limited to 8191, or one less than the buffer
|
||||
size given to gzbuffer(). The caller should assure that this limit is not
|
||||
exceeded. If it is exceeded, then gzprintf() will return an error (0) with
|
||||
nothing written. In this case, there may also be a buffer overflow with
|
||||
unpredictable consequences, which is possible only if zlib was compiled with
|
||||
the insecure functions sprintf() or vsprintf() because the secure snprintf()
|
||||
or vsnprintf() functions were not available. This can be determined using
|
||||
zlibCompileFlags().
|
||||
uncompressed bytes actually written, or a negative zlib error code in case
|
||||
of error. The number of uncompressed bytes written is limited to 8191, or
|
||||
one less than the buffer size given to gzbuffer(). The caller should assure
|
||||
that this limit is not exceeded. If it is exceeded, then gzprintf() will
|
||||
return an error (0) with nothing written. In this case, there may also be a
|
||||
buffer overflow with unpredictable consequences, which is possible only if
|
||||
zlib was compiled with the insecure functions sprintf() or vsprintf()
|
||||
because the secure snprintf() or vsnprintf() functions were not available.
|
||||
This can be determined using zlibCompileFlags().
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
|
||||
|
@ -1418,7 +1537,7 @@ ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
|
|||
If the flush parameter is Z_FINISH, the remaining data is written and the
|
||||
gzip stream is completed in the output. If gzwrite() is called again, a new
|
||||
gzip stream will be started in the output. gzread() is able to read such
|
||||
concatented gzip streams.
|
||||
concatenated gzip streams.
|
||||
|
||||
gzflush should be called only when strictly necessary because it will
|
||||
degrade compression if called too often.
|
||||
|
@ -1572,7 +1691,7 @@ ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
|
|||
return the updated checksum. If buf is Z_NULL, this function returns the
|
||||
required initial value for the checksum.
|
||||
|
||||
An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
|
||||
An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed
|
||||
much faster.
|
||||
|
||||
Usage example:
|
||||
|
@ -1585,6 +1704,12 @@ ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
|
|||
if (adler != original_adler) error();
|
||||
*/
|
||||
|
||||
ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf,
|
||||
z_size_t len));
|
||||
/*
|
||||
Same as adler32(), but with a size_t length.
|
||||
*/
|
||||
|
||||
/*
|
||||
ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
|
||||
z_off_t len2));
|
||||
|
@ -1614,6 +1739,12 @@ ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len));
|
|||
if (crc != original_crc) error();
|
||||
*/
|
||||
|
||||
ZEXTERN uLong ZEXPORT crc32_z OF((uLong adler, const Bytef *buf,
|
||||
z_size_t len));
|
||||
/*
|
||||
Same as crc32(), but with a size_t length.
|
||||
*/
|
||||
|
||||
/*
|
||||
ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
|
||||
|
||||
|
@ -1644,19 +1775,35 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
|
|||
unsigned char FAR *window,
|
||||
const char *version,
|
||||
int stream_size));
|
||||
#define deflateInit(strm, level) \
|
||||
deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
|
||||
#define inflateInit(strm) \
|
||||
inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
|
||||
#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
|
||||
deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
|
||||
(strategy), ZLIB_VERSION, (int)sizeof(z_stream))
|
||||
#define inflateInit2(strm, windowBits) \
|
||||
inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
|
||||
(int)sizeof(z_stream))
|
||||
#define inflateBackInit(strm, windowBits, window) \
|
||||
inflateBackInit_((strm), (windowBits), (window), \
|
||||
ZLIB_VERSION, (int)sizeof(z_stream))
|
||||
#ifdef Z_PREFIX_SET
|
||||
# define z_deflateInit(strm, level) \
|
||||
deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
|
||||
# define z_inflateInit(strm) \
|
||||
inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
|
||||
# define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
|
||||
deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
|
||||
(strategy), ZLIB_VERSION, (int)sizeof(z_stream))
|
||||
# define z_inflateInit2(strm, windowBits) \
|
||||
inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
|
||||
(int)sizeof(z_stream))
|
||||
# define z_inflateBackInit(strm, windowBits, window) \
|
||||
inflateBackInit_((strm), (windowBits), (window), \
|
||||
ZLIB_VERSION, (int)sizeof(z_stream))
|
||||
#else
|
||||
# define deflateInit(strm, level) \
|
||||
deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
|
||||
# define inflateInit(strm) \
|
||||
inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
|
||||
# define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
|
||||
deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
|
||||
(strategy), ZLIB_VERSION, (int)sizeof(z_stream))
|
||||
# define inflateInit2(strm, windowBits) \
|
||||
inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
|
||||
(int)sizeof(z_stream))
|
||||
# define inflateBackInit(strm, windowBits, window) \
|
||||
inflateBackInit_((strm), (windowBits), (window), \
|
||||
ZLIB_VERSION, (int)sizeof(z_stream))
|
||||
#endif
|
||||
|
||||
#ifndef Z_SOLO
|
||||
|
||||
|
@ -1676,10 +1823,10 @@ ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */
|
|||
#ifdef Z_PREFIX_SET
|
||||
# undef z_gzgetc
|
||||
# define z_gzgetc(g) \
|
||||
((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
|
||||
((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
|
||||
#else
|
||||
# define gzgetc(g) \
|
||||
((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
|
||||
((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
|
||||
#endif
|
||||
|
||||
/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
|
||||
|
@ -1737,19 +1884,16 @@ ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */
|
|||
|
||||
#endif /* !Z_SOLO */
|
||||
|
||||
/* hack for buggy compilers */
|
||||
#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
|
||||
struct internal_state {int dummy;};
|
||||
#endif
|
||||
|
||||
/* undocumented functions */
|
||||
ZEXTERN const char * ZEXPORT zError OF((int));
|
||||
ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp));
|
||||
ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void));
|
||||
ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int));
|
||||
ZEXTERN int ZEXPORT inflateValidate OF((z_streamp, int));
|
||||
ZEXTERN unsigned long ZEXPORT inflateCodesUsed OF ((z_streamp));
|
||||
ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp));
|
||||
ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp));
|
||||
#if defined(_WIN32) && !defined(Z_SOLO)
|
||||
#if (defined(_WIN32) || defined(__CYGWIN__)) && !defined(Z_SOLO)
|
||||
ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path,
|
||||
const char *mode));
|
||||
#endif
|
||||
|
|
49
zlib/zutil.c
49
zlib/zutil.c
|
@ -1,5 +1,5 @@
|
|||
/* zutil.c -- target dependent utility functions for the compression library
|
||||
* Copyright (C) 1995-2005, 2010, 2011, 2012 Jean-loup Gailly.
|
||||
* Copyright (C) 1995-2017 Jean-loup Gailly
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
|
@ -10,21 +10,18 @@
|
|||
# include "gzguts.h"
|
||||
#endif
|
||||
|
||||
#ifndef NO_DUMMY_DECL
|
||||
struct internal_state {int dummy;}; /* for buggy compilers */
|
||||
#endif
|
||||
|
||||
z_const char * const z_errmsg[10] = {
|
||||
"need dictionary", /* Z_NEED_DICT 2 */
|
||||
"stream end", /* Z_STREAM_END 1 */
|
||||
"", /* Z_OK 0 */
|
||||
"file error", /* Z_ERRNO (-1) */
|
||||
"stream error", /* Z_STREAM_ERROR (-2) */
|
||||
"data error", /* Z_DATA_ERROR (-3) */
|
||||
"insufficient memory", /* Z_MEM_ERROR (-4) */
|
||||
"buffer error", /* Z_BUF_ERROR (-5) */
|
||||
"incompatible version",/* Z_VERSION_ERROR (-6) */
|
||||
""};
|
||||
(z_const char *)"need dictionary", /* Z_NEED_DICT 2 */
|
||||
(z_const char *)"stream end", /* Z_STREAM_END 1 */
|
||||
(z_const char *)"", /* Z_OK 0 */
|
||||
(z_const char *)"file error", /* Z_ERRNO (-1) */
|
||||
(z_const char *)"stream error", /* Z_STREAM_ERROR (-2) */
|
||||
(z_const char *)"data error", /* Z_DATA_ERROR (-3) */
|
||||
(z_const char *)"insufficient memory", /* Z_MEM_ERROR (-4) */
|
||||
(z_const char *)"buffer error", /* Z_BUF_ERROR (-5) */
|
||||
(z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */
|
||||
(z_const char *)""
|
||||
};
|
||||
|
||||
|
||||
const char * ZEXPORT zlibVersion()
|
||||
|
@ -61,7 +58,7 @@ uLong ZEXPORT zlibCompileFlags()
|
|||
case 8: flags += 2 << 6; break;
|
||||
default: flags += 3 << 6;
|
||||
}
|
||||
#ifdef DEBUG
|
||||
#ifdef ZLIB_DEBUG
|
||||
flags += 1 << 8;
|
||||
#endif
|
||||
#if defined(ASMV) || defined(ASMINF)
|
||||
|
@ -115,8 +112,8 @@ uLong ZEXPORT zlibCompileFlags()
|
|||
return flags;
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
|
||||
#ifdef ZLIB_DEBUG
|
||||
#include <stdlib.h>
|
||||
# ifndef verbose
|
||||
# define verbose 0
|
||||
# endif
|
||||
|
@ -219,9 +216,11 @@ local ptr_table table[MAX_PTR];
|
|||
|
||||
voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
|
||||
{
|
||||
voidpf buf = opaque; /* just to make some compilers happy */
|
||||
voidpf buf;
|
||||
ulg bsize = (ulg)items*size;
|
||||
|
||||
(void)opaque;
|
||||
|
||||
/* If we allocate less than 65520 bytes, we assume that farmalloc
|
||||
* will return a usable pointer which doesn't have to be normalized.
|
||||
*/
|
||||
|
@ -244,6 +243,9 @@ voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
|
|||
void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
|
||||
{
|
||||
int n;
|
||||
|
||||
(void)opaque;
|
||||
|
||||
if (*(ush*)&ptr != 0) { /* object < 64K */
|
||||
farfree(ptr);
|
||||
return;
|
||||
|
@ -259,7 +261,6 @@ void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
|
|||
next_ptr--;
|
||||
return;
|
||||
}
|
||||
ptr = opaque; /* just to make some compilers happy */
|
||||
Assert(0, "zcfree: ptr not found");
|
||||
}
|
||||
|
||||
|
@ -278,13 +279,13 @@ void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
|
|||
|
||||
voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
|
||||
{
|
||||
if (opaque) opaque = 0; /* to make compiler happy */
|
||||
(void)opaque;
|
||||
return _halloc((long)items, size);
|
||||
}
|
||||
|
||||
void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
|
||||
{
|
||||
if (opaque) opaque = 0; /* to make compiler happy */
|
||||
(void)opaque;
|
||||
_hfree(ptr);
|
||||
}
|
||||
|
||||
|
@ -306,7 +307,7 @@ voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
|
|||
unsigned items;
|
||||
unsigned size;
|
||||
{
|
||||
if (opaque) items += size - size; /* make compiler happy */
|
||||
(void)opaque;
|
||||
return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
|
||||
(voidpf)calloc(items, size);
|
||||
}
|
||||
|
@ -315,8 +316,8 @@ void ZLIB_INTERNAL zcfree (opaque, ptr)
|
|||
voidpf opaque;
|
||||
voidpf ptr;
|
||||
{
|
||||
(void)opaque;
|
||||
free(ptr);
|
||||
if (opaque) return; /* make compiler happy */
|
||||
}
|
||||
|
||||
#endif /* MY_ZCALLOC */
|
||||
|
|
52
zlib/zutil.h
52
zlib/zutil.h
|
@ -1,5 +1,5 @@
|
|||
/* zutil.h -- internal interface and configuration of the compression library
|
||||
* Copyright (C) 1995-2013 Jean-loup Gailly.
|
||||
* Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
|
@ -36,7 +36,9 @@
|
|||
#ifndef local
|
||||
# define local static
|
||||
#endif
|
||||
/* compile with -Dlocal if your debugger can't find static symbols */
|
||||
/* since "static" is used to mean two completely different things in C, we
|
||||
define "local" for the non-static meaning of "static", for readability
|
||||
(compile with -Dlocal if your debugger can't find static symbols) */
|
||||
|
||||
typedef unsigned char uch;
|
||||
typedef uch FAR uchf;
|
||||
|
@ -98,28 +100,38 @@ extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
|
|||
#endif
|
||||
|
||||
#ifdef AMIGA
|
||||
# define OS_CODE 0x01
|
||||
# define OS_CODE 1
|
||||
#endif
|
||||
|
||||
#if defined(VAXC) || defined(VMS)
|
||||
# define OS_CODE 0x02
|
||||
# define OS_CODE 2
|
||||
# define F_OPEN(name, mode) \
|
||||
fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
|
||||
#endif
|
||||
|
||||
#ifdef __370__
|
||||
# if __TARGET_LIB__ < 0x20000000
|
||||
# define OS_CODE 4
|
||||
# elif __TARGET_LIB__ < 0x40000000
|
||||
# define OS_CODE 11
|
||||
# else
|
||||
# define OS_CODE 8
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined(ATARI) || defined(atarist)
|
||||
# define OS_CODE 0x05
|
||||
# define OS_CODE 5
|
||||
#endif
|
||||
|
||||
#ifdef OS2
|
||||
# define OS_CODE 0x06
|
||||
# define OS_CODE 6
|
||||
# if defined(M_I86) && !defined(Z_SOLO)
|
||||
# include <malloc.h>
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined(MACOS) || defined(TARGET_OS_MAC)
|
||||
# define OS_CODE 0x07
|
||||
# define OS_CODE 7
|
||||
# ifndef Z_SOLO
|
||||
# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
|
||||
# include <unix.h> /* for fdopen */
|
||||
|
@ -131,18 +143,24 @@ extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
|
|||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef TOPS20
|
||||
# define OS_CODE 0x0a
|
||||
#ifdef __acorn
|
||||
# define OS_CODE 13
|
||||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
# ifndef __CYGWIN__ /* Cygwin is Unix, not Win32 */
|
||||
# define OS_CODE 0x0b
|
||||
# endif
|
||||
#if defined(WIN32) && !defined(__CYGWIN__)
|
||||
# define OS_CODE 10
|
||||
#endif
|
||||
|
||||
#ifdef __50SERIES /* Prime/PRIMOS */
|
||||
# define OS_CODE 0x0f
|
||||
#ifdef _BEOS_
|
||||
# define OS_CODE 16
|
||||
#endif
|
||||
|
||||
#ifdef __TOS_OS400__
|
||||
# define OS_CODE 18
|
||||
#endif
|
||||
|
||||
#ifdef __APPLE__
|
||||
# define OS_CODE 19
|
||||
#endif
|
||||
|
||||
#if defined(_BEOS_) || defined(RISCOS)
|
||||
|
@ -177,7 +195,7 @@ extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
|
|||
/* common defaults */
|
||||
|
||||
#ifndef OS_CODE
|
||||
# define OS_CODE 0x03 /* assume Unix */
|
||||
# define OS_CODE 3 /* assume Unix */
|
||||
#endif
|
||||
|
||||
#ifndef F_OPEN
|
||||
|
@ -216,7 +234,7 @@ extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
|
|||
#endif
|
||||
|
||||
/* Diagnostic functions */
|
||||
#ifdef DEBUG
|
||||
#ifdef ZLIB_DEBUG
|
||||
# include <stdio.h>
|
||||
extern int ZLIB_INTERNAL z_verbose;
|
||||
extern void ZLIB_INTERNAL z_error OF((char *m));
|
||||
|
|
Loading…
Reference in a new issue