ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2044 from TASVideos/nyma 

Add 'nyma' project

The goal is to eventually update all of our Mednafen cores. For now, there is a work in progress import of the Mednafen pce core. Basic gameplay with hucard, turbocd, and supergrafix is supported, but the core is not complete yet.
This commit is contained in:
nattthebear 2020-05-25 13:54:35 -04:00 committed by GitHub
parent fbb47b2297 9ec8536a5e
commit 07c627cc3e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
132 changed files with 23416 additions and 884 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitmodules vendored
View File

@ -22,3 +22,6 @@
[submodule "waterbox/musl"]
path = waterbox/musl
url = https://github.com/nattthebear/musl.git
[submodule "waterbox/nyma/mednafen"]
path = waterbox/nyma/mednafen
url = https://github.com/TASVideos/mednafen.git

BIN
output/dll/gpgx.wbx.gz
View File

Binary file not shown.

BIN
output/dll/libsnes.wbx.gz
View File

Binary file not shown.

BIN
output/dll/ngp.wbx.gz
View File

Binary file not shown.

BIN
output/dll/pcfx.wbx.gz
View File

Binary file not shown.

BIN
output/dll/picodrive.wbx.gz
View File

Binary file not shown.

BIN
output/dll/sameboy.wbx.gz
View File

Binary file not shown.

BIN
output/dll/snes9x.wbx.gz
View File

Binary file not shown.

BIN
output/dll/ss.wbx.gz
View File

Binary file not shown.

BIN
output/dll/uzem.wbx.gz
View File

Binary file not shown.

BIN
output/dll/vb.wbx.gz
View File

Binary file not shown.

4
src/BizHawk.BizInvoke/BizInvoker.cs
View File

@ -287,7 +287,7 @@ namespace BizHawk.BizInvoke
var paramTypes = paramInfos.Select(p => p.ParameterType).ToArray();
var nativeParamTypes = new List<Type>();
var returnType = baseMethod.ReturnType;
if (returnType != typeof(void) && !returnType.IsPrimitive)
if (returnType != typeof(void) && !returnType.IsPrimitive && !returnType.IsPointer)
{
throw new InvalidOperationException("Only primitive return types are supported");
}
@ -527,7 +527,7 @@ namespace BizHawk.BizInvoke
return typeof(IntPtr);
}
if (type.IsPrimitive || type.IsEnum)
if (type.IsPrimitive || type.IsEnum || type.IsPointer)
{
il.Emit(OpCodes.Ldarg, (short)idx);
return type;

23
src/BizHawk.BizInvoke/IMemoryBlockPal.cs Normal file
View File

@ -0,0 +1,23 @@
using System;
namespace BizHawk.BizInvoke
{
/// <summary>
/// Platform abstraction layer over mmap like functionality
/// </summary>
public interface IMemoryBlockPal : IDisposable
{
/// <summary>
/// Map in the memory area at the predetermined address
/// </summary>
void Activate();
/// <summary>
/// Unmap the memory area
/// </summary>
void Deactivate();
/// <summary>
/// Change protection on some addresses, guaranteed to be page aligned and in the memory area
/// </summary>
void Protect(ulong start, ulong size, MemoryBlock.Protection prot);
}
}

163
src/BizHawk.BizInvoke/MemoryBlock.cs
View File

@ -5,11 +5,11 @@ using BizHawk.Common;
namespace BizHawk.BizInvoke
{
public abstract class MemoryBlock : IDisposable
public class MemoryBlock : IDisposable
{
/// <summary>allocate <paramref name="size"/> bytes starting at a particular address <paramref name="start"/></summary>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="start"/> is not aligned or <paramref name="size"/> is <c>0</c></exception>
protected MemoryBlock(ulong start, ulong size)
public MemoryBlock(ulong start, ulong size)
{
if (!WaterboxUtils.Aligned(start))
throw new ArgumentOutOfRangeException(nameof(start), start, "start address must be aligned");
@ -19,8 +19,14 @@ namespace BizHawk.BizInvoke
Size = WaterboxUtils.AlignUp(size);
EndExclusive = Start + Size;
_pageData = new Protection[GetPage(EndExclusive - 1) + 1];
_pal = OSTailoredCode.IsUnixHost
? (IMemoryBlockPal)new MemoryBlockUnixPal(Start, Size)
: new MemoryBlockWindowsPal(Start, Size);
}
private IMemoryBlockPal _pal;
/// <summary>stores last set memory protection value for each page</summary>
protected readonly Protection[] _pageData;
@ -51,8 +57,13 @@ namespace BizHawk.BizInvoke
/// <summary>get a start address for a page index within the block</summary>
protected ulong GetStartAddr(int page) => ((ulong) page << WaterboxUtils.PageShift) + Start;
/// <summary>Get a stream that can be used to read or write from part of the block. Does not check for or change <see cref="Protect"/>!</summary>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="start"/> or end (= <paramref name="start"/> + <paramref name="length"/> - <c>1</c>) are outside [<see cref="Start"/>, <see cref="EndExclusive"/>), the range of the block</exception>
/// <summary>
/// Get a stream that can be used to read or write from part of the block. Does not check for or change <see cref="Protect"/>!
/// </summary>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="start"/> or end (= <paramref name="start"/> + <paramref name="length"/> - <c>1</c>)
/// are outside [<see cref="Start"/>, <see cref="EndExclusive"/>), the range of the block
/// </exception>
public Stream GetStream(ulong start, ulong length, bool writer)
{
if (start < Start)
@ -62,52 +73,138 @@ namespace BizHawk.BizInvoke
return new MemoryViewStream(!writer, writer, (long) start, (long) length, this);
}
/// <summary>get a stream that can be used to read or write from part of the block. both reads and writes will be XORed against an earlier recorded snapshot</summary>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="start"/> or end (= <paramref name="start"/> + <paramref name="length"/> - <c>1</c>) are outside [<see cref="Start"/>, <see cref="EndExclusive"/>), the range of the block</exception>
/// <summary>
/// get a stream that can be used to read or write from part of the block.
/// both reads and writes will be XORed against an earlier recorded snapshot
/// </summary>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="start"/> or end (= <paramref name="start"/> + <paramref name="length"/> - <c>1</c>) are outside
/// [<see cref="Start"/>, <see cref="EndExclusive"/>), the range of the block
/// </exception>
/// <exception cref="InvalidOperationException">no snapshot taken (haven't called <see cref="SaveXorSnapshot"/>)</exception>
public Stream GetXorStream(ulong start, ulong length, bool writer)
{
if (start < Start) throw new ArgumentOutOfRangeException(nameof(start), start, "invalid address");
if (EndExclusive < start + length) throw new ArgumentOutOfRangeException(nameof(length), length, "requested length implies invalid end address");
if (_snapshot == null) throw new InvalidOperationException("No snapshot taken!");
if (start < Start)
throw new ArgumentOutOfRangeException(nameof(start), start, "invalid address");
if (EndExclusive < start + length)
throw new ArgumentOutOfRangeException(nameof(length), length, "requested length implies invalid end address");
if (_snapshot == null)
throw new InvalidOperationException("No snapshot taken!");
return new MemoryViewXorStream(!writer, writer, (long) start, (long) length, this, _snapshot, (long) (start - Start));
}
/// <summary>activate the memory block, swapping it in at the pre-specified address</summary>
public abstract void Activate();
/// <exception cref="InvalidOperationException"><see cref="MemoryBlock.Active"/> is <see langword="true"/> or failed to map file view</exception>
public void Activate()
{
if (Active)
throw new InvalidOperationException("Already active");
_pal.Activate();
ProtectAll();
Active = true;
}
/// <summary>deactivate the memory block, removing it from RAM but leaving it immediately available to swap back in</summary>
public abstract void Deactivate();
/// <exception cref="InvalidOperationException">
/// <see cref="MemoryBlock.Active"/> is <see langword="false"/> or failed to unmap file view
/// </exception>
public void Deactivate()
{
if (!Active)
throw new InvalidOperationException("Not active");
_pal.Deactivate();
Active = false;
}
/// <summary>take a hash of the current full contents of the block, including unreadable areas</summary>
public abstract byte[] FullHash();
/// <exception cref="InvalidOperationException">
/// <see cref="MemoryBlock.Active"/> is <see langword="false"/> or failed to make memory read-only
/// </exception>
public byte[] FullHash()
{
if (!Active)
throw new InvalidOperationException("Not active");
// temporarily switch the entire block to `R`
_pal.Protect(Start, Size, Protection.R);
var ret = WaterboxUtils.Hash(GetStream(Start, Size, false));
ProtectAll();
return ret;
}
/// <summary>set r/w/x protection on a portion of memory. rounded to encompassing pages</summary>
public abstract void Protect(ulong start, ulong length, Protection prot);
/// <summary>set r/w/x protection on a portion of memory. rounded to encompassing pages</summary
/// <exception cref="InvalidOperationException">failed to protect memory</exception>
public void Protect(ulong start, ulong length, Protection prot)
{
if (length == 0)
return;
int pstart = GetPage(start);
int pend = GetPage(start + length - 1);
for (int i = pstart; i <= pend; i++)
_pageData[i] = prot; // also store the value for later use
if (Active) // it's legal to Protect() if we're not active; the information is just saved for the next activation
{
var computedStart = WaterboxUtils.AlignDown(start);
var computedEnd = WaterboxUtils.AlignUp(start + length);
var computedLength = computedEnd - computedStart;
_pal.Protect(computedStart, computedLength, prot);
}
}
/// <summary>restore all recorded protections</summary>
protected abstract void ProtectAll();
private void ProtectAll()
{
int ps = 0;
for (int i = 0; i < _pageData.Length; i++)
{
if (i == _pageData.Length - 1 || _pageData[i] != _pageData[i + 1])
{
ulong zstart = GetStartAddr(ps);
ulong zend = GetStartAddr(i + 1);
_pal.Protect(zstart, zend - zstart, _pageData[i]);
ps = i + 1;
}
}
}
/// <summary>take a snapshot of the entire memory block's contents, for use in <see cref="GetXorStream"/></summary>
public abstract void SaveXorSnapshot();
/// <exception cref="InvalidOperationException">
/// snapshot already taken, <see cref="MemoryBlock.Active"/> is <see langword="false"/>, or failed to make memory read-only
/// </exception>
public void SaveXorSnapshot()
{
if (_snapshot != null)
throw new InvalidOperationException("Snapshot already taken");
if (!Active)
throw new InvalidOperationException("Not active");
public abstract void Dispose(bool disposing);
// temporarily switch the entire block to `R`: in case some areas are unreadable, we don't want
// that to complicate things
_pal.Protect(Start, Size, Protection.R);
_snapshot = new byte[Size];
var ds = new MemoryStream(_snapshot, true);
var ss = GetStream(Start, Size, false);
ss.CopyTo(ds);
XorHash = WaterboxUtils.Hash(_snapshot);
ProtectAll();
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
~MemoryBlock()
{
Dispose(false);
if (_pal != null)
{
_pal.Dispose();
_pal = null;
}
}
/// <summary>allocate <paramref name="size"/> bytes starting at a particular address <paramref name="start"/></summary>
public static MemoryBlock Create(ulong start, ulong size) => OSTailoredCode.IsUnixHost
? (MemoryBlock) new MemoryBlockUnix(start, size)
: new MemoryBlockWindows(start, size);
public static MemoryBlock Create(ulong start, ulong size) => new MemoryBlock(start, size);
/// <summary>allocate <paramref name="size"/> bytes at any address</summary>
public static MemoryBlock Create(ulong size) => Create(0, size);
@ -159,8 +256,10 @@ namespace BizHawk.BizInvoke
public override int Read(byte[] buffer, int offset, int count)
{
if (!_readable) throw new InvalidOperationException();
if (count < 0 || buffer.Length < count + offset) throw new ArgumentOutOfRangeException();
if (!_readable)
throw new InvalidOperationException();
if (count < 0 || buffer.Length < count + offset)
throw new ArgumentOutOfRangeException();
EnsureNotDisposed();
count = (int) Math.Min(count, _length - _pos);
@ -196,8 +295,10 @@ namespace BizHawk.BizInvoke
public override void Write(byte[] buffer, int offset, int count)
{
if (!_writable) throw new InvalidOperationException();
if (count < 0 || _length - _pos < count || buffer.Length < count + offset) throw new ArgumentOutOfRangeException();
if (!_writable)
throw new InvalidOperationException();
if (count < 0 || _length - _pos < count || buffer.Length < count + offset)
throw new ArgumentOutOfRangeException();
EnsureNotDisposed();
Marshal.Copy(buffer, offset, Z.SS(_ptr + _pos), count);

133
src/BizHawk.BizInvoke/MemoryBlockUnix.cs
View File

@ -1,133 +0,0 @@
using System;
using System.IO;
using static BizHawk.BizInvoke.POSIXLibC;
namespace BizHawk.BizInvoke
{
public sealed class MemoryBlockUnix : MemoryBlock
{
/// <summary>handle returned by <see cref="memfd_create"/></summary>
private int _fd;
/// <inheritdoc cref="MemoryBlock(ulong,ulong)"/>
/// <exception cref="InvalidOperationException">failed to get file descriptor (never thrown as <see cref="NotImplementedException"/> is thrown first)</exception>
/// <exception cref="NotImplementedException">always</exception>
public MemoryBlockUnix(ulong start, ulong size) : base(start, size)
{
throw new NotImplementedException($"{nameof(MemoryBlockUnix)} ctor");
#if false
_fd = memfd_create("MemoryBlockUnix", 0);
if (_fd == -1) throw new InvalidOperationException($"{nameof(memfd_create)}() returned -1");
#endif
}
/// <exception cref="InvalidOperationException"><see cref="MemoryBlock.Active"/> is <see langword="true"/> or failed to map memory</exception>
public override void Activate()
{
if (Active) throw new InvalidOperationException("Already active");
var ptr = mmap(Z.US(Start), Z.UU(Size), MemoryProtection.Read | MemoryProtection.Write | MemoryProtection.Execute, 16, _fd, IntPtr.Zero);
if (ptr != Z.US(Start)) throw new InvalidOperationException($"{nameof(mmap)}() returned NULL or the wrong pointer");
ProtectAll();
Active = true;
}
/// <exception cref="InvalidOperationException"><see cref="MemoryBlock.Active"/> is <see langword="false"/> or failed to unmap memory</exception>
public override void Deactivate()
{
if (!Active) throw new InvalidOperationException("Not active");
var exitCode = munmap(Z.US(Start), Z.UU(Size));
if (exitCode != 0) throw new InvalidOperationException($"{nameof(munmap)}() returned {exitCode}");
Active = false;
}
/// <exception cref="InvalidOperationException"><see cref="MemoryBlock.Active"/> is <see langword="false"/> or failed to make memory read-only</exception>
public override byte[] FullHash()
{
if (!Active) throw new InvalidOperationException("Not active");
// temporarily switch the entire block to `R`
var exitCode = mprotect(Z.US(Start), Z.UU(Size), MemoryProtection.Read);
if (exitCode != 0) throw new InvalidOperationException($"{nameof(mprotect)}() returned {exitCode}!");
var ret = WaterboxUtils.Hash(GetStream(Start, Size, false));
ProtectAll();
return ret;
}
/// <exception cref="InvalidOperationException">failed to protect memory</exception>
public override void Protect(ulong start, ulong length, Protection prot)
{
if (length == 0) return;
var pstart = GetPage(start);
var pend = GetPage(start + length - 1);
for (var i = pstart; i <= pend; i++) _pageData[i] = prot; // also store the value for later use
if (!Active) return; // it's legal to call this method if we're not active; the information is just saved for the next activation
var computedStart = WaterboxUtils.AlignDown(start);
var protEnum = prot.ToMemoryProtection();
var exitCode = mprotect(
Z.US(computedStart),
Z.UU(WaterboxUtils.AlignUp(start + length) - computedStart),
protEnum
);
if (exitCode != 0) throw new InvalidOperationException($"{nameof(mprotect)}() returned {exitCode}!");
}
protected override void ProtectAll()
{
var ps = 0;
for (var i = 0; i < _pageData.Length; i++)
{
if (i == _pageData.Length - 1 || _pageData[i] != _pageData[i + 1])
{
var protEnum = _pageData[i].ToMemoryProtection();
var zstart = GetStartAddr(ps);
var exitCode = mprotect(
Z.US(zstart),
Z.UU(GetStartAddr(i + 1) - zstart),
protEnum
);
if (exitCode != 0) throw new InvalidOperationException($"{nameof(mprotect)}() returned {exitCode}!");
ps = i + 1;
}
}
}
/// <exception cref="InvalidOperationException">snapshot already taken, <see cref="MemoryBlock.Active"/> is <see langword="false"/>, or failed to make memory read-only</exception>
public override void SaveXorSnapshot()
{
if (_snapshot != null) throw new InvalidOperationException("Snapshot already taken");
if (!Active) throw new InvalidOperationException("Not active");
// temporarily switch the entire block to `R`: in case some areas are unreadable, we don't want that to complicate things
var exitCode = mprotect(Z.US(Start), Z.UU(Size), MemoryProtection.Read);
if (exitCode != 0) throw new InvalidOperationException($"{nameof(mprotect)}() returned {exitCode}!");
_snapshot = new byte[Size];
GetStream(Start, Size, false).CopyTo(new MemoryStream(_snapshot, true));
XorHash = WaterboxUtils.Hash(_snapshot);
ProtectAll();
}
public override void Dispose(bool disposing)
{
if (_fd == 0) return;
if (Active) Deactivate();
close(_fd);
_fd = -1;
}
~MemoryBlockUnix()
{
Dispose(false);
}
}
}

72
src/BizHawk.BizInvoke/MemoryBlockUnixPal.cs Normal file
View File

@ -0,0 +1,72 @@
using System;
using static BizHawk.BizInvoke.MemoryBlock;
using static BizHawk.BizInvoke.POSIXLibC;
namespace BizHawk.BizInvoke
{
public sealed class MemoryBlockUnixPal : IMemoryBlockPal
{
/// <summary>handle returned by <see cref="memfd_create"/></summary>
private int _fd = -1;
private ulong _start;
private ulong _size;
/// <summary>
/// Reserve bytes to later be swapped in, but do not map them
/// </summary>
/// <param name="start">eventual mapped address</param>
/// <param name="size"></param>
/// <exception cref="InvalidOperationException">failed to get file descriptor (never thrown as <see cref="NotImplementedException"/> is thrown first)</exception>
/// <exception cref="NotImplementedException">always</exception>
public MemoryBlockUnixPal(ulong start, ulong size)
{
_start = start;
_size = size;
throw new NotImplementedException($"{nameof(MemoryBlockUnixPal)} ctor");
#if false
_fd = memfd_create("MemoryBlockUnix", 0);
if (_fd == -1)
throw new InvalidOperationException($"{nameof(memfd_create)}() returned -1");
#endif
}
public void Dispose()
{
if (_fd == -1)
return;
close(_fd);
_fd = -1;
GC.SuppressFinalize(this);
}
~MemoryBlockUnixPal()
{
Dispose();
}
public void Activate()
{
var ptr = mmap(Z.US(_start), Z.UU(_size), MemoryProtection.Read | MemoryProtection.Write | MemoryProtection.Execute, 16, _fd, IntPtr.Zero);
if (ptr != Z.US(_start))
throw new InvalidOperationException($"{nameof(mmap)}() returned NULL or the wrong pointer");
}
public void Deactivate()
{
var exitCode = munmap(Z.US(_start), Z.UU(_size));
if (exitCode != 0)
throw new InvalidOperationException($"{nameof(munmap)}() returned {exitCode}");
}
public void Protect(ulong start, ulong size, Protection prot)
{
var exitCode = mprotect(
Z.US(start),
Z.UU(size),
prot.ToMemoryProtection()
);
if (exitCode != 0)
throw new InvalidOperationException($"{nameof(mprotect)}() returned {exitCode}!");
}
}
}

238
src/BizHawk.BizInvoke/MemoryBlockWindows.cs
View File

@ -1,238 +0,0 @@
using System;
using System.Runtime.InteropServices;
using System.IO;
namespace BizHawk.BizInvoke
{
public sealed class MemoryBlockWindows : MemoryBlock
{
/// <summary>
/// handle returned by CreateFileMapping
/// </summary>
private IntPtr _handle;
/// <inheritdoc cref="MemoryBlock(ulong,ulong)"/>
/// <exception cref="InvalidOperationException">failed to create file mapping</exception>
public MemoryBlockWindows(ulong start, ulong size) : base(start, size)
{
_handle = Kernel32.CreateFileMapping(
Kernel32.INVALID_HANDLE_VALUE,
IntPtr.Zero,
Kernel32.FileMapProtection.PageExecuteReadWrite | Kernel32.FileMapProtection.SectionCommit,
(uint)(Size >> 32),
(uint)Size,
null
);
if (_handle == IntPtr.Zero) throw new InvalidOperationException($"{nameof(Kernel32.CreateFileMapping)}() returned NULL");
}
/// <exception cref="InvalidOperationException"><see cref="MemoryBlock.Active"/> is <see langword="true"/> or failed to map file view</exception>
public override void Activate()
{
if (Active)
throw new InvalidOperationException("Already active");
if (Kernel32.MapViewOfFileEx(
_handle,
Kernel32.FileMapAccessType.Read | Kernel32.FileMapAccessType.Write | Kernel32.FileMapAccessType.Execute,
0,
0,
Z.UU(Size),
Z.US(Start)
) != Z.US(Start))
{
throw new InvalidOperationException($"{nameof(Kernel32.MapViewOfFileEx)}() returned NULL");
}
ProtectAll();
Active = true;
}
/// <exception cref="InvalidOperationException"><see cref="MemoryBlock.Active"/> is <see langword="false"/> or failed to unmap file view</exception>
public override void Deactivate()
{
if (!Active)
throw new InvalidOperationException("Not active");
if (!Kernel32.UnmapViewOfFile(Z.US(Start)))
throw new InvalidOperationException($"{nameof(Kernel32.UnmapViewOfFile)}() returned NULL");
Active = false;
}
/// <exception cref="InvalidOperationException">snapshot already taken, <see cref="MemoryBlock.Active"/> is <see langword="false"/>, or failed to make memory read-only</exception>
public override void SaveXorSnapshot()
{
if (_snapshot != null)
throw new InvalidOperationException("Snapshot already taken");
if (!Active)
throw new InvalidOperationException("Not active");
// temporarily switch the entire block to `R`: in case some areas are unreadable, we don't want
// that to complicate things
Kernel32.MemoryProtection old;
if (!Kernel32.VirtualProtect(Z.UU(Start), Z.UU(Size), Kernel32.MemoryProtection.READONLY, out old))
throw new InvalidOperationException($"{nameof(Kernel32.VirtualProtect)}() returned FALSE!");
_snapshot = new byte[Size];
var ds = new MemoryStream(_snapshot, true);
var ss = GetStream(Start, Size, false);
ss.CopyTo(ds);
XorHash = WaterboxUtils.Hash(_snapshot);
ProtectAll();
}
/// <exception cref="InvalidOperationException"><see cref="MemoryBlock.Active"/> is <see langword="false"/> or failed to make memory read-only</exception>
public override byte[] FullHash()
{
if (!Active)
throw new InvalidOperationException("Not active");
// temporarily switch the entire block to `R`
Kernel32.MemoryProtection old;
if (!Kernel32.VirtualProtect(Z.UU(Start), Z.UU(Size), Kernel32.MemoryProtection.READONLY, out old))
throw new InvalidOperationException($"{nameof(Kernel32.VirtualProtect)}() returned FALSE!");
var ret = WaterboxUtils.Hash(GetStream(Start, Size, false));
ProtectAll();
return ret;
}
private static Kernel32.MemoryProtection GetKernelMemoryProtectionValue(Protection prot)
{
Kernel32.MemoryProtection p;
switch (prot)
{
case Protection.None: p = Kernel32.MemoryProtection.NOACCESS; break;
case Protection.R: p = Kernel32.MemoryProtection.READONLY; break;
case Protection.RW: p = Kernel32.MemoryProtection.READWRITE; break;
case Protection.RX: p = Kernel32.MemoryProtection.EXECUTE_READ; break;
default: throw new ArgumentOutOfRangeException(nameof(prot));
}
return p;
}
protected override void ProtectAll()
{
int ps = 0;
for (int i = 0; i < _pageData.Length; i++)
{
if (i == _pageData.Length - 1 || _pageData[i] != _pageData[i + 1])
{
var p = GetKernelMemoryProtectionValue(_pageData[i]);
ulong zstart = GetStartAddr(ps);
ulong zend = GetStartAddr(i + 1);
Kernel32.MemoryProtection old;
if (!Kernel32.VirtualProtect(Z.UU(zstart), Z.UU(zend - zstart), p, out old))
throw new InvalidOperationException($"{nameof(Kernel32.VirtualProtect)}() returned FALSE!");
ps = i + 1;
}
}
}
/// <exception cref="InvalidOperationException">failed to protect memory</exception>
public override void Protect(ulong start, ulong length, Protection prot)
{
if (length == 0)
return;
int pstart = GetPage(start);
int pend = GetPage(start + length - 1);
var p = GetKernelMemoryProtectionValue(prot);
for (int i = pstart; i <= pend; i++)
_pageData[i] = prot; // also store the value for later use
if (Active) // it's legal to Protect() if we're not active; the information is just saved for the next activation
{
var computedStart = WaterboxUtils.AlignDown(start);
var computedEnd = WaterboxUtils.AlignUp(start + length);
var computedLength = computedEnd - computedStart;
Kernel32.MemoryProtection old;
if (!Kernel32.VirtualProtect(Z.UU(computedStart),
Z.UU(computedLength), p, out old))
throw new InvalidOperationException($"{nameof(Kernel32.VirtualProtect)}() returned FALSE!");
}
}
public override void Dispose(bool disposing)
{
if (_handle != IntPtr.Zero)
{
if (Active)
Deactivate();
Kernel32.CloseHandle(_handle);
_handle = IntPtr.Zero;
}
}
~MemoryBlockWindows()
{
Dispose(false);
}
private static class Kernel32
{
[DllImport("kernel32.dll", SetLastError = true)]
public static extern bool VirtualProtect(UIntPtr lpAddress, UIntPtr dwSize,
MemoryProtection flNewProtect, out MemoryProtection lpflOldProtect);
[Flags]
public enum MemoryProtection : uint
{
EXECUTE = 0x10,
EXECUTE_READ = 0x20,
EXECUTE_READWRITE = 0x40,
EXECUTE_WRITECOPY = 0x80,
NOACCESS = 0x01,
READONLY = 0x02,
READWRITE = 0x04,
WRITECOPY = 0x08,
GUARD_Modifierflag = 0x100,
NOCACHE_Modifierflag = 0x200,
WRITECOMBINE_Modifierflag = 0x400
}
[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr CreateFileMapping(
IntPtr hFile,
IntPtr lpFileMappingAttributes,
FileMapProtection flProtect,
uint dwMaximumSizeHigh,
uint dwMaximumSizeLow,
string lpName);
[Flags]
public enum FileMapProtection : uint
{
PageReadonly = 0x02,
PageReadWrite = 0x04,
PageWriteCopy = 0x08,
PageExecuteRead = 0x20,
PageExecuteReadWrite = 0x40,
SectionCommit = 0x8000000,
SectionImage = 0x1000000,
SectionNoCache = 0x10000000,
SectionReserve = 0x4000000,
}
[DllImport("kernel32.dll", SetLastError = true)]
public static extern bool CloseHandle(IntPtr hObject);
[DllImport("kernel32.dll", SetLastError = true)]
public static extern bool UnmapViewOfFile(IntPtr lpBaseAddress);
[DllImport("kernel32.dll")]
public static extern IntPtr MapViewOfFileEx(IntPtr hFileMappingObject,
FileMapAccessType dwDesiredAccess, uint dwFileOffsetHigh, uint dwFileOffsetLow,
UIntPtr dwNumberOfBytesToMap, IntPtr lpBaseAddress);
[Flags]
public enum FileMapAccessType : uint
{
Copy = 0x01,
Write = 0x02,
Read = 0x04,
AllAccess = 0x08,
Execute = 0x20,
}
public static readonly IntPtr INVALID_HANDLE_VALUE = Z.US(0xffffffffffffffff);
}
}
}

164
src/BizHawk.BizInvoke/MemoryBlockWindowsPal.cs Normal file
View File

@ -0,0 +1,164 @@
using System;
using System.Runtime.InteropServices;
using static BizHawk.BizInvoke.MemoryBlock;
namespace BizHawk.BizInvoke
{
internal sealed class MemoryBlockWindowsPal : IMemoryBlockPal
{
/// <summary>
/// handle returned by CreateFileMapping
/// </summary>
private IntPtr _handle;
private ulong _start;
private ulong _size;
/// <summary>
/// Reserve bytes to later be swapped in, but do not map them
/// </summary>
/// <param name="start">eventual mapped address</param>
/// <param name="size"></param>
public MemoryBlockWindowsPal(ulong start, ulong size)
{
_start = start;
_size = size;
_handle = Kernel32.CreateFileMapping(
Kernel32.INVALID_HANDLE_VALUE,
IntPtr.Zero,
Kernel32.FileMapProtection.PageExecuteReadWrite | Kernel32.FileMapProtection.SectionCommit,
(uint)(_size >> 32),
(uint)_size,
null
);
if (_handle == IntPtr.Zero)
{
throw new InvalidOperationException($"{nameof(Kernel32.CreateFileMapping)}() returned NULL");
}
}
public void Activate()
{
if (Kernel32.MapViewOfFileEx(
_handle,
Kernel32.FileMapAccessType.Read | Kernel32.FileMapAccessType.Write | Kernel32.FileMapAccessType.Execute,
0,
0,
Z.UU(_size),
Z.US(_start)
) != Z.US(_start))
{
throw new InvalidOperationException($"{nameof(Kernel32.MapViewOfFileEx)}() returned NULL");
}
}
public void Deactivate()
{
if (!Kernel32.UnmapViewOfFile(Z.US(_start)))
throw new InvalidOperationException($"{nameof(Kernel32.UnmapViewOfFile)}() returned NULL");
}
public void Protect(ulong start, ulong size, Protection prot)
{
if (!Kernel32.VirtualProtect(Z.UU(start), Z.UU(size), GetKernelMemoryProtectionValue(prot), out var old))
throw new InvalidOperationException($"{nameof(Kernel32.VirtualProtect)}() returned FALSE!");
}
private static Kernel32.MemoryProtection GetKernelMemoryProtectionValue(Protection prot)
{
Kernel32.MemoryProtection p;
switch (prot)
{
case Protection.None: p = Kernel32.MemoryProtection.NOACCESS; break;
case Protection.R: p = Kernel32.MemoryProtection.READONLY; break;
case Protection.RW: p = Kernel32.MemoryProtection.READWRITE; break;
case Protection.RX: p = Kernel32.MemoryProtection.EXECUTE_READ; break;
default: throw new ArgumentOutOfRangeException(nameof(prot));
}
return p;
}
public void Dispose()
{
if (_handle != IntPtr.Zero)
{
Kernel32.CloseHandle(_handle);
_handle = IntPtr.Zero;
GC.SuppressFinalize(this);
}
}
~MemoryBlockWindowsPal()
{
Dispose();
}
private static class Kernel32
{
[DllImport("kernel32.dll", SetLastError = true)]
public static extern bool VirtualProtect(UIntPtr lpAddress, UIntPtr dwSize,
MemoryProtection flNewProtect, out MemoryProtection lpflOldProtect);
[Flags]
public enum MemoryProtection : uint
{
EXECUTE = 0x10,
EXECUTE_READ = 0x20,
EXECUTE_READWRITE = 0x40,
EXECUTE_WRITECOPY = 0x80,
NOACCESS = 0x01,
READONLY = 0x02,
READWRITE = 0x04,
WRITECOPY = 0x08,
GUARD_Modifierflag = 0x100,
NOCACHE_Modifierflag = 0x200,
WRITECOMBINE_Modifierflag = 0x400
}
[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr CreateFileMapping(
IntPtr hFile,
IntPtr lpFileMappingAttributes,
FileMapProtection flProtect,
uint dwMaximumSizeHigh,
uint dwMaximumSizeLow,
string lpName);
[Flags]
public enum FileMapProtection : uint
{
PageReadonly = 0x02,
PageReadWrite = 0x04,
PageWriteCopy = 0x08,
PageExecuteRead = 0x20,
PageExecuteReadWrite = 0x40,
SectionCommit = 0x8000000,
SectionImage = 0x1000000,
SectionNoCache = 0x10000000,
SectionReserve = 0x4000000,
}
[DllImport("kernel32.dll", SetLastError = true)]
public static extern bool CloseHandle(IntPtr hObject);
[DllImport("kernel32.dll", SetLastError = true)]
public static extern bool UnmapViewOfFile(IntPtr lpBaseAddress);
[DllImport("kernel32.dll")]
public static extern IntPtr MapViewOfFileEx(IntPtr hFileMappingObject,
FileMapAccessType dwDesiredAccess, uint dwFileOffsetHigh, uint dwFileOffsetLow,
UIntPtr dwNumberOfBytesToMap, IntPtr lpBaseAddress);
[Flags]
public enum FileMapAccessType : uint
{
Copy = 0x01,
Write = 0x02,
Read = 0x04,
AllAccess = 0x08,
Execute = 0x20,
}
public static readonly IntPtr INVALID_HANDLE_VALUE = Z.US(0xffffffffffffffff);
}
}
}

35
src/BizHawk.Client.Common/RomLoader.cs
View File

@ -27,6 +27,7 @@ using BizHawk.Emulation.Cores.Consoles.Sega.Saturn;
using BizHawk.Emulation.Cores.Consoles.NEC.PCFX;
using BizHawk.Emulation.Cores.Computers.AmstradCPC;
using BizHawk.Emulation.Cores.Consoles.ChannelF;
using BizHawk.Emulation.Cores.Consoles.NEC.PCE;
namespace BizHawk.Client.Common
{
@ -510,9 +511,25 @@ namespace BizHawk.Client.Common
nextEmulator = new Tst(nextComm, new[] { disc },
(Tst.Settings)GetCoreSettings<Tst>(), (Tst.SyncSettings)GetCoreSyncSettings<Tst>());
break;
case "PCE":
case "PCE": // TODO: this is clearly not used, its set to PCE by code above
case "PCECD":
nextEmulator = new PCEngine(nextComm, game, disc, GetCoreSettings<PCEngine>(), GetCoreSyncSettings<PCEngine>());
string core = CoreNames.PceHawk;
if (Global.Config.PreferredCores.TryGetValue("PCECD", out string preferredCore))
{
core = preferredCore;
}
if (core == CoreNames.PceHawk)
{
nextEmulator = new PCEngine(nextComm, game, disc, GetCoreSettings<PCEngine>(), GetCoreSyncSettings<PCEngine>());
}
else
{
nextEmulator = new TerboGrafix(game, new[] { disc }, nextComm,
(Emulation.Cores.Waterbox.NymaCore.NymaSettings)GetCoreSettings<TerboGrafix>(),
(Emulation.Cores.Waterbox.NymaCore.NymaSyncSettings)GetCoreSyncSettings<TerboGrafix>());
}
break;
}
}
@ -837,7 +854,15 @@ namespace BizHawk.Client.Common
switch (game.System)
{
default:
core = CoreInventory.Instance[game.System];
if (Global.Config.PreferredCores.TryGetValue(game.System, out string coreName))
{
core = CoreInventory.Instance[game.System, coreName];
}
else
{
core = CoreInventory.Instance[game.System];
}
break;
case null:
@ -978,7 +1003,9 @@ namespace BizHawk.Client.Common
if (core != null)
{
// use CoreInventory
nextEmulator = core.Create(nextComm, game, rom.RomData, rom.FileData, Deterministic, GetCoreSettings(core.Type), GetCoreSyncSettings(core.Type));
nextEmulator = core.Create(
nextComm, game, rom.RomData, rom.FileData, Deterministic,
GetCoreSettings(core.Type), GetCoreSyncSettings(core.Type), rom.Extension);
}
}

5
src/BizHawk.Client.Common/config/Config.cs
View File

@ -322,7 +322,10 @@ namespace BizHawk.Client.Common
{
["NES"] = CoreNames.QuickNes,
["SNES"] = CoreNames.Snes9X,
["GB"] = CoreNames.Gambatte
["GB"] = CoreNames.Gambatte,
["PCE"] = CoreNames.PceHawk,
["PCECD"] = CoreNames.PceHawk,
["SGX"] = CoreNames.PceHawk
};
// ReSharper disable once UnusedMember.Global

2
src/BizHawk.Client.EmuHawk/BizHawk.Client.EmuHawk.csproj
View File

@ -7,7 +7,7 @@
<ApplicationManifest>app.manifest</ApplicationManifest>
<DefineConstants>$(DefineConstants);EXE_PROJECT</DefineConstants>
<OutputPath>$(ProjectDir)../../output</OutputPath>
<OutputType>WinExe</OutputType>
<OutputType>Exe</OutputType>
<TargetFramework>net48</TargetFramework>
<TargetName>EmuHawk</TargetName>
<ResolveAssemblyWarnOrErrorOnTargetArchitectureMismatch>None</ResolveAssemblyWarnOrErrorOnTargetArchitectureMismatch>

31
src/BizHawk.Client.EmuHawk/MainForm.Designer.cs generated
View File

@ -193,8 +193,11 @@
this.CorebsnesMenuItem = new System.Windows.Forms.ToolStripMenuItem();
this.SGBCoreSubmenu = new System.Windows.Forms.ToolStripMenuItem();
this.SgbBsnesMenuItem = new System.Windows.Forms.ToolStripMenuItem();
this.PceHawkMenuItem = new System.Windows.Forms.ToolStripMenuItem();
this.TurboNymaMenuItem = new System.Windows.Forms.ToolStripMenuItem();
this.SgbSameBoyMenuItem = new System.Windows.Forms.ToolStripMenuItem();
this.GBCoreSubmenu = new System.Windows.Forms.ToolStripMenuItem();
this.PceCoreSubmenu = new System.Windows.Forms.ToolStripMenuItem();
this.GBGambatteMenuItem = new System.Windows.Forms.ToolStripMenuItem();
this.GBGBHawkMenuItem = new System.Windows.Forms.ToolStripMenuItem();
this.GBInSGBMenuItem = new System.Windows.Forms.ToolStripMenuItem();
@ -1789,6 +1792,7 @@
this.CoreSNESSubMenu,
this.SGBCoreSubmenu,
this.GBCoreSubmenu,
this.PceCoreSubmenu,
this.GBInSGBMenuItem,
this.toolStripMenuItem16,
this.AllowGameDbCoreOverridesMenuItem,
@ -1879,6 +1883,16 @@
this.SGBCoreSubmenu.Text = "SGB";
this.SGBCoreSubmenu.DropDownOpened += new System.EventHandler(this.SGBCoreSubmenu_DropDownOpened);
//
// PceCoreSubmenu
//
this.PceCoreSubmenu.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
this.PceHawkMenuItem,
this.TurboNymaMenuItem});
this.PceCoreSubmenu.Name = "PceCoreSubmenu";
this.PceCoreSubmenu.Size = new System.Drawing.Size(223, 22);
this.PceCoreSubmenu.Text = "PCE";
this.PceCoreSubmenu.DropDownOpened += new System.EventHandler(this.PceCoreSubmenu_DropDownOpened);
//
// SgbBsnesMenuItem
//
this.SgbBsnesMenuItem.Name = "SgbBsnesMenuItem";
@ -1893,6 +1907,20 @@
this.SgbSameBoyMenuItem.Text = "SameBoy";
this.SgbSameBoyMenuItem.Click += new System.EventHandler(this.SgbCorePick_Click);
//
// PceHawkMenuItem
//
this.PceHawkMenuItem.Name = "PceHawkMenuItem";
this.PceHawkMenuItem.Size = new System.Drawing.Size(118, 22);
this.PceHawkMenuItem.Text = "PCEHawk";
this.PceHawkMenuItem.Click += new System.EventHandler(this.PceHawkCorePick_Click);
//
// TurboNymaMenuItem
//
this.TurboNymaMenuItem.Name = "TurboNymaMenuItem";
this.TurboNymaMenuItem.Size = new System.Drawing.Size(118, 22);
this.TurboNymaMenuItem.Text = "TurboNyma";
this.TurboNymaMenuItem.Click += new System.EventHandler(this.TurboNymaCorePick_Click);
//
// GBCoreSubmenu
//
this.GBCoreSubmenu.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
@ -4311,7 +4339,10 @@
private System.Windows.Forms.ToolStripMenuItem SGBCoreSubmenu;
private System.Windows.Forms.ToolStripMenuItem SgbBsnesMenuItem;
private System.Windows.Forms.ToolStripMenuItem SgbSameBoyMenuItem;
private System.Windows.Forms.ToolStripMenuItem PceHawkMenuItem;
private System.Windows.Forms.ToolStripMenuItem TurboNymaMenuItem;
private System.Windows.Forms.ToolStripMenuItem GBCoreSubmenu;
private System.Windows.Forms.ToolStripMenuItem PceCoreSubmenu;
private System.Windows.Forms.ToolStripMenuItem GBGambatteMenuItem;
private System.Windows.Forms.ToolStripMenuItem GBGBHawkMenuItem;
private System.Windows.Forms.ToolStripMenuItem pCFXToolStripMenuItem;

35
src/BizHawk.Client.EmuHawk/MainForm.Events.cs
View File

@ -1257,6 +1257,12 @@ namespace BizHawk.Client.EmuHawk
SubGBHawkMenuItem.Checked = Config.PreferredCores["GB"] == CoreNames.SubGbHawk;
}
private void PceCoreSubmenu_DropDownOpened(object sender, EventArgs e)
{
PceHawkMenuItem.Checked = Config.PreferredCores["PCE"] == CoreNames.PceHawk;
TurboNymaMenuItem.Checked = Config.PreferredCores["PCE"] == CoreNames.TurboNyma;
}
private void SubGBCorePick_Click(object sender, EventArgs e)
{
Config.PreferredCores["GB"] = CoreNames.SubGbHawk;
@ -1285,11 +1291,36 @@ namespace BizHawk.Client.EmuHawk
}
}
private void PceHawkCorePick_Click(object sender, EventArgs e)
{
// TODO: do we want to be able to pick different cores for each system?
Config.PreferredCores["PCE"] = CoreNames.PceHawk;
Config.PreferredCores["PCECD"] = CoreNames.PceHawk;
Config.PreferredCores["SGX"] = CoreNames.PceHawk;
if (Emulator.SystemId == "PCE" || Emulator.SystemId == "PCECD" || Emulator.SystemId == "SGX")
{
FlagNeedsReboot();
}
}
private void TurboNymaCorePick_Click(object sender, EventArgs e)
{
Config.PreferredCores["PCE"] = CoreNames.TurboNyma;
Config.PreferredCores["PCECD"] = CoreNames.TurboNyma;
Config.PreferredCores["SGX"] = CoreNames.TurboNyma;
if (Emulator.SystemId == "PCE" || Emulator.SystemId == "PCECD" || Emulator.SystemId == "SGX")
{
FlagNeedsReboot();
}
}
private void GBCorePick_Click(object sender, EventArgs e)
{
Config.PreferredCores["GB"] = CoreNames.GbHawk;
Config.PreferredCores["PCE"] = CoreNames.TurboNyma;
if (Emulator.SystemId == "GB" || Emulator.SystemId == "GBC")
if (Emulator.SystemId == "PCE" || Emulator.SystemId == "PCECD")
{
FlagNeedsReboot();
}

90
src/BizHawk.Client.EmuHawk/config/ControllerConfig.cs
View File

@ -8,6 +8,7 @@ using System.Windows.Forms;
using BizHawk.Common;
using BizHawk.Client.Common;
using BizHawk.Emulation.Common;
using System.Text.RegularExpressions;
namespace BizHawk.Client.EmuHawk
{
@ -88,6 +89,8 @@ namespace BizHawk.Client.EmuHawk
return new AnalogBindPanel(settings, buttons) { Dock = DockStyle.Fill, AutoScroll = true };
}
private static Regex ButtonMatchesPlayer = new Regex("^P(\\d+)\\s");
private void LoadToPanel<T>(Control dest, string controllerName, IList<string> controllerButtons, Dictionary<string,string> categoryLabels, IDictionary<string, Dictionary<string, T>> settingsBlock, T defaultValue, PanelCreator<T> createPanel)
{
if (!settingsBlock.TryGetValue(controllerName, out var settings))
@ -110,92 +113,57 @@ namespace BizHawk.Client.EmuHawk
return;
}
// split the list of all settings into buckets by player number
var buckets = new List<string>[MaxPlayers + 1];
var categoryBuckets = new WorkingDictionary<string, List<string>>();
for (var i = 0; i < buckets.Length; i++)
{
buckets[i] = new List<string>();
}
// split the list of all settings into buckets by player number, or supplied category
// the order that buttons appeared in determines the order of the tabs
var orderedBuckets = new List<KeyValuePair<string, List<string>>>();
var buckets = new Dictionary<string, List<string>>();
// by iterating through only the controller's active buttons, we're silently
// discarding anything that's not on the controller right now. due to the way
// saving works, those entries will still be preserved in the config file, tho
foreach (var button in controllerButtons)
{
int i;
for (i = MaxPlayers; i > 0; i--)
{
if (button.StartsWith($"P{i}"))
{
break;
}
}
if (i > MaxPlayers) // couldn't find
{
i = 0;
}
Match m;
string categoryLabel; // = "Console"; // anything that wants not console can set it in the categorylabels
if (categoryLabels.ContainsKey(button))
{
categoryBuckets[categoryLabels[button]].Add(button);
categoryLabel = categoryLabels[button];
}
else if ((m = ButtonMatchesPlayer.Match(button)).Success)
{
categoryLabel = $"Player {m.Groups[1].Value}";
}
else
{
buckets[i].Add(button);
categoryLabel = "Console"; // anything that wants not console can set it in the categorylabels
}
if (!buckets.ContainsKey(categoryLabel))
{
var l = new List<string>();
buckets.Add(categoryLabel, l);
orderedBuckets.Add(new KeyValuePair<string, List<string>>(categoryLabel, l));
}
buckets[categoryLabel].Add(button);
}
if (buckets[0].Count == controllerButtons.Count)
if (orderedBuckets.Count == 1)
{
// everything went into bucket 0, so make no tabs at all
dest.Controls.Add(createPanel(settings, controllerButtons.ToList(), dest.Size));
}
else
{
// create multiple player tabs
// create multiple tabs
var tt = new TabControl { Dock = DockStyle.Fill };
dest.Controls.Add(tt);
int pageIdx = 0;
for (int i = 1; i <= MaxPlayers; i++)
foreach (var kvp in orderedBuckets)
{
if (buckets[i].Count > 0)
{
string tabName = _emulator.SystemId != "WSWAN" ? $"Player {i}" : i == 1 ? "Normal" : "Rotated"; // hack
tt.TabPages.Add(tabName);
tt.TabPages[pageIdx].Controls.Add(createPanel(settings, buckets[i], tt.Size));
pageIdx++;
}
}
foreach (var cat in categoryBuckets)
{
string tabName = cat.Key;
string tabName = kvp.Key;
tt.TabPages.Add(tabName);
tt.TabPages[pageIdx].Controls.Add(createPanel(settings, cat.Value, tt.Size));
// ZxHawk hack - it uses multiple categoryLabels
if (_emulator.SystemId == "ZXSpectrum"
|| _emulator.SystemId == "AmstradCPC"
|| _emulator.SystemId == "ChannelF")
{
pageIdx++;
}
}
if (buckets[0].Count > 0)
{
// ZXHawk needs to skip this bit
if (_emulator.SystemId == "ZXSpectrum" || _emulator.SystemId == "AmstradCPC" || _emulator.SystemId == "ChannelF")
return;
string tabName =
(_emulator.SystemId == "C64") ? "Keyboard" :
(_emulator.SystemId == "MAME") ? "Misc" :
"Console"; // hack
tt.TabPages.Add(tabName);
tt.TabPages[pageIdx].Controls.Add(createPanel(settings, buckets[0], tt.Size));
tt.TabPages[pageIdx++].Controls.Add(createPanel(settings, kvp.Value, tt.Size));
}
}
}

22
src/BizHawk.Common/PtrToStringUtf8.cs Normal file
View File

@ -0,0 +1,22 @@
using System;
using System.Text;
namespace BizHawk.Common
{
public static class Mershul
{
/// <summary>
/// TODO: Update to a version of .nyet that includes this
/// </summary>
public static unsafe string PtrToStringUtf8(IntPtr p)
{
if (p == IntPtr.Zero)
return null;
byte* b = (byte*)p;
int len = 0;
while (*b++ != 0)
len++;
return Encoding.UTF8.GetString((byte*)p, len);
}
}
}

91
src/BizHawk.Emulation.Common/Base Implementations/MemoryDomainStream.cs Normal file
View File

@ -0,0 +1,91 @@
using System;
using System.IO;
using BizHawk.Common;
namespace BizHawk.Emulation.Common
{
public class MemoryDomainStream : Stream
{
public MemoryDomainStream(MemoryDomain d)
{
_d = d;
}
private readonly MemoryDomain _d;
public override bool CanRead => true;
public override bool CanSeek => true;
public override bool CanWrite => _d.Writable;
public override long Length => _d.Size;
public override long Position { get; set; }
public override void Flush()
{
}
public override int ReadByte()
{
if (Position >= Length)
return -1;
return _d.PeekByte(Position++);
}
public override void WriteByte(byte value)
{
if (Position >= Length)
throw new IOException("Can't resize stream");
_d.PokeByte(Position++, value);
}
public override int Read(byte[] buffer, int offset, int count)
{
if (offset < 0 || offset + count > buffer.Length)
throw new ArgumentOutOfRangeException("offset");
count = (int)Math.Min(count, Length - Position);
if (count == 0)
return 0;
// TODO: Memory domain doesn't have the overload we need :(
var poop = new byte[count];
// TODO: Range has the wrong end value
_d.BulkPeekByte(new MutableRange<long>(Position, Position + count - 1), poop);
Array.Copy(poop, 0, buffer, offset, count);
Position += count;
return count;
}
public override void Write(byte[] buffer, int offset, int count)
{
if (offset < 0 || offset + count > buffer.Length)
throw new ArgumentOutOfRangeException("offset");
for (var i = offset; i < offset + count; i++)
_d.PokeByte(Position++, buffer[i]);
}
public override long Seek(long offset, SeekOrigin origin)
{
switch (origin)
{
case SeekOrigin.Begin:
Position = offset;
break;
case SeekOrigin.Current:
Position += offset;
break;
case SeekOrigin.End:
Position = Length + offset;
break;
default:
throw new ArgumentOutOfRangeException("origin");
}
return Position;
}
public override void SetLength(long value)
{
throw new NotSupportedException("Stream cannot be resized");
}
}
}

12
src/BizHawk.Emulation.Common/Base Implementations/NullEmulator.cs
View File

@ -1,4 +1,6 @@
namespace BizHawk.Emulation.Common
using System.Threading;
namespace BizHawk.Emulation.Common
{
[Core("NullHawk", "", false, true)]
[ServiceNotApplicable(new[] {
@ -28,7 +30,13 @@
public ControllerDefinition ControllerDefinition => NullController.Instance.Definition;
public bool FrameAdvance(IController controller, bool render, bool renderSound) => true;
public bool FrameAdvance(IController controller, bool render, bool renderSound)
{
// real cores wouldn't do something like this, but this just keeps speed reasonable
// if all throttles are off
Thread.Sleep(5);
return true;
}
public int Frame => 0;

1
src/BizHawk.Emulation.Common/Database/FirmwareDatabase.cs
View File

@ -29,6 +29,7 @@ namespace BizHawk.Emulation.Common
FirmwareAndOption("FECBAE2CEC76C710422486BAA186FFA7CA1CF925", 53248, "SNES", "ST011", "st011.rom", "ST011 Rom");
FirmwareAndOption("91383B92745CC7CC4F15409AC5BC2C2F699A43F1", 163840, "SNES", "ST018", "st018.rom", "ST018 Rom");
FirmwareAndOption("79F5FF55DD10187C7FD7B8DAAB0B3FFBD1F56A2C", 262144, "PCECD", "Bios", "pcecd-3.0-(J).pce", "Super CD Bios (J)");
FirmwareAndOption("014881a959e045e00f4db8f52955200865d40280", 32768, "PCECD", "GE-Bios", "gecard.pce", "Games Express CD Card (Japan)");
FirmwareAndOption("D9D134BB6B36907C615A594CC7688F7BFCEF5B43", 4096, "A78", "Bios_NTSC", "7800NTSCBIOS.bin", "NTSC Bios");
//FirmwareAndOption("CE236581AB7921B59DB95BA12837C22F160896CB", 4096, "A78", "Bios_NTSC", "speed_bios.bin", "NTSC Bios speed");

34
src/BizHawk.Emulation.Cores/Consoles/NEC/PCE/TerboGrafix.cs Normal file
View File

@ -0,0 +1,34 @@
using System.Collections.Generic;
using BizHawk.Emulation.Common;
using BizHawk.Emulation.Cores.Waterbox;
using BizHawk.Emulation.DiscSystem;
namespace BizHawk.Emulation.Cores.Consoles.NEC.PCE
{
[Core(CoreNames.TurboNyma, "Mednafen Team", true, false, "1.24.3", "", false)]
public class TerboGrafix : NymaCore, IRegionable
{
[CoreConstructor(new[] { "PCE", "SGX" })]
public TerboGrafix(GameInfo game, byte[] rom, CoreComm comm, string extension,
NymaSettings settings, NymaSyncSettings syncSettings)
: base(comm, "PCE", "PC Engine Controller", settings, syncSettings)
{
DoInit<LibNymaCore>(game, rom, null, "pce.wbx", extension);
}
public TerboGrafix(GameInfo game, Disc[] discs, CoreComm comm,
NymaSettings settings, NymaSyncSettings syncSettings)
: base(comm, "PCE", "PC Engine Controller", settings, syncSettings)
{
// TODO: detect GECD and only ask for the firmware we need
var firmwares = new Dictionary<string, byte[]>
{
{ "FIRMWARE:syscard3.pce", comm.CoreFileProvider.GetFirmware("PCECD", "Bios", true) },
{ "FIRMWARE:gecard.pce", comm.CoreFileProvider.GetFirmware("PCECD", "GE-Bios", true) },
};
DoInit<LibNymaCore>(game, null, discs, "pce.wbx", null, firmwares);
}
// pce always has two layers, sgx always has 4, and mednafen knows this
public override string SystemId => SettingsInfo.LayerNames.Count == 4 ? "SGX" : "PCE";
}
}

2
src/BizHawk.Emulation.Cores/Consoles/PC Engine/PCEngine.cs
View File

@ -12,7 +12,7 @@ namespace BizHawk.Emulation.Cores.PCEngine
public enum NecSystemType { TurboGrafx, TurboCD, SuperGrafx }
[Core(
"PCEHawk",
CoreNames.PceHawk,
"Vecna",
isPorted: false,
isReleased: true)]

25
src/BizHawk.Emulation.Cores/Consoles/SNK/DualNeoGeoPort.cs
View File

@ -28,20 +28,21 @@ namespace BizHawk.Emulation.Cores.Consoles.SNK
[CoreConstructor("DNGP")]
public DualNeoGeoPort(CoreComm comm, byte[] rom, bool deterministic)
{
// this will throw on construct: we need to compile two different copies of ngp at different starts
CoreComm = comm;
_left = new NeoGeoPort(comm, rom, new NeoGeoPort.SyncSettings { Language = LibNeoGeoPort.Language.English }, deterministic, WaterboxHost.CanonicalStart);
_right = new NeoGeoPort(comm, rom, new NeoGeoPort.SyncSettings { Language = LibNeoGeoPort.Language.English }, deterministic, WaterboxHost.CanonicalStart);
_linkCable = new LinkCable();
_leftEnd = new LinkInterop(_left, _linkCable.LeftIn, _linkCable.LeftOut);
_rightEnd = new LinkInterop(_right, _linkCable.RightIn, _linkCable.RightOut);
throw new NotImplementedException();
// // this will throw on construct: we need to compile two different copies of ngp at different starts
// CoreComm = comm;
// _left = new NeoGeoPort(comm, rom, new NeoGeoPort.SyncSettings { Language = LibNeoGeoPort.Language.English }, deterministic, WaterboxHost.CanonicalStart);
// _right = new NeoGeoPort(comm, rom, new NeoGeoPort.SyncSettings { Language = LibNeoGeoPort.Language.English }, deterministic, WaterboxHost.CanonicalStart);
// _linkCable = new LinkCable();
// _leftEnd = new LinkInterop(_left, _linkCable.LeftIn, _linkCable.LeftOut);
// _rightEnd = new LinkInterop(_right, _linkCable.RightIn, _linkCable.RightOut);
_serviceProvider = new BasicServiceProvider(this);
_soundProvider = new DualSyncSound(_left, _right);
_serviceProvider.Register<ISoundProvider>(_soundProvider);
_videoProvider = new SideBySideVideo(_left, _right);
_serviceProvider.Register<IVideoProvider>(_videoProvider);
// _serviceProvider = new BasicServiceProvider(this);
// _soundProvider = new DualSyncSound(_left, _right);
// _serviceProvider.Register<ISoundProvider>(_soundProvider);
// _videoProvider = new SideBySideVideo(_left, _right);
// _serviceProvider.Register<IVideoProvider>(_videoProvider);
}
public bool FrameAdvance(IController controller, bool render, bool rendersound = true)

26
src/BizHawk.Emulation.Cores/Consoles/WonderSwan/WonderSwan.Controller.cs
View File

@ -35,6 +35,32 @@ namespace BizHawk.Emulation.Cores.WonderSwan
"Power",
"Rotate"
},
CategoryLabels =
{
{ "P1 X1", "Normal" },
{ "P1 X2", "Normal" },
{ "P1 X3", "Normal" },
{ "P1 X4", "Normal" },
{ "P1 Y1", "Normal" },
{ "P1 Y2", "Normal" },
{ "P1 Y3", "Normal" },
{ "P1 Y4", "Normal" },
{ "P1 Start", "Normal" },
{ "P1 B", "Normal" },
{ "P1 A", "Normal" },
{ "P2 X1", "Rotated" },
{ "P2 X2", "Rotated" },
{ "P2 X3", "Rotated" },
{ "P2 X4", "Rotated" },
{ "P2 Y1", "Rotated" },
{ "P2 Y2", "Rotated" },
{ "P2 Y3", "Rotated" },
{ "P2 Y4", "Rotated" },
{ "P2 Start", "Rotated" },
{ "P2 B", "Rotated" },
{ "P2 A", "Rotated" },
}
};
public ControllerDefinition ControllerDefinition => WonderSwanController;

4
src/BizHawk.Emulation.Cores/CoreInventory.cs
View File

@ -80,7 +80,8 @@ namespace BizHawk.Emulation.Cores
byte[] file,
bool deterministic,
object settings,
object syncSettings
object syncSettings,
string extension
)
{
object[] o = new object[_paramMap.Count];
@ -91,6 +92,7 @@ namespace BizHawk.Emulation.Cores
Bp(o, "deterministic", deterministic);
Bp(o, "settings", settings);
Bp(o, "syncsettings", syncSettings);
Bp(o, "extension", extension);
return (IEmulator)CTor.Invoke(o);
}

2
src/BizHawk.Emulation.Cores/CoreNames.cs
View File

@ -21,5 +21,7 @@ namespace BizHawk.Emulation.Cores
public const string SameBoy = "SameBoy";
public const string PicoDrive = "PicoDrive";
public const string Gpgx = "Genplus-gx";
public const string PceHawk = "PCEHawk";
public const string TurboNyma = "Terbo Grafix";
}
}

103
src/BizHawk.Emulation.Cores/Waterbox/ElfLoader.cs
View File

@ -26,8 +26,6 @@ namespace BizHawk.Emulation.Cores.Waterbox
private readonly Section<ulong> _sealed;
private readonly Section<ulong> _invisible;
private readonly List<Section<ulong>> _savedSections;
private readonly bool _skipCoreConsistencyCheck;
private readonly bool _skipMemoryConsistencyCheck;
@ -37,6 +35,20 @@ namespace BizHawk.Emulation.Cores.Waterbox
public string ModuleName { get; }
/// <summary>
/// Where writable data begins
/// </summary>
private ulong _writeStart;
/// <summary>
/// Where writiable data begins after seal
/// </summary>
private ulong _postSealWriteStart;
/// <summary>
/// Where the saveable program data begins
/// </summary>
private ulong _saveStart;
private ulong _execEnd;
public ElfLoader(string moduleName, byte[] fileData, ulong assumedStart, bool skipCoreConsistencyCheck, bool skipMemoryConsistencyCheck)
{
ModuleName = moduleName;
@ -76,12 +88,6 @@ namespace BizHawk.Emulation.Cores.Waterbox
_sectionsByName.TryGetValue(".sealed", out _sealed);
_sectionsByName.TryGetValue(".invis", out _invisible);
_savedSections = _elf.Sections
.Where(s => (s.Flags & SectionFlags.Allocatable) != 0 && (s.Flags & SectionFlags.Writable) != 0)
.Where(s => !IsSpecialReadonlySection(s) && s != _invisible)
.OrderBy(s => s.LoadAddress)
.ToList();
_visibleSymbols = _allSymbols
.Where(s => s.Binding == SymbolBinding.Global && s.Visibility == SymbolVisibility.Default)
.ToDictionary(s => s.Name);
@ -93,7 +99,6 @@ namespace BizHawk.Emulation.Cores.Waterbox
.Where(s => s.PointedSection == _imports)
.ToList();
Memory = MemoryBlock.Create(start, size);
Memory.Activate();
Memory.Protect(Memory.Start, Memory.Size, MemoryBlock.Protection.RW);
@ -104,6 +109,39 @@ namespace BizHawk.Emulation.Cores.Waterbox
Marshal.Copy(data, 0, Z.US(seg.Address), Math.Min((int)seg.Size, (int)seg.FileSize));
}
{
// Compute RW boundaries
var allocated = _elf.Sections
.Where(s => (s.Flags & SectionFlags.Allocatable) != 0);
var writable = allocated
.Where(s => (s.Flags & SectionFlags.Writable) != 0);
var postSealWritable = writable
.Where(s => !IsSpecialReadonlySection(s));
var saveable = postSealWritable
.Where(s => s != _invisible);
var executable = allocated
.Where(s => (s.Flags & SectionFlags.Executable) != 0);
_writeStart = WaterboxUtils.AlignDown(writable.Min(s => s.LoadAddress));
_postSealWriteStart = WaterboxUtils.AlignDown(postSealWritable.Min(s => s.LoadAddress));
_saveStart = WaterboxUtils.AlignDown(saveable.Min(s => s.LoadAddress));
_execEnd = WaterboxUtils.AlignUp(executable.Max(s => s.LoadAddress + s.Size));
// validate; this may require linkscript cooperation
// due to the segment limitations, the only thing we'd expect to catch is a custom eventually readonly section
// in the wrong place (because the linkscript doesn't know "eventually readonly")
if (_execEnd > _writeStart)
throw new InvalidOperationException($"ElfLoader: Executable data to {_execEnd:X16} overlaps writable data from {_writeStart}");
var actuallySaved = allocated.Where(a => a.LoadAddress + a.Size > _saveStart);
var oopsSaved = actuallySaved.Except(saveable);
foreach (var s in oopsSaved)
{
Console.WriteLine($"ElfLoader: Section {s.Name} will be saved, but that was not expected");
}
}
PrintSections();
PrintGdbData();
PrintTopSavableSymbols();
@ -126,7 +164,7 @@ namespace BizHawk.Emulation.Cores.Waterbox
(s.Flags & SectionFlags.Allocatable) != 0 ? "R" : " ",
(s.Flags & SectionFlags.Writable) != 0 ? "W" : " ",
(s.Flags & SectionFlags.Executable) != 0 ? "X" : " ",
_savedSections.Contains(s) ? "V" : " ",
s.LoadAddress + s.Size > _saveStart ? "V" : " ",
s.Name,
s.Size);
}
@ -135,7 +173,7 @@ namespace BizHawk.Emulation.Cores.Waterbox
private void PrintTopSavableSymbols()
{
var tops = _allSymbols
.Where(s => _savedSections.Contains(s.PointedSection))
.Where(s => s.Value + s.Size > _saveStart)
.OrderByDescending(s => s.Size)
.Where(s => s.Size >= 20 * 1024)
.Take(30)
@ -157,10 +195,12 @@ namespace BizHawk.Emulation.Cores.Waterbox
/// </summary>
private bool IsSpecialReadonlySection(Section<ulong> sec)
{
// TODO: I don't think there are any more relro sections, right?
return sec.Name.Contains(".rel.ro")
|| sec.Name.StartsWith(".got")
|| sec.Name == ".init_array"
|| sec.Name == ".fini_array"
|| sec.Name == ".tbss"
|| sec == _imports
|| sec == _sealed;
}
@ -170,17 +210,11 @@ namespace BizHawk.Emulation.Cores.Waterbox
/// </summary>
private void Protect()
{
Memory.Protect(Memory.Start, Memory.Size, MemoryBlock.Protection.R);
foreach (var sec in _elf.Sections.Where(s => (s.Flags & SectionFlags.Allocatable) != 0))
{
if (_everythingSealed && IsSpecialReadonlySection(sec))
continue;
var writeStart = _everythingSealed ? _postSealWriteStart : _writeStart;
if ((sec.Flags & SectionFlags.Executable) != 0)
Memory.Protect(sec.LoadAddress, sec.Size, MemoryBlock.Protection.RX);
else if ((sec.Flags & SectionFlags.Writable) != 0)
Memory.Protect(sec.LoadAddress, sec.Size, MemoryBlock.Protection.RW);
}
Memory.Protect(Memory.Start, _execEnd - Memory.Start, MemoryBlock.Protection.RX);
Memory.Protect(_execEnd, writeStart - _execEnd, MemoryBlock.Protection.R);
Memory.Protect(writeStart, Memory.EndExclusive - writeStart, MemoryBlock.Protection.RW);
}
// connect all of the .wbxsyscall stuff
@ -304,12 +338,10 @@ namespace BizHawk.Emulation.Cores.Waterbox
bw.Write(_elfHash);
bw.Write(Memory.XorHash);
foreach (var s in _savedSections)
{
var ms = Memory.GetXorStream(s.LoadAddress, s.Size, false);
bw.Write(s.Size);
ms.CopyTo(bw.BaseStream);
}
var len = Memory.EndExclusive - _saveStart;
var ms = Memory.GetXorStream(_saveStart, len, false);
bw.Write(len);
ms.CopyTo(bw.BaseStream);
}
public void LoadStateBinary(BinaryReader br)
@ -343,18 +375,11 @@ namespace BizHawk.Emulation.Cores.Waterbox
throw new InvalidOperationException("Memory consistency check failed. Is this savestate from different SyncSettings?");
}
Memory.Protect(Memory.Start, Memory.Size, MemoryBlock.Protection.RW);
foreach (var s in _savedSections)
{
if (br.ReadUInt64() != s.Size)
throw new InvalidOperationException("Unexpected section size for " + s.Name);
var ms = Memory.GetXorStream(s.LoadAddress, s.Size, true);
WaterboxUtils.CopySome(br.BaseStream, ms, (long)s.Size);
}
Protect();
var len = Memory.EndExclusive - _saveStart;
if (br.ReadUInt64() != len)
throw new InvalidOperationException("Unexpected saved length");
var ms = Memory.GetXorStream(_saveStart, len, true);
WaterboxUtils.CopySome(br.BaseStream, ms, (long)len);
}
}
}

4
src/BizHawk.Emulation.Cores/Waterbox/EmuLibc.cs
View File

@ -1,6 +1,7 @@
using System;
using System.Runtime.InteropServices;
using BizHawk.BizInvoke;
using BizHawk.Common;
namespace BizHawk.Emulation.Cores.Waterbox
{
@ -36,8 +37,7 @@ namespace BizHawk.Emulation.Cores.Waterbox
[BizExport(CallingConvention.Cdecl, EntryPoint = "__w_debug_puts")]
public void DebugPuts(IntPtr s)
{
// TODO: Should be PtrToStringUtf8
Console.WriteLine(Marshal.PtrToStringAnsi(s));
Console.WriteLine(Mershul.PtrToStringUtf8(s));
}
}
}

2
src/BizHawk.Emulation.Cores/Waterbox/Heap.cs
View File

@ -73,7 +73,7 @@ namespace BizHawk.Emulation.Cores.Waterbox
if (!Sealed)
{
Memory.Protect(Memory.Start, Used, MemoryBlock.Protection.R);
_hash = WaterboxUtils.Hash(Memory.GetStream(Memory.Start, Used, false));
_hash = WaterboxUtils.Hash(Memory.GetStream(Memory.Start, WaterboxUtils.AlignUp(Used), false));
Sealed = true;
}
else

325
src/BizHawk.Emulation.Cores/Waterbox/LibNymaCore.cs Normal file
View File

@ -0,0 +1,325 @@
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using BizHawk.BizInvoke;
using BizHawk.Common;
namespace BizHawk.Emulation.Cores.Waterbox
{
public abstract unsafe class LibNymaCore : LibWaterboxCore
{
[StructLayout(LayoutKind.Sequential)]
public class InitData
{
/// <summary>
/// Filename without extension. Used in autodetect
/// </summary>
public string FileNameBase;
/// <summary>
/// Just the extension. Used in autodetect. LOWERCASE PLEASE.
/// </summary>
public string FileNameExt;
/// <summary>
/// Full filename. This will be fopen()ed by the core
/// </summary>
public string FileNameFull;
}
/// <summary>
/// Do this before calling anything, even settings queries
/// </summary>
[BizImport(CC, Compatibility = true)]
public abstract void PreInit();
/// <summary>
/// Load a ROM
/// </summary>
[BizImport(CC, Compatibility = true)]
public abstract bool InitRom([In]InitData data);
/// <summary>
/// Load some CDs
/// </summary>
[BizImport(CC)]
public abstract bool InitCd(int numdisks);
public enum CommandType : int
{
NONE = 0x00,
RESET = 0x01,
POWER = 0x02,
INSERT_COIN = 0x07,
TOGGLE_DIP0 = 0x10,
TOGGLE_DIP1,
TOGGLE_DIP2,
TOGGLE_DIP3,
TOGGLE_DIP4,
TOGGLE_DIP5,
TOGGLE_DIP6,
TOGGLE_DIP7,
TOGGLE_DIP8,
TOGGLE_DIP9,
TOGGLE_DIP10,
TOGGLE_DIP11,
TOGGLE_DIP12,
TOGGLE_DIP13,
TOGGLE_DIP14,
TOGGLE_DIP15,
}
[StructLayout(LayoutKind.Sequential)]
public new class FrameInfo : LibWaterboxCore.FrameInfo
{
/// <summary>
/// true to skip video rendering
/// </summary>
public short SkipRendering;
/// <summary>
/// true to skip audion rendering
/// </summary>
public short SkipSoundening;
/// <summary>
/// a single command to run at the start of this frame
/// </summary>
public CommandType Command;
/// <summary>
/// raw data for each input port, assumed to be MAX_PORTS * MAX_PORT_DATA long
/// </summary>
public byte* InputPortData;
}
/// <summary>
/// Gets raw layer data to be handled by NymaCore.GetLayerData
/// </summary>
[BizImport(CC)]
public abstract byte* GetLayerData();
/// <summary>
/// Set enabled layers (or is it disabled layers?). Only call if NymaCore.GetLayerData() returned non null
/// </summary>
/// <param name="layers">bitmask in order defined by NymaCore.GetLayerData</param>
[BizImport(CC)]
public abstract void SetLayers(ulong layers);
public enum InputType : byte
{
PADDING = 0, // n-bit, zero
BUTTON, // 1-bit
BUTTON_CAN_RAPID, // 1-bit
SWITCH, // ceil(log2(n))-bit
// Current switch position(default 0).
// Persistent, and bidirectional communication(can be modified driver side, and Mednafen core and emulation module side)
STATUS, // ceil(log2(n))-bit
// emulation module->driver communication
AXIS, // 16-bits; 0 through 65535; 32768 is centered position
POINTER_X, // mouse pointer, 16-bits, signed - in-screen/window range before scaling/offseting normalized coordinates: [0.0, 1.0)
POINTER_Y, // see: mouse_scale_x, mouse_scale_y, mouse_offs_x, mouse_offs_y
AXIS_REL, // mouse relative motion, 16-bits, signed
BYTE_SPECIAL,
RESET_BUTTON, // 1-bit
BUTTON_ANALOG, // 16-bits, 0 - 65535
RUMBLE, // 16-bits, lower 8 bits are weak rumble(0-255), next 8 bits are strong rumble(0-255), 0=no rumble, 255=max rumble. Somewhat subjective, too...
}
[Flags]
public enum AxisFlags: byte
{
NONE = 0,
// Denotes analog data that may need to be scaled to ensure a more squareish logical range(for emulated analog sticks)
SQLR = 0x01,
// Invert config order of the two components(neg,pos) of the axis
INVERT_CO = 0x02,
SETTINGS_UNDOC = 0x80,
}
[Flags]
public enum DeviceFlags: uint
{
NONE = 0,
KEYBOARD = 1
}
[StructLayout(LayoutKind.Sequential)]
public struct NPortInfo
{
public IntPtr _shortName;
public IntPtr _fullName;
public IntPtr _defaultDeviceShortName;
public uint NumDevices;
public string ShortName => Mershul.PtrToStringUtf8(_shortName);
public string FullName => Mershul.PtrToStringUtf8(_fullName);
public string DefaultDeviceShortName => Mershul.PtrToStringUtf8(_defaultDeviceShortName);
}
[StructLayout(LayoutKind.Sequential)]
public struct NDeviceInfo
{
public IntPtr _shortName;
public IntPtr _fullName;
public IntPtr _description;
public DeviceFlags Flags;
public uint ByteLength;
public uint NumInputs;
public string ShortName => Mershul.PtrToStringUtf8(_shortName);
public string FullName => Mershul.PtrToStringUtf8(_fullName);
public string Description => Mershul.PtrToStringUtf8(_description);
}
[StructLayout(LayoutKind.Sequential)]
public struct NInputInfo
{
public IntPtr _settingName;
public IntPtr _name;
public short ConfigOrder;
public ushort BitOffset;
public InputType Type;
public AxisFlags Flags;
public byte BitSize;
public string SettingName => Mershul.PtrToStringUtf8(_settingName);
public string Name => Mershul.PtrToStringUtf8(_name);
}
[StructLayout(LayoutKind.Sequential)]
public struct NButtonInfo
{
public IntPtr _excludeName;
public string ExcludeName => Mershul.PtrToStringUtf8(_excludeName);
}
[StructLayout(LayoutKind.Sequential)]
public struct NAxisInfo
{
public IntPtr _settingsNameNeg;
public IntPtr _settingsNamePos;
public IntPtr _nameNeg;
public IntPtr _namePos;
public string SettingsNameNeg => Mershul.PtrToStringUtf8(_settingsNameNeg);
public string SettingsNamePos => Mershul.PtrToStringUtf8(_settingsNamePos);
public string NameNeg => Mershul.PtrToStringUtf8(_nameNeg);
public string NamePos => Mershul.PtrToStringUtf8(_namePos);
}
[StructLayout(LayoutKind.Sequential)]
public struct NSwitchInfo
{
public uint NumPositions;
public uint DefaultPosition;
[StructLayout(LayoutKind.Sequential)]
public struct Position
{
public IntPtr _settingName;
public IntPtr _name;
public IntPtr _description;
public string SettingName => Mershul.PtrToStringUtf8(_settingName);
public string Name => Mershul.PtrToStringUtf8(_name);
public string Description => Mershul.PtrToStringUtf8(_description);
}
}
[StructLayout(LayoutKind.Sequential)]
public struct NStatusInfo
{
public uint NumStates;
[StructLayout(LayoutKind.Sequential)]
public struct State
{
public IntPtr _shortName;
public IntPtr _name;
public int Color; // (msb)0RGB(lsb), -1 for unused.
public int _Padding;
public string ShortName => Mershul.PtrToStringUtf8(_shortName);
public string Name => Mershul.PtrToStringUtf8(_name);
}
}
[BizImport(CC, Compatibility = true)]
public abstract uint GetNumPorts();
[BizImport(CC, Compatibility = true)]
public abstract NPortInfo* GetPort(uint port);
[BizImport(CC, Compatibility = true)]
public abstract NDeviceInfo* GetDevice(uint port, uint dev);
[BizImport(CC, Compatibility = true)]
public abstract NInputInfo* GetInput(uint port, uint dev, uint input);
[BizImport(CC, Compatibility = true)]
public abstract NButtonInfo* GetButton(uint port, uint dev, uint input);
[BizImport(CC, Compatibility = true)]
public abstract NSwitchInfo* GetSwitch(uint port, uint dev, uint input);
[BizImport(CC, Compatibility = true)]
public abstract NSwitchInfo.Position* GetSwitchPosition(uint port, uint dev, uint input, int i);
[BizImport(CC, Compatibility = true)]
public abstract NStatusInfo* GetStatus(uint port, uint dev, uint input);
[BizImport(CC, Compatibility = true)]
public abstract NStatusInfo.State* GetStatusState(uint port, uint dev, uint input, int i);
[BizImport(CC, Compatibility = true)]
public abstract NAxisInfo* GetAxis(uint port, uint dev, uint input);
/// <summary>
/// Set what input devices we're going to use
/// </summary>
/// <param name="devices">MUST end with a null string</param>
[BizImport(CC, Compatibility = true)]
public abstract void SetInputDevices(string[] devices);
public enum VideoSystem : int
{
NONE,
PAL,
PAL_M,
NTSC,
SECAM
}
[StructLayout(LayoutKind.Sequential)]
public struct SystemInfo
{
public int MaxWidth;
public int MaxHeight;
public int NominalWidth;
public int NominalHeight;
public VideoSystem VideoSystem;
public int FpsFixed;
}
[BizImport(CC, Compatibility = true)]
public abstract SystemInfo* GetSystemInfo();
[BizImport(CC, Compatibility = true)]
public abstract void IterateSettings(int index, [In, Out]NymaCore.NymaSettingsInfo.MednaSettingS s);
[BizImport(CC, Compatibility = true)]
public abstract void IterateSettingEnums(int index, int enumIndex,[In, Out]NymaCore.NymaSettingsInfo.MednaSettingS.EnumValueS e);
public delegate void FrontendSettingQuery(string setting, IntPtr dest);
[BizImport(CC)]
public abstract void SetFrontendSettingQuery(FrontendSettingQuery q);
[StructLayout(LayoutKind.Sequential)]
public class TOC
{
public int FirstTrack;
public int LastTrack;
public int DiskType;
[StructLayout(LayoutKind.Sequential)]
public struct Track
{
public int Adr;
public int Control;
public int Lba;
public int Valid;
}
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 101)]
public Track[] Tracks;
}
[UnmanagedFunctionPointer(CC)]
public delegate void CDTOCCallback(int disk, [In, Out]TOC toc);
[UnmanagedFunctionPointer(CC)]
public delegate void CDSectorCallback(int disk, int lba, IntPtr dest);
[BizImport(CC)]
public abstract void SetCDCallbacks(CDTOCCallback toccallback, CDSectorCallback sectorcallback);
}
}

99
src/BizHawk.Emulation.Cores/Waterbox/LibWaterboxCore.cs
View File

@ -90,13 +90,17 @@ namespace BizHawk.Emulation.Cores.Waterbox
/// for a yuge endian domain, if true, bytes are stored word-swapped from their native ordering
/// </summary>
Swapped = 512,
/// <summary>
/// If true, Data is a function to call and not a pointer
/// </summary>
FunctionHook = 1024,
}
[StructLayout(LayoutKind.Sequential)]
public struct MemoryArea
{
/// <summary>
/// pointer to the data in memory
/// pointer to the data in memory, or a function hook to call
/// </summary>
public IntPtr Data;
/// <summary>
@ -110,99 +114,12 @@ namespace BizHawk.Emulation.Cores.Waterbox
public MemoryDomainFlags Flags;
}
[UnmanagedFunctionPointer(CC)]
public delegate void MemoryFunctionHook(IntPtr buffer, long address, long count, bool write);
[UnmanagedFunctionPointer(CC)]
public delegate void EmptyCallback();
public unsafe class WaterboxMemoryDomain : MemoryDomain
{
private readonly IntPtr _data;
private readonly IMonitor _monitor;
private readonly long _addressMangler;
public override byte PeekByte(long addr)
{
if ((ulong)addr < (ulong)Size)
{
using (_monitor.EnterExit())
{
return ((byte*)_data)[addr ^ _addressMangler];
}
}
throw new ArgumentOutOfRangeException(nameof(addr));
}
public override void PokeByte(long addr, byte val)
{
if (Writable)
{
if ((ulong)addr < (ulong)Size)
{
using (_monitor.EnterExit())
{
((byte*)_data)[addr ^ _addressMangler] = val;
}
}
else
{
throw new ArgumentOutOfRangeException(nameof(addr));
}
}
}
public override void BulkPeekByte(Range<long> addresses, byte[] values)
{
if (_addressMangler != 0)
{
base.BulkPeekByte(addresses, values);
return;
}
var start = (ulong)addresses.Start;
var count = addresses.Count();
if (start < (ulong)Size && (start + count) <= (ulong)Size)
{
using (_monitor.EnterExit())
{
Marshal.Copy(Z.US((ulong)_data + start), values, 0, (int)count);
}
}
else
{
throw new ArgumentOutOfRangeException(nameof(addresses));
}
}
public WaterboxMemoryDomain(MemoryArea m, IMonitor monitor)
{
Name = Marshal.PtrToStringAnsi(m.Name);
EndianType = (m.Flags & MemoryDomainFlags.YugeEndian) != 0 ? Endian.Big : Endian.Little;
_data = m.Data;
Size = m.Size;
Writable = (m.Flags & MemoryDomainFlags.Writable) != 0;
if ((m.Flags & MemoryDomainFlags.WordSize1) != 0)
WordSize = 1;
else if ((m.Flags & MemoryDomainFlags.WordSize2) != 0)
WordSize = 2;
else if ((m.Flags & MemoryDomainFlags.WordSize4) != 0)
WordSize = 4;
else if ((m.Flags & MemoryDomainFlags.WordSize8) != 0)
WordSize = 8;
else
throw new InvalidOperationException("Unknown word size for memory domain");
_monitor = monitor;
if ((m.Flags & MemoryDomainFlags.Swapped) != 0 && EndianType == Endian.Big)
{
_addressMangler = WordSize - 1;
}
else
{
_addressMangler = 0;
}
}
}
[BizImport(CC)]
public abstract void FrameAdvance([In, Out] FrameInfo frame);

50
src/BizHawk.Emulation.Cores/Waterbox/NymaCore.Cd.cs Normal file
View File

@ -0,0 +1,50 @@
using System;
using System.Runtime.InteropServices;
using BizHawk.Emulation.Common;
using BizHawk.Emulation.DiscSystem;
namespace BizHawk.Emulation.Cores.Waterbox
{
abstract partial class NymaCore : IDriveLight
{
// this code was mostly copied from Saturnus, which it will replace soon(R)
private static readonly DiscSectorReaderPolicy _diskPolicy = new DiscSectorReaderPolicy
{
DeinterleavedSubcode = false
};
private LibNymaCore.CDTOCCallback _cdTocCallback;
private LibNymaCore.CDSectorCallback _cdSectorCallback;
private Disc[] _disks;
private DiscSectorReader[] _diskReaders;
private static void SetupTOC(LibNymaCore.TOC t, DiscTOC tin)
{
// everything that's not commented, we're sure about
t.FirstTrack = tin.FirstRecordedTrackNumber;
t.LastTrack = tin.LastRecordedTrackNumber;
t.DiskType = (int)tin.Session1Format;
for (int i = 0; i < 101; i++)
{
t.Tracks[i].Adr = tin.TOCItems[i].Exists ? 1 : 0; // ????
t.Tracks[i].Lba = tin.TOCItems[i].LBA;
t.Tracks[i].Control = (int)tin.TOCItems[i].Control;
t.Tracks[i].Valid = tin.TOCItems[i].Exists ? 1 : 0;
}
}
private void CDTOCCallback(int disk, [In, Out]LibNymaCore.TOC t)
{
SetupTOC(t, _disks[disk].TOC);
}
private void CDSectorCallback(int disk, int lba, IntPtr dest)
{
var buff = new byte[2448];
_diskReaders[disk].ReadLBA_2448(lba, buff, 0);
Marshal.Copy(buff, 0, dest, 2448);
DriveLightOn = true;
}
public bool DriveLightEnabled => _disks?.Length > 0;
public bool DriveLightOn { get; private set; }
}
}

188
src/BizHawk.Emulation.Cores/Waterbox/NymaCore.Controller.cs Normal file
View File

@ -0,0 +1,188 @@
using System;
using System.Collections.Generic;
using System.Linq;
using BizHawk.Emulation.Common;
namespace BizHawk.Emulation.Cores.Waterbox
{
unsafe partial class NymaCore
{
private ControllerAdapter _controllerAdapter;
private readonly byte[] _inputPortData = new byte[16 * 16];
private readonly string _controllerDeckName;
private void InitControls()
{
_controllerAdapter = new ControllerAdapter(_nyma, _syncSettingsActual.PortDevices);
_nyma.SetInputDevices(_controllerAdapter.Devices);
ControllerDefinition = _controllerAdapter.Definition;
}
protected delegate void ControllerThunk(IController c, byte[] b);
protected class ControllerAdapter
{
/// <summary>
/// allowed number of input ports. must match native
/// </summary>
private const int MAX_PORTS = 16;
/// <summary>
/// total maximum bytes on each input port. must match native
/// </summary>
private const int MAX_PORT_DATA = 16;
/// <summary>
/// Device list suitable to pass back to the core
/// </summary>
public string[] Devices { get; }
public ControllerDefinition Definition { get; }
public ControllerAdapter(LibNymaCore core, IList<string> config)
{
var ret = new ControllerDefinition
{
Name = "Mednafen Controller"
};
var finalDevices = new List<string>();
var numPorts = core.GetNumPorts();
if (numPorts > MAX_PORTS)
throw new InvalidOperationException($"Too many input ports");
for (uint port = 0, devByteStart = 0; port < numPorts; port++, devByteStart += MAX_PORT_DATA)
{
var portInfo = *core.GetPort(port);
var deviceName = port < config.Count ? config[(int)port] : portInfo.DefaultDeviceShortName;
finalDevices.Add(deviceName);
var devices = Enumerable.Range(0, (int)portInfo.NumDevices)
.Select(i => new { Index = (uint)i, Device = *core.GetDevice(port, (uint)i) })
.ToList();
var device = devices.FirstOrDefault(a => a.Device.ShortName == deviceName);
if (device == null)
{
Console.WriteLine($"Warn: unknown controller device {deviceName}");
device = devices.FirstOrDefault(a => a.Device.ShortName == portInfo.DefaultDeviceShortName);
if (device == null)
throw new InvalidOperationException($"Fail: unknown controller device {portInfo.DefaultDeviceShortName}");
}
var deviceInfo = device.Device;
if (deviceInfo.ByteLength > MAX_PORT_DATA)
throw new InvalidOperationException($"Input device {deviceInfo.ShortName} uses more than {MAX_PORT_DATA} bytes");
var category = portInfo.FullName + " - " + deviceInfo.FullName;
var inputs = Enumerable.Range(0, (int)deviceInfo.NumInputs)
.Select(i => new { Index = i, Data = *core.GetInput(port, device.Index, (uint)i) })
.OrderBy(a => a.Data.ConfigOrder);
foreach (var input in inputs)
{
var inputInfo = input.Data;
var bitSize = (int)inputInfo.BitSize;
var bitOffset = (int)inputInfo.BitOffset;
var byteStart = devByteStart + bitOffset / 8;
bitOffset %= 8;
var name = $"P{port + 1} {inputInfo.Name}";
switch (inputInfo.Type)
{
case LibNymaCore.InputType.PADDING:
{
break;
}
case LibNymaCore.InputType.BUTTON:
case LibNymaCore.InputType.BUTTON_CAN_RAPID:
{
// var data = *core.GetButton(port, device.Index, (uint)input.Index);
// TODO: Wire up data.ExcludeName
ret.BoolButtons.Add(name);
_thunks.Add((c, b) =>
{
if (c.IsPressed(name))
b[byteStart] |= (byte)(1 << bitOffset);
});
break;
}
case LibNymaCore.InputType.SWITCH:
{
var data = *core.GetSwitch(port, device.Index, (uint)input.Index);
var zzhacky = (int)data.DefaultPosition;
// TODO: Possibly bulebutton for 2 states?
ret.AxisControls.Add(name);
ret.AxisRanges.Add(new ControllerDefinition.AxisRange(
0, (int)data.DefaultPosition, (int)data.NumPositions - 1));
_thunks.Add((c, b) =>
{
// HACK: Silently discard this until bizhawk fixes its shit
// var val = (int)Math.Round(c.AxisValue(name));
var val = zzhacky;
b[byteStart] |= (byte)(val << bitOffset);
});
break;
}
case LibNymaCore.InputType.AXIS:
{
// var data = core.GetAxis(port, device.Index, (uint)input.Index);
ret.AxisControls.Add(name);
ret.AxisRanges.Add(new ControllerDefinition.AxisRange(
0, 0x8000, 0xffff, (inputInfo.Flags & LibNymaCore.AxisFlags.INVERT_CO) != 0
));
_thunks.Add((c, b) =>
{
var val = (ushort)Math.Round(c.AxisValue(name));
b[byteStart] = (byte)val;
b[byteStart + 1] = (byte)(val >> 8);
});
break;
}
case LibNymaCore.InputType.AXIS_REL:
{
// var data = core.GetAxis(port, device.Index, (uint)input.Index);
ret.AxisControls.Add(name);
ret.AxisRanges.Add(new ControllerDefinition.AxisRange(
-0x8000, 0, 0x7fff, (inputInfo.Flags & LibNymaCore.AxisFlags.INVERT_CO) != 0
));
_thunks.Add((c, b) =>
{
var val = (short)Math.Round(c.AxisValue(name));
b[byteStart] = (byte)val;
b[byteStart + 1] = (byte)(val >> 8);
});
break;
}
case LibNymaCore.InputType.POINTER_X:
{
throw new Exception("TODO: Axis ranges are ints????");
// ret.AxisControls.Add(name);
// ret.AxisRanges.Add(new ControllerDefinition.AxisRange(0, 0.5, 1));
// break;
}
case LibNymaCore.InputType.POINTER_Y:
{
throw new Exception("TODO: Axis ranges are ints????");
// ret.AxisControls.Add(name);
// ret.AxisRanges.Add(new ControllerDefinition.AxisRange(0, 0.5, 1, true));
// break;
}
// TODO: wire up statuses to something (not controller, of course)
default:
throw new NotImplementedException($"Unimplemented button type {inputInfo.Type}");
}
ret.CategoryLabels[name] = category;
}
}
Definition = ret;
finalDevices.Add(null);
Devices = finalDevices.ToArray();
}
private readonly List<Action<IController, byte[]>> _thunks = new List<Action<IController, byte[]>>();
public void SetBits(IController src, byte[] dest)
{
Array.Clear(dest, 0, dest.Length);
foreach (var t in _thunks)
t(src, dest);
}
}
}
}

296
src/BizHawk.Emulation.Cores/Waterbox/NymaCore.Settings.cs Normal file
View File

@ -0,0 +1,296 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using BizHawk.Common;
using BizHawk.Emulation.Common;
namespace BizHawk.Emulation.Cores.Waterbox
{
unsafe partial class NymaCore : ISettable<NymaCore.NymaSettings, NymaCore.NymaSyncSettings>
{
public NymaSettingsInfo SettingsInfo { get; private set; }
private NymaSettings _settings;
private NymaSyncSettings _syncSettings;
/// <summary>
/// What this core was actually started with
/// </summary>
private NymaSyncSettings _syncSettingsActual;
public NymaSettings GetSettings() => _settings.Clone();
public NymaSyncSettings GetSyncSettings() => _syncSettings.Clone();
public PutSettingsDirtyBits PutSettings(NymaSettings o)
{
_settings = o.Clone();
if (SettingsInfo.LayerNames.Count > 0)
{
ulong layers = ~0ul;
for (int i = 0; i < 64 && i < SettingsInfo.LayerNames.Count; i++)
{
if (_settings.DisabledLayers.Contains(SettingsInfo.LayerNames[i]))
layers &= ~(1ul << i);
}
_nyma.SetLayers(layers);
}
return PutSettingsDirtyBits.None;
}
public PutSettingsDirtyBits PutSyncSettings(NymaSyncSettings o)
{
_syncSettings = o.Clone();
return _syncSettings.Equals(_syncSettingsActual)
? PutSettingsDirtyBits.None
: PutSettingsDirtyBits.RebootCore;
}
public class NymaSettings
{
public HashSet<string> DisabledLayers { get; set; } = new HashSet<string>();
public NymaSettings Clone()
{
return new NymaSettings { DisabledLayers = new HashSet<string>(DisabledLayers) };
}
}
public class NymaSyncSettings
{
public Dictionary<string, string> MednafenValues { get; set; } = new Dictionary<string, string>();
public List<string> PortDevices { get; set; } = new List<string>();
public NymaSyncSettings Clone()
{
return new NymaSyncSettings
{
MednafenValues = new Dictionary<string, string>(MednafenValues),
PortDevices = new List<string>(PortDevices)
};
}
public override bool Equals(object obj)
{
if (!(obj is NymaSyncSettings x))
return false;
return PortDevices.SequenceEqual(x.PortDevices)
&& new HashSet<KeyValuePair<string, string>>(MednafenValues).SetEquals(x.MednafenValues);
}
public override int GetHashCode()
{
return 0; // some other time, maybe
}
}
private void SettingsQuery(string name, IntPtr dest)
{
if (!_syncSettingsActual.MednafenValues.TryGetValue(name, out var val))
{
if (SettingsInfo.SettingsByKey.TryGetValue(name, out var info))
{
val = info.DefaultValue;
}
else
{
throw new InvalidOperationException($"Core asked for setting {name} which was not found in the defaults");
}
}
var bytes = Encoding.UTF8.GetBytes(val);
if (bytes.Length > 255)
throw new InvalidOperationException($"Value {val} for setting {name} was too long");
WaterboxUtils.ZeroMemory(dest, 256);
Marshal.Copy(bytes, 0, dest, bytes.Length);
}
private LibNymaCore.FrontendSettingQuery _settingsQueryDelegate;
public class NymaSettingsInfo
{
/// <summary>
/// What layers are available to toggle. If empty, layers cannot be set on this core.
/// </summary>
public List<string> LayerNames { get; set; }
public class Device
{
public string Name { get; set; }
public string Description { get; set; }
public string SettingValue { get; set; }
}
public class Port
{
public string Name { get; set; }
public List<Device> AllowedDevices { get; set; } = new List<Device>();
public string DefaultSettingsValue { get; set; }
}
/// <summary>
/// What devices can be plugged into each port
/// </summary>
public List<Port> Ports { get; set; } = new List<Port>();
public class MednaSetting
{
public string Name;
public string Description;
public string SettingsKey;
public string DefaultValue;
public string Min;
public string Max;
[Flags]
public enum SettingFlags : uint
{
NOFLAGS = 0U, // Always 0, makes setting definitions prettier...maybe.
// TODO(cats)
CAT_INPUT = (1U << 8),
CAT_SOUND = (1U << 9),
CAT_VIDEO = (1U << 10),
CAT_INPUT_MAPPING = (1U << 11), // User-configurable physical->virtual button/axes and hotkey mappings(driver-side code category mainly).
// Setting is used as a path or filename(mostly intended for automatic charset conversion of 0.9.x settings on MS Windows).
CAT_PATH = (1U << 12),
EMU_STATE = (1U << 17), // If the setting affects emulation from the point of view of the emulated program
UNTRUSTED_SAFE = (1U << 18), // If it's safe for an untrusted source to modify it, probably only used in conjunction with
// MDFNST_EX_EMU_STATE and network play
SUPPRESS_DOC = (1U << 19), // Suppress documentation generation for this setting.
COMMON_TEMPLATE = (1U << 20), // Auto-generated common template setting(like nes.xscale, pce.xscale, vb.xscale, nes.enable, pce.enable, vb.enable)
NONPERSISTENT = (1U << 21), // Don't save setting in settings file.
// TODO:
// WILL_BREAK_GAMES (1U << ) // If changing the value of the setting from the default value will break games/programs that would otherwise work.
// TODO(in progress):
REQUIRES_RELOAD = (1U << 24), // If a game reload is required for the setting to take effect.
REQUIRES_RESTART = (1U << 25), // If Mednafen restart is required for the setting to take effect.
}
public SettingFlags Flags;
public enum SettingType : int
{
INT = 0, // (signed), int8, int16, int32, int64(saved as)
UINT, // uint8, uint16, uint32, uint64(saved as)
/// <summary>
/// 0 or 1
/// </summary>
BOOL,
/// <summary>
/// float64
/// </summary>
FLOAT,
STRING,
/// <summary>
/// string value from a list of potential strings
/// </summary>
ENUM,
/// <summary>
/// TODO: How do these work
/// </summary>
MULTI_ENUM,
/// <summary>
/// Shouldn't see any of these
/// </summary>
ALIAS
}
public SettingType Type;
public class EnumValue
{
public string Name;
public string Description;
public string Value;
public EnumValue(MednaSettingS.EnumValueS s)
{
Name = Mershul.PtrToStringUtf8(s.Name);
Description = Mershul.PtrToStringUtf8(s.Description);
Value = Mershul.PtrToStringUtf8(s.Value);
}
}
public MednaSetting(MednaSettingS s)
{
Name = Mershul.PtrToStringUtf8(s.Name);
Description = Mershul.PtrToStringUtf8(s.Description);
SettingsKey = Mershul.PtrToStringUtf8(s.SettingsKey);
DefaultValue = Mershul.PtrToStringUtf8(s.DefaultValue);
Min = Mershul.PtrToStringUtf8(s.Min);
Max = Mershul.PtrToStringUtf8(s.Max);
Flags = (SettingFlags)s.Flags;
Type = (SettingType)s.Type;
}
}
[StructLayout(LayoutKind.Sequential)]
public class MednaSettingS
{
public IntPtr Name;
public IntPtr Description;
public IntPtr SettingsKey;
public IntPtr DefaultValue;
public IntPtr Min;
public IntPtr Max;
public uint Flags;
public int Type;
[StructLayout(LayoutKind.Sequential)]
public class EnumValueS
{
public IntPtr Name;
public IntPtr Description;
public IntPtr Value;
}
}
public List<MednaSetting> Settings { get; set; } = new List<MednaSetting>();
public Dictionary<string, List<MednaSetting.EnumValue>> SettingEnums { get; set; } = new Dictionary<string, List<MednaSetting.EnumValue>>();
public Dictionary<string, MednaSetting> SettingsByKey { get; set; } = new Dictionary<string, MednaSetting>();
}
private void InitSyncSettingsInfo()
{
// TODO: Some shared logic in ControllerAdapter. Avoidable?
var s = new NymaSettingsInfo();
var numPorts = _nyma.GetNumPorts();
for (uint port = 0; port < numPorts; port++)
{
var portInfo = *_nyma.GetPort(port);
s.Ports.Add(new NymaSettingsInfo.Port
{
Name = portInfo.FullName,
DefaultSettingsValue = portInfo.DefaultDeviceShortName,
AllowedDevices = Enumerable.Range(0, (int)portInfo.NumDevices)
.Select(i =>
{
var dev = *_nyma.GetDevice(port, (uint)i);
return new NymaSettingsInfo.Device
{
Name = dev.FullName,
Description = dev.Description,
SettingValue = dev.ShortName
};
})
.ToList()
});
}
for (var i = 0;; i++)
{
var tt = new NymaSettingsInfo.MednaSettingS();
_nyma.IterateSettings(i, tt);
if (tt.SettingsKey == IntPtr.Zero)
break;
var ss = new NymaSettingsInfo.MednaSetting(tt);
s.Settings.Add(ss);
s.SettingsByKey.Add(ss.SettingsKey, ss);
if (ss.Type == NymaSettingsInfo.MednaSetting.SettingType.ENUM)
{
var l = new List<NymaSettingsInfo.MednaSetting.EnumValue>();
for (var j = 0;; j++)
{
var ff = new NymaSettingsInfo.MednaSettingS.EnumValueS();
_nyma.IterateSettingEnums(i, j, ff);
if (ff.Value == IntPtr.Zero)
break;
var ee = new NymaSettingsInfo.MednaSetting.EnumValue(ff);
l.Add(ee);
}
s.SettingEnums.Add(ss.SettingsKey, l);
}
}
SettingsInfo = s;
}
}
}

184
src/BizHawk.Emulation.Cores/Waterbox/NymaCore.cs Normal file
View File

@ -0,0 +1,184 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using BizHawk.Common;
using BizHawk.Emulation.Common;
using BizHawk.Emulation.DiscSystem;
namespace BizHawk.Emulation.Cores.Waterbox
{
public unsafe abstract partial class NymaCore : WaterboxCore
{
protected NymaCore(CoreComm comm,
string systemId, string controllerDeckName,
NymaSettings settings, NymaSyncSettings syncSettings)
: base(comm, new Configuration { SystemId = systemId })
{
_settings = settings ?? new NymaSettings();
_syncSettings = syncSettings ?? new NymaSyncSettings();
_syncSettingsActual = _syncSettings;
_controllerDeckName = controllerDeckName;
}
private LibNymaCore _nyma;
protected T DoInit<T>(GameInfo game, byte[] rom, Disc[] discs, string wbxFilename, string extension,
ICollection<KeyValuePair<string, byte[]>> firmwares = null)
where T : LibNymaCore
{
var t = PreInit<T>(new WaterboxOptions
{
// TODO fix these up
Filename = wbxFilename,
SbrkHeapSizeKB = 1024 * 16,
SealedHeapSizeKB = 1024 * 16,
InvisibleHeapSizeKB = 1024 * 16,
PlainHeapSizeKB = 1024 * 16,
MmapHeapSizeKB = 1024 * 16,
SkipCoreConsistencyCheck = CoreComm.CorePreferences.HasFlag(CoreComm.CorePreferencesFlags.WaterboxCoreConsistencyCheck),
SkipMemoryConsistencyCheck = CoreComm.CorePreferences.HasFlag(CoreComm.CorePreferencesFlags.WaterboxMemoryConsistencyCheck),
});
_nyma = t;
_settingsQueryDelegate = new LibNymaCore.FrontendSettingQuery(SettingsQuery);
using (_exe.EnterExit())
{
_nyma.PreInit();
InitSyncSettingsInfo();
_nyma.SetFrontendSettingQuery(_settingsQueryDelegate);
if (firmwares != null)
{
foreach (var kvp in firmwares)
{
_exe.AddReadonlyFile(kvp.Value, kvp.Key);
}
}
if (discs?.Length > 0)
{
_disks = discs;
_diskReaders = _disks.Select(d => new DiscSectorReader(d) { Policy = _diskPolicy }).ToArray();
_cdTocCallback = CDTOCCallback;
_cdSectorCallback = CDSectorCallback;
_nyma.SetCDCallbacks(_cdTocCallback, _cdSectorCallback);
var didInit = _nyma.InitCd(_disks.Length);
if (!didInit)
throw new InvalidOperationException("Core rejected the CDs!");
}
else
{
var fn = game.FilesystemSafeName();
_exe.AddReadonlyFile(rom, fn);
var didInit = _nyma.InitRom(new LibNymaCore.InitData
{
// TODO: Set these as some cores need them
FileNameBase = "",
FileNameExt = extension.Trim('.').ToLowerInvariant(),
FileNameFull = fn
});
if (!didInit)
throw new InvalidOperationException("Core rejected the rom!");
_exe.RemoveReadonlyFile(fn);
}
if (firmwares != null)
{
foreach (var kvp in firmwares)
{
_exe.RemoveReadonlyFile(kvp.Key);
}
}
var info = *_nyma.GetSystemInfo();
_videoBuffer = new int[info.MaxWidth * info.MaxHeight];
BufferWidth = info.NominalWidth;
BufferHeight = info.NominalHeight;
switch (info.VideoSystem)
{
// TODO: There seriously isn't any region besides these?
case LibNymaCore.VideoSystem.PAL:
case LibNymaCore.VideoSystem.SECAM:
Region = DisplayType.PAL;
break;
case LibNymaCore.VideoSystem.PAL_M:
Region = DisplayType.Dendy; // sort of...
break;
default:
Region = DisplayType.NTSC;
break;
}
VsyncNumerator = info.FpsFixed;
VsyncDenominator = 1 << 24;
_soundBuffer = new short[22050 * 2];
InitControls();
_nyma.SetFrontendSettingQuery(null);
_nyma.SetCDCallbacks(null, null);
PostInit();
SettingsInfo.LayerNames = GetLayerData();
_nyma.SetFrontendSettingQuery(_settingsQueryDelegate);
_nyma.SetCDCallbacks(_cdTocCallback, _cdSectorCallback);
PutSettings(_settings);
}
return t;
}
protected override void LoadStateBinaryInternal(BinaryReader reader)
{
_nyma.SetFrontendSettingQuery(_settingsQueryDelegate);
_nyma.SetCDCallbacks(_cdTocCallback, _cdSectorCallback);
}
// todo: bleh
private GCHandle _frameAdvanceInputLock;
protected override LibWaterboxCore.FrameInfo FrameAdvancePrep(IController controller, bool render, bool rendersound)
{
DriveLightOn = false;
_controllerAdapter.SetBits(controller, _inputPortData);
_frameAdvanceInputLock = GCHandle.Alloc(_inputPortData, GCHandleType.Pinned);
var ret = new LibNymaCore.FrameInfo
{
SkipRendering = (short)(render ? 0 : 1),
SkipSoundening =(short)(rendersound ? 0 : 1),
Command = LibNymaCore.CommandType.NONE,
InputPortData = (byte*)_frameAdvanceInputLock.AddrOfPinnedObject()
};
return ret;
}
protected override void FrameAdvancePost()
{
_frameAdvanceInputLock.Free();
}
public DisplayType Region { get; protected set; }
/// <summary>
/// Gets a string array of valid layers to pass to SetLayers, or an empty list if that method should not be called
/// </summary>
private List<string> GetLayerData()
{
var ret = new List<string>();
var p = _nyma.GetLayerData();
if (p == null)
return ret;
var q = p;
while (true)
{
if (*q == 0)
{
if (q > p)
ret.Add(Mershul.PtrToStringUtf8((IntPtr)p));
else
break;
p = q + 1;
}
q++;
}
return ret;
}
}
}

140
src/BizHawk.Emulation.Cores/Waterbox/Syscalls/Errno.cs Normal file
View File

@ -0,0 +1,140 @@
namespace BizHawk.Emulation.Cores.Waterbox
{
partial class Syscalls
{
internal const int EPERM = 1;
internal const int ENOENT = 2;
internal const int ESRCH = 3;
internal const int EINTR = 4;
internal const int EIO = 5;
internal const int ENXIO = 6;
internal const int E2BIG = 7;
internal const int ENOEXEC = 8;
internal const int EBADF = 9;
internal const int ECHILD = 10;
internal const int EAGAIN = 11;
internal const int ENOMEM = 12;
internal const int EACCES = 13;
internal const int EFAULT = 14;
internal const int ENOTBLK = 15;
internal const int EBUSY = 16;
internal const int EEXIST = 17;
internal const int EXDEV = 18;
internal const int ENODEV = 19;
internal const int ENOTDIR = 20;
internal const int EISDIR = 21;
internal const int EINVAL = 22;
internal const int ENFILE = 23;
internal const int EMFILE = 24;
internal const int ENOTTY = 25;
internal const int ETXTBSY = 26;
internal const int EFBIG = 27;
internal const int ENOSPC = 28;
internal const int ESPIPE = 29;
internal const int EROFS = 30;
internal const int EMLINK = 31;
internal const int EPIPE = 32;
internal const int EDOM = 33;
internal const int ERANGE = 34;
internal const int EDEADLK = 35;
internal const int ENAMETOOLONG = 36;
internal const int ENOLCK = 37;
internal const int ENOSYS = 38;
internal const int ENOTEMPTY = 39;
internal const int ELOOP = 40;
internal const int EWOULDBLOCK = EAGAIN;
internal const int ENOMSG = 42;
internal const int EIDRM = 43;
internal const int ECHRNG = 44;
internal const int EL2NSYNC = 45;
internal const int EL3HLT = 46;
internal const int EL3RST = 47;
internal const int ELNRNG = 48;
internal const int EUNATCH = 49;
internal const int ENOCSI = 50;
internal const int EL2HLT = 51;
internal const int EBADE = 52;
internal const int EBADR = 53;
internal const int EXFULL = 54;
internal const int ENOANO = 55;
internal const int EBADRQC = 56;
internal const int EBADSLT = 57;
internal const int EDEADLOCK = EDEADLK;
internal const int EBFONT = 59;
internal const int ENOSTR = 60;
internal const int ENODATA = 61;
internal const int ETIME = 62;
internal const int ENOSR = 63;
internal const int ENONET = 64;
internal const int ENOPKG = 65;
internal const int EREMOTE = 66;
internal const int ENOLINK = 67;
internal const int EADV = 68;
internal const int ESRMNT = 69;
internal const int ECOMM = 70;
internal const int EPROTO = 71;
internal const int EMULTIHOP = 72;
internal const int EDOTDOT = 73;
internal const int EBADMSG = 74;
internal const int EOVERFLOW = 75;
internal const int ENOTUNIQ = 76;
internal const int EBADFD = 77;
internal const int EREMCHG = 78;
internal const int ELIBACC = 79;
internal const int ELIBBAD = 80;
internal const int ELIBSCN = 81;
internal const int ELIBMAX = 82;
internal const int ELIBEXEC = 83;
internal const int EILSEQ = 84;
internal const int ERESTART = 85;
internal const int ESTRPIPE = 86;
internal const int EUSERS = 87;
internal const int ENOTSOCK = 88;
internal const int EDESTADDRREQ = 89;
internal const int EMSGSIZE = 90;
internal const int EPROTOTYPE = 91;
internal const int ENOPROTOOPT = 92;
internal const int EPROTONOSUPPORT = 93;
internal const int ESOCKTNOSUPPORT = 94;
internal const int EOPNOTSUPP = 95;
internal const int ENOTSUP = EOPNOTSUPP;
internal const int EPFNOSUPPORT = 96;
internal const int EAFNOSUPPORT = 97;
internal const int EADDRINUSE = 98;
internal const int EADDRNOTAVAIL = 99;
internal const int ENETDOWN = 100;
internal const int ENETUNREACH = 101;
internal const int ENETRESET = 102;
internal const int ECONNABORTED = 103;
internal const int ECONNRESET = 104;
internal const int ENOBUFS = 105;
internal const int EISCONN = 106;
internal const int ENOTCONN = 107;
internal const int ESHUTDOWN = 108;
internal const int ETOOMANYREFS = 109;
internal const int ETIMEDOUT = 110;
internal const int ECONNREFUSED = 111;
internal const int EHOSTDOWN = 112;
internal const int EHOSTUNREACH = 113;
internal const int EALREADY = 114;
internal const int EINPROGRESS = 115;
internal const int ESTALE = 116;
internal const int EUCLEAN = 117;
internal const int ENOTNAM = 118;
internal const int ENAVAIL = 119;
internal const int EISNAM = 120;
internal const int EREMOTEIO = 121;
internal const int EDQUOT = 122;
internal const int ENOMEDIUM = 123;
internal const int EMEDIUMTYPE = 124;
internal const int ECANCELED = 125;
internal const int ENOKEY = 126;
internal const int EKEYEXPIRED = 127;
internal const int EKEYREVOKED = 128;
internal const int EKEYREJECTED = 129;
internal const int EOWNERDEAD = 130;
internal const int ENOTRECOVERABLE = 131;
internal const int ERFKILL = 132;
internal const int EHWPOISON = 133;
}
}

194
src/BizHawk.Emulation.Cores/Waterbox/Syscalls/MMan.cs Normal file
View File

@ -0,0 +1,194 @@
using System;
using System.Runtime.InteropServices;
using BizHawk.BizInvoke;
namespace BizHawk.Emulation.Cores.Waterbox
{
partial class Syscalls
{
internal const long MAP_FAILED = -1;
internal const ulong MAP_SHARED = 0x01;
internal const ulong MAP_PRIVATE = 0x02;
internal const ulong MAP_SHARED_VALIDATE = 0x03;
internal const ulong MAP_TYPE = 0x0f;
internal const ulong MAP_FIXED = 0x10;
internal const ulong MAP_ANON = 0x20;
internal const ulong MAP_ANONYMOUS = MAP_ANON;
internal const ulong MAP_NORESERVE = 0x4000;
internal const ulong MAP_GROWSDOWN = 0x0100;
internal const ulong MAP_DENYWRITE = 0x0800;
internal const ulong MAP_EXECUTABLE = 0x1000;
internal const ulong MAP_LOCKED = 0x2000;
internal const ulong MAP_POPULATE = 0x8000;
internal const ulong MAP_NONBLOCK = 0x10000;
internal const ulong MAP_STACK = 0x20000;
internal const ulong MAP_HUGETLB = 0x40000;
internal const ulong MAP_SYNC = 0x80000;
internal const ulong MAP_FIXED_NOREPLACE = 0x100000;
internal const ulong MAP_FILE = 0;
internal const ulong MAP_HUGE_SHIFT = 26;
internal const ulong MAP_HUGE_MASK = 0x3f;
internal const ulong MAP_HUGE_64KB = (16 << 26);
internal const ulong MAP_HUGE_512KB = (19 << 26);
internal const ulong MAP_HUGE_1MB = (20 << 26);
internal const ulong MAP_HUGE_2MB = (21 << 26);
internal const ulong MAP_HUGE_8MB = (23 << 26);
internal const ulong MAP_HUGE_16MB = (24 << 26);
internal const ulong MAP_HUGE_32MB = (25 << 26);
internal const ulong MAP_HUGE_256MB = (28 << 26);
internal const ulong MAP_HUGE_512MB = (29 << 26);
internal const ulong MAP_HUGE_1GB = (30 << 26);
internal const ulong MAP_HUGE_2GB = (31 << 26);
internal const ulong MAP_HUGE_16GB = (34U << 26);
internal const ulong PROT_NONE = 0;
internal const ulong PROT_READ = 1;
internal const ulong PROT_WRITE = 2;
internal const ulong PROT_EXEC = 4;
internal const ulong PROT_GROWSDOWN = 0x01000000;
internal const ulong PROT_GROWSUP = 0x02000000;
internal const ulong MS_ASYNC = 1;
internal const ulong MS_INVALIDATE = 2;
internal const ulong MS_SYNC = 4;
internal const ulong MCL_CURRENT = 1;
internal const ulong MCL_FUTURE = 2;
internal const ulong MCL_ONFAULT = 4;
internal const ulong POSIX_MADV_NORMAL = 0;
internal const ulong POSIX_MADV_RANDOM = 1;
internal const ulong POSIX_MADV_SEQUENTIAL = 2;
internal const ulong POSIX_MADV_WILLNEED = 3;
internal const ulong POSIX_MADV_DONTNEED = 4;
internal const ulong MADV_NORMAL = 0;
internal const ulong MADV_RANDOM = 1;
internal const ulong MADV_SEQUENTIAL = 2;
internal const ulong MADV_WILLNEED = 3;
internal const ulong MADV_DONTNEED = 4;
internal const ulong MADV_FREE = 8;
internal const ulong MADV_REMOVE = 9;
internal const ulong MADV_DONTFORK = 10;
internal const ulong MADV_DOFORK = 11;
internal const ulong MADV_MERGEABLE = 12;
internal const ulong MADV_UNMERGEABLE = 13;
internal const ulong MADV_HUGEPAGE = 14;
internal const ulong MADV_NOHUGEPAGE = 15;
internal const ulong MADV_DONTDUMP = 16;
internal const ulong MADV_DODUMP = 17;
internal const ulong MADV_WIPEONFORK = 18;
internal const ulong MADV_KEEPONFORK = 19;
internal const ulong MADV_COLD = 20;
internal const ulong MADV_PAGEOUT = 21;
internal const ulong MADV_HWPOISON = 100;
internal const ulong MADV_SOFT_OFFLINE = 101;
internal const ulong MREMAP_MAYMOVE = 1;
internal const ulong MREMAP_FIXED = 2;
internal const ulong MLOCK_ONFAULT = 0x01;
internal const ulong MFD_CLOEXEC = 0x0001U;
internal const ulong MFD_ALLOW_SEALING = 0x0002U;
internal const ulong MFD_HUGETLB = 0x0004U;
[BizExport(CallingConvention.Cdecl, EntryPoint = "__wsyscalltab[9]")]
public IntPtr MMap(IntPtr address, UIntPtr size, ulong prot, ulong flags, int fd, IntPtr offs)
{
if (address != IntPtr.Zero)
{
// waterbox cores generally don't know about hardcoded addresses
// we could support this, so long as the address is in our heap's range
return Z.SS(MAP_FAILED);
}
MemoryBlock.Protection mprot;
switch (prot)
{
case PROT_NONE:
mprot = MemoryBlock.Protection.None;
break;
default:
case PROT_WRITE | PROT_EXEC: // W^X
case PROT_READ | PROT_WRITE | PROT_EXEC: // W^X
case PROT_EXEC: // exec only????
case PROT_WRITE:
return Z.SS(MAP_FAILED); // write only????
case PROT_READ | PROT_WRITE:
mprot = MemoryBlock.Protection.RW;
break;
case PROT_READ:
mprot = MemoryBlock.Protection.R;
break;
case PROT_READ | PROT_EXEC:
mprot = MemoryBlock.Protection.RX;
break;
}
if ((flags & MAP_ANONYMOUS) == 0)
{
// anonymous + private is easy
// anonymous by itself is hard
// nothing needs either right now
return Z.SS(MAP_FAILED);
}
if ((flags & 0xf00) != 0)
{
// various unsupported flags
return Z.SS(MAP_FAILED);
}
var ret = _parent._mmapheap.Map((ulong)size, mprot);
return ret == 0 ? Z.SS(MAP_FAILED) : Z.US(ret);
}
[BizExport(CallingConvention.Cdecl, EntryPoint = "__wsyscalltab[25]")]
public IntPtr MRemap(UIntPtr oldAddress, UIntPtr oldSize,
UIntPtr newSize, ulong flags)
{
if ((flags & MREMAP_FIXED) != 0)
{
// just like mmap.
// waterbox cores generally don't know about hardcoded addresses
// we could support this, so long as the address is in our heap's range
return Z.SS(MAP_FAILED);
}
var ret = _parent._mmapheap.Remap((ulong)oldAddress, (ulong)oldSize, (ulong)newSize,
(flags & MREMAP_MAYMOVE) != 0);
return ret == 0 ? Z.SS(MAP_FAILED) : Z.US(ret);
}
[BizExport(CallingConvention.Cdecl, EntryPoint = "__wsyscalltab[11]")]
public long MUnmap(UIntPtr address, UIntPtr size)
{
return _parent._mmapheap.Unmap((ulong)address, (ulong)size) ? 0 : MAP_FAILED;
}
[BizExport(CallingConvention.Cdecl, EntryPoint = "__wsyscalltab[10]")]
public long MProtect(UIntPtr address, UIntPtr size, ulong prot)
{
MemoryBlock.Protection mprot;
switch (prot)
{
case PROT_NONE:
mprot = MemoryBlock.Protection.None;
break;
default:
case PROT_WRITE | PROT_EXEC: // W^X
case PROT_READ | PROT_WRITE | PROT_EXEC: // W^X
case PROT_EXEC: // exec only????
case PROT_WRITE:
return MAP_FAILED; // write only????
case PROT_READ | PROT_WRITE:
mprot = MemoryBlock.Protection.RW;
break;
case PROT_READ:
mprot = MemoryBlock.Protection.R;
break;
case PROT_READ | PROT_EXEC:
mprot = MemoryBlock.Protection.RX;
break;
}
return _parent._mmapheap.Protect((ulong)address, (ulong)size, mprot) ? 0 : MAP_FAILED;
}
}
}

422
src/BizHawk.Emulation.Cores/Waterbox/Syscalls/NotImplementedSyscalls.cs Normal file
View File

@ -0,0 +1,422 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;
using BizHawk.BizInvoke;
using BizHawk.Common;
namespace BizHawk.Emulation.Cores.Waterbox
{
/// <summary>
/// Provides useful traps for any syscalls that are not implemented by libc
/// </summary>
internal class NotImplementedSyscalls : IImportResolver
{
private static readonly Dictionary<int, string> SyscallNames = new Dictionary<int, string>()
{
{ 0, "read" },
{ 1, "write" },
{ 2, "open" },
{ 3, "close" },
{ 4, "stat" },
{ 5, "fstat" },
{ 6, "lstat" },
{ 7, "poll" },
{ 8, "lseek" },
{ 9, "mmap" },
{ 10, "mprotect" },
{ 11, "munmap" },
{ 12, "brk" },
{ 13, "rt_sigaction" },
{ 14, "rt_sigprocmask" },
{ 15, "rt_sigreturn" },
{ 16, "ioctl" },
{ 17, "pread64" },
{ 18, "pwrite64" },
{ 19, "readv" },
{ 20, "writev" },
{ 21, "access" },
{ 22, "pipe" },
{ 23, "select" },
{ 24, "sched_yield" },
{ 25, "mremap" },
{ 26, "msync" },
{ 27, "mincore" },
{ 28, "madvise" },
{ 29, "shmget" },
{ 30, "shmat" },
{ 31, "shmctl" },
{ 32, "dup" },
{ 33, "dup2" },
{ 34, "pause" },
{ 35, "nanosleep" },
{ 36, "getitimer" },
{ 37, "alarm" },
{ 38, "setitimer" },
{ 39, "getpid" },
{ 40, "sendfile" },
{ 41, "socket" },
{ 42, "connect" },
{ 43, "accept" },
{ 44, "sendto" },
{ 45, "recvfrom" },
{ 46, "sendmsg" },
{ 47, "recvmsg" },
{ 48, "shutdown" },
{ 49, "bind" },
{ 50, "listen" },
{ 51, "getsockname" },
{ 52, "getpeername" },
{ 53, "socketpair" },
{ 54, "setsockopt" },
{ 55, "getsockopt" },
{ 56, "clone" },
{ 57, "fork" },
{ 58, "vfork" },
{ 59, "execve" },
{ 60, "exit" },
{ 61, "wait4" },
{ 62, "kill" },
{ 63, "uname" },
{ 64, "semget" },
{ 65, "semop" },
{ 66, "semctl" },
{ 67, "shmdt" },
{ 68, "msgget" },
{ 69, "msgsnd" },
{ 70, "msgrcv" },
{ 71, "msgctl" },
{ 72, "fcntl" },
{ 73, "flock" },
{ 74, "fsync" },
{ 75, "fdatasync" },
{ 76, "truncate" },
{ 77, "ftruncate" },
{ 78, "getdents" },
{ 79, "getcwd" },
{ 80, "chdir" },
{ 81, "fchdir" },
{ 82, "rename" },
{ 83, "mkdir" },
{ 84, "rmdir" },
{ 85, "creat" },
{ 86, "link" },
{ 87, "unlink" },
{ 88, "symlink" },
{ 89, "readlink" },
{ 90, "chmod" },
{ 91, "fchmod" },
{ 92, "chown" },
{ 93, "fchown" },
{ 94, "lchown" },
{ 95, "umask" },
{ 96, "gettimeofday" },
{ 97, "getrlimit" },
{ 98, "getrusage" },
{ 99, "sysinfo" },
{ 100, "times" },
{ 101, "ptrace" },
{ 102, "getuid" },
{ 103, "syslog" },
{ 104, "getgid" },
{ 105, "setuid" },
{ 106, "setgid" },
{ 107, "geteuid" },
{ 108, "getegid" },
{ 109, "setpgid" },
{ 110, "getppid" },
{ 111, "getpgrp" },
{ 112, "setsid" },
{ 113, "setreuid" },
{ 114, "setregid" },
{ 115, "getgroups" },
{ 116, "setgroups" },
{ 117, "setresuid" },
{ 118, "getresuid" },
{ 119, "setresgid" },
{ 120, "getresgid" },
{ 121, "getpgid" },
{ 122, "setfsuid" },
{ 123, "setfsgid" },
{ 124, "getsid" },
{ 125, "capget" },
{ 126, "capset" },
{ 127, "rt_sigpending" },
{ 128, "rt_sigtimedwait" },
{ 129, "rt_sigqueueinfo" },
{ 130, "rt_sigsuspend" },
{ 131, "sigaltstack" },
{ 132, "utime" },
{ 133, "mknod" },
{ 134, "uselib" },
{ 135, "personality" },
{ 136, "ustat" },
{ 137, "statfs" },
{ 138, "fstatfs" },
{ 139, "sysfs" },
{ 140, "getpriority" },
{ 141, "setpriority" },
{ 142, "sched_setparam" },
{ 143, "sched_getparam" },
{ 144, "sched_setscheduler" },
{ 145, "sched_getscheduler" },
{ 146, "sched_get_priority_max" },
{ 147, "sched_get_priority_min" },
{ 148, "sched_rr_get_interval" },
{ 149, "mlock" },
{ 150, "munlock" },
{ 151, "mlockall" },
{ 152, "munlockall" },
{ 153, "vhangup" },
{ 154, "modify_ldt" },
{ 155, "pivot_root" },
{ 156, "_sysctl" },
{ 157, "prctl" },
{ 158, "arch_prctl" },
{ 159, "adjtimex" },
{ 160, "setrlimit" },
{ 161, "chroot" },
{ 162, "sync" },
{ 163, "acct" },
{ 164, "settimeofday" },
{ 165, "mount" },
{ 166, "umount2" },
{ 167, "swapon" },
{ 168, "swapoff" },
{ 169, "reboot" },
{ 170, "sethostname" },
{ 171, "setdomainname" },
{ 172, "iopl" },
{ 173, "ioperm" },
{ 174, "create_module" },
{ 175, "init_module" },
{ 176, "delete_module" },
{ 177, "get_kernel_syms" },
{ 178, "query_module" },
{ 179, "quotactl" },
{ 180, "nfsservctl" },
{ 181, "getpmsg" },
{ 182, "putpmsg" },
{ 183, "afs_syscall" },
{ 184, "tuxcall" },
{ 185, "security" },
{ 186, "gettid" },
{ 187, "readahead" },
{ 188, "setxattr" },
{ 189, "lsetxattr" },
{ 190, "fsetxattr" },
{ 191, "getxattr" },
{ 192, "lgetxattr" },
{ 193, "fgetxattr" },
{ 194, "listxattr" },
{ 195, "llistxattr" },
{ 196, "flistxattr" },
{ 197, "removexattr" },
{ 198, "lremovexattr" },
{ 199, "fremovexattr" },
{ 200, "tkill" },
{ 201, "time" },
{ 202, "futex" },
{ 203, "sched_setaffinity" },
{ 204, "sched_getaffinity" },
{ 205, "set_thread_area" },
{ 206, "io_setup" },
{ 207, "io_destroy" },
{ 208, "io_getevents" },
{ 209, "io_submit" },
{ 210, "io_cancel" },
{ 211, "get_thread_area" },
{ 212, "lookup_dcookie" },
{ 213, "epoll_create" },
{ 214, "epoll_ctl_old" },
{ 215, "epoll_wait_old" },
{ 216, "remap_file_pages" },
{ 217, "getdents64" },
{ 218, "set_tid_address" },
{ 219, "restart_syscall" },
{ 220, "semtimedop" },
{ 221, "fadvise64" },
{ 222, "timer_create" },
{ 223, "timer_settime" },
{ 224, "timer_gettime" },
{ 225, "timer_getoverrun" },
{ 226, "timer_delete" },
{ 227, "clock_settime" },
{ 228, "clock_gettime" },
{ 229, "clock_getres" },
{ 230, "clock_nanosleep" },
{ 231, "exit_group" },
{ 232, "epoll_wait" },
{ 233, "epoll_ctl" },
{ 234, "tgkill" },
{ 235, "utimes" },
{ 236, "vserver" },
{ 237, "mbind" },
{ 238, "set_mempolicy" },
{ 239, "get_mempolicy" },
{ 240, "mq_open" },
{ 241, "mq_unlink" },
{ 242, "mq_timedsend" },
{ 243, "mq_timedreceive" },
{ 244, "mq_notify" },
{ 245, "mq_getsetattr" },
{ 246, "kexec_load" },
{ 247, "waitid" },
{ 248, "add_key" },
{ 249, "request_key" },
{ 250, "keyctl" },
{ 251, "ioprio_set" },
{ 252, "ioprio_get" },
{ 253, "inotify_init" },
{ 254, "inotify_add_watch" },
{ 255, "inotify_rm_watch" },
{ 256, "migrate_pages" },
{ 257, "openat" },
{ 258, "mkdirat" },
{ 259, "mknodat" },
{ 260, "fchownat" },
{ 261, "futimesat" },
{ 262, "newfstatat" },
{ 263, "unlinkat" },
{ 264, "renameat" },
{ 265, "linkat" },
{ 266, "symlinkat" },
{ 267, "readlinkat" },
{ 268, "fchmodat" },
{ 269, "faccessat" },
{ 270, "pselect6" },
{ 271, "ppoll" },
{ 272, "unshare" },
{ 273, "set_robust_list" },
{ 274, "get_robust_list" },
{ 275, "splice" },
{ 276, "tee" },
{ 277, "sync_file_range" },
{ 278, "vmsplice" },
{ 279, "move_pages" },
{ 280, "utimensat" },
{ 281, "epoll_pwait" },
{ 282, "signalfd" },
{ 283, "timerfd_create" },
{ 284, "eventfd" },
{ 285, "fallocate" },
{ 286, "timerfd_settime" },
{ 287, "timerfd_gettime" },
{ 288, "accept4" },
{ 289, "signalfd4" },
{ 290, "eventfd2" },
{ 291, "epoll_create1" },
{ 292, "dup3" },
{ 293, "pipe2" },
{ 294, "inotify_init1" },
{ 295, "preadv" },
{ 296, "pwritev" },
{ 297, "rt_tgsigqueueinfo" },
{ 298, "perf_event_open" },
{ 299, "recvmmsg" },
{ 300, "fanotify_init" },
{ 301, "fanotify_mark" },
{ 302, "prlimit64" },
{ 303, "name_to_handle_at" },
{ 304, "open_by_handle_at" },
{ 305, "clock_adjtime" },
{ 306, "syncfs" },
{ 307, "sendmmsg" },
{ 308, "setns" },
{ 309, "getcpu" },
{ 310, "process_vm_readv" },
{ 311, "process_vm_writev" },
{ 312, "kcmp" },
{ 313, "finit_module" },
{ 314, "sched_setattr" },
{ 315, "sched_getattr" },
{ 316, "renameat2" },
{ 317, "seccomp" },
{ 318, "getrandom" },
{ 319, "memfd_create" },
{ 320, "kexec_file_load" },
{ 321, "bpf" },
{ 322, "execveat" },
{ 323, "userfaultfd" },
{ 324, "membarrier" },
{ 325, "mlock2" },
{ 326, "copy_file_range" },
{ 327, "preadv2" },
{ 328, "pwritev2" },
{ 329, "pkey_mprotect" },
{ 330, "pkey_alloc" },
{ 331, "pkey_free" },
{ 332, "statx" },
{ 333, "io_pgetevents" },
{ 334, "rseq" },
{ 424, "pidfd_send_signal" },
{ 425, "io_uring_setup" },
{ 426, "io_uring_enter" },
{ 427, "io_uring_register" },
{ 428, "open_tree" },
{ 429, "move_mount" },
{ 430, "fsopen" },
{ 431, "fsconfig" },
{ 432, "fsmount" },
{ 433, "fspick" },
{ 434, "pidfd_open" },
{ 435, "clone3" },
};
private class Trap
{
private readonly int _index;
private readonly string _message;
private readonly IImportResolver _resolver;
public Trap(int index)
{
_index = index;
_resolver = BizExvoker.GetExvoker(this, CallingConventionAdapters.Waterbox);
if (!SyscallNames.TryGetValue(_index, out var name))
name = "???";
_message = $"Trapped on unimplemented syscall {name} (#{_index})";
}
[BizExport(CallingConvention.Cdecl, EntryPoint="@@")]
public void RunTrap()
{
System.Diagnostics.Debug.WriteLine(_message);
// TODO: this unwind never works, so debugbrk instead
System.Diagnostics.Debugger.Break();
throw new InvalidOperationException(_message);
}
public IntPtr FunctionPointer => _resolver.GetProcAddrOrThrow("@@");
}
private readonly List<Trap> _traps;
private NotImplementedSyscalls()
{
_traps = Enumerable.Range(0, 512)
.Select(i => new Trap(i))
.ToList();
}
private static readonly Regex ExportRegex = new Regex("__wsyscalltab\\[(\\d+)\\]");
public IntPtr GetProcAddrOrZero(string entryPoint)
{
var m = ExportRegex.Match(entryPoint);
if (m.Success)
{
return _traps[int.Parse(m.Groups[1].Value)].FunctionPointer;
}
return IntPtr.Zero;
}
public IntPtr GetProcAddrOrThrow(string entryPoint)
{
var m = ExportRegex.Match(entryPoint);
if (m.Success)
{
return _traps[int.Parse(m.Groups[1].Value)].FunctionPointer;
}
throw new InvalidOperationException($"{entryPoint} was not of the format __wsyscalltab[#]");
}
public static NotImplementedSyscalls Instance { get; } = new NotImplementedSyscalls();
}
}

120
src/BizHawk.Emulation.Cores/Waterbox/Syscalls/Stat.cs Normal file
View File

@ -0,0 +1,120 @@
using System;
using System.Runtime.InteropServices;
using BizHawk.BizInvoke;
namespace BizHawk.Emulation.Cores.Waterbox
{
unsafe partial class Syscalls
{
internal const uint S_IFMT = 61440;
internal const uint S_IFDIR = 16384;
internal const uint S_IFCHR = 8192;
internal const uint S_IFBLK = 24576;
internal const uint S_IFREG = 32768;
internal const uint S_IFIFO = 4096;
internal const uint S_IFLNK = 40960;
internal const uint S_IFSOCK = 49152;
internal const uint S_ISUID = 2048;
internal const uint S_ISGID = 1024;
internal const uint S_ISVTX = 512;
internal const uint S_IRUSR = 0400;
internal const uint S_IWUSR = 256;
internal const uint S_IXUSR = 64;
internal const uint S_IRWXU = 448;
internal const uint S_IRGRP = 32;
internal const uint S_IWGRP = 16;
internal const uint S_IXGRP = 8;
internal const uint S_IRWXG = 56;
internal const uint S_IROTH = 4;
internal const uint S_IWOTH = 2;
internal const uint S_IXOTH = 1;
internal const uint S_IRWXO = 7;
[StructLayout(LayoutKind.Sequential)]
public struct KStat
{
public ulong st_dev;
public ulong st_ino;
public ulong st_nlink;
public uint st_mode;
public uint st_uid;
public uint st_gid;
public uint __pad0;
public ulong st_rdev;
public long st_size;
public long st_blksize;
public long st_blocks;
public long st_atime_sec;
public long st_atime_nsec;
public long st_mtime_sec;
public long st_mtime_nsec;
public long st_ctime_sec;
public long st_ctime_nsec;
public long __unused0;
public long __unused1;
public long __unused2;
}
private void StatInternal(KStat* s, IFileObject o)
{
s->st_dev = 1;
s->st_ino = 1;
s->st_nlink = 0;
uint flags = 0;
if (o.Stream.CanRead)
flags |= S_IRUSR | S_IRGRP | S_IROTH;
if (o.Stream.CanWrite)
flags |= S_IWUSR | S_IWGRP | S_IWOTH;
if (o.Stream.CanSeek)
flags |= S_IFREG;
else
flags |= S_IFIFO;
s->st_mode = flags;
s->st_uid = 0;
s->st_gid = 0;
s->__pad0 = 0;
s->st_rdev = 0;
if (o.Stream.CanSeek)
s->st_size = o.Stream.Length;
else
s->st_size = 0;
s->st_blksize = 4096;
s->st_blocks = (s->st_size + 511) / 512;
s->st_atime_sec = 1262304000000;
s->st_atime_nsec = 1000000000 / 2;
s->st_mtime_sec = 1262304000000;
s->st_mtime_nsec = 1000000000 / 2;
s->st_ctime_sec = 1262304000000;
s->st_ctime_nsec = 1000000000 / 2;
}
[BizExport(CallingConvention.Cdecl, EntryPoint = "__wsyscalltab[4]")]
public long Stat(string path, KStat* statbuf)
{
if (!_availableFiles.TryGetValue(path, out var o))
return -ENOENT;
StatInternal(statbuf, o);
return 0;
}
[BizExport(CallingConvention.Cdecl, EntryPoint = "__wsyscalltab[5]")]
public long Fstat(int fd, KStat* statbuf)
{
if (fd < 0 || fd >= _openFiles.Count)
return -EBADF;
var o = _openFiles[fd];
if (o == null)
return -EBADF;
StatInternal(statbuf, o);
return 0;
}
}
}

181
src/BizHawk.Emulation.Cores/Waterbox/Syscalls.cs → src/BizHawk.Emulation.Cores/Waterbox/Syscalls/Syscalls.cs
View File

@ -3,7 +3,6 @@ using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;
using BizHawk.BizInvoke;
using BizHawk.Common;
using BizHawk.Emulation.Common;
@ -13,7 +12,7 @@ namespace BizHawk.Emulation.Cores.Waterbox
/// <summary>
/// syscall emulation layer
/// </summary>
internal class Syscalls : IBinaryStateable
internal partial class Syscalls : IBinaryStateable
{
public interface IFileObject : IBinaryStateable
{
@ -287,12 +286,12 @@ namespace BizHawk.Emulation.Cores.Waterbox
}
[BizExport(CallingConvention.Cdecl, EntryPoint = "__wsyscalltab[2]")]
public int Open(string path, int flags, int mode)
public long Open(string path, int flags, int mode)
{
if (!_availableFiles.TryGetValue(path, out var o))
return -1;
return -ENOENT;
if (_openFiles.Contains(o))
return -1;
return -EACCES;
FileAccess access;
switch (flags & 3)
{
@ -306,10 +305,10 @@ namespace BizHawk.Emulation.Cores.Waterbox
access = FileAccess.ReadWrite;
break;
default:
return -1;
return -EINVAL;
}
if (!o.Open(access))
return -1;
return -EACCES;
int fd;
for (fd = 0; fd < _openFiles.Count; fd++)
if (_openFiles[fd] == null)
@ -321,13 +320,15 @@ namespace BizHawk.Emulation.Cores.Waterbox
return fd;
}
[BizExport(CallingConvention.Cdecl, EntryPoint = "__wsyscalltab[3]")]
public int Close(int fd)
public long Close(int fd)
{
if (fd < 0 || fd >= _openFiles.Count)
return -1;
return -EBADF;
var o = _openFiles[fd];
if (o == null || !o.Close())
return -1;
if (o == null)
return -EBADF;
if (!o.Close())
return -EIO;
_openFiles[fd] = null;
return 0;
}
@ -335,8 +336,10 @@ namespace BizHawk.Emulation.Cores.Waterbox
public long Seek(int fd, long offset, int type)
{
var s = StreamForFd(fd);
if (s == null || !s.CanSeek)
return -1;
if (s == null)
return -EBADF;
if (!s.CanSeek)
return -ESPIPE;
SeekOrigin o;
switch (type)
{
@ -350,23 +353,20 @@ namespace BizHawk.Emulation.Cores.Waterbox
o = SeekOrigin.End;
break;
default:
return -1;
return -EINVAL;
}
try
{
return s.Seek(offset, o);
}
catch (IOException)
{
// usually means bad offset, since we already filtered out on CanSeek
return -EINVAL;
}
return s.Seek(offset, o);
}
[BizExport(CallingConvention.Cdecl, EntryPoint = "__wsyscalltab[4]")]
public int Stat(string path, IntPtr statbuf)
{
return -1;
}
[BizExport(CallingConvention.Cdecl, EntryPoint = "__wsyscalltab[5]")]
public int Fstat(int fd, IntPtr statbuf)
{
return -1;
}
// TODO: Remove this entirely once everything is compiled against the new libc
[BizExport(CallingConvention.Cdecl, EntryPoint = "__wsyscalltab[205]")]
public long SetThreadArea(IntPtr uinfo)
{
@ -376,6 +376,7 @@ namespace BizHawk.Emulation.Cores.Waterbox
[BizExport(CallingConvention.Cdecl, EntryPoint = "__wsyscalltab[218]")]
public long SetTidAddress(IntPtr address)
{
// pretend we succeeded
return 8675309; // arbitrary thread id
}
@ -394,76 +395,6 @@ namespace BizHawk.Emulation.Cores.Waterbox
return 0;
}
[BizExport(CallingConvention.Cdecl, EntryPoint = "__wsyscalltab[9]")]
public IntPtr MMap(IntPtr address, UIntPtr size, int prot, int flags, int fd, IntPtr offs)
{
if (address != IntPtr.Zero)
return Z.SS(-1);
MemoryBlock.Protection mprot;
switch (prot)
{
case 0: mprot = MemoryBlock.Protection.None; break;
default:
case 6: // W^X
case 7: // W^X
case 4: // exec only????
case 2: return Z.SS(-1); // write only????
case 3: mprot = MemoryBlock.Protection.RW; break;
case 1: mprot = MemoryBlock.Protection.R; break;
case 5: mprot = MemoryBlock.Protection.RX; break;
}
if ((flags & 0x20) == 0)
{
// MAP_ANONYMOUS is required
return Z.SS(-1);
}
if ((flags & 0xf00) != 0)
{
// various unsupported flags
return Z.SS(-1);
}
var ret = _parent._mmapheap.Map((ulong)size, mprot);
return ret == 0 ? Z.SS(-1) : Z.US(ret);
}
[BizExport(CallingConvention.Cdecl, EntryPoint = "__wsyscalltab[25]")]
public IntPtr MRemap(UIntPtr oldAddress, UIntPtr oldSize,
UIntPtr newSize, int flags)
{
if ((flags & 2) != 0)
{
// don't support MREMAP_FIXED
return Z.SS(-1);
}
var ret = _parent._mmapheap.Remap((ulong)oldAddress, (ulong)oldSize, (ulong)newSize,
(flags & 1) != 0);
return ret == 0 ? Z.SS(-1) : Z.US(ret);
}
[BizExport(CallingConvention.Cdecl, EntryPoint = "__wsyscalltab[11]")]
public int MUnmap(UIntPtr address, UIntPtr size)
{
return _parent._mmapheap.Unmap((ulong)address, (ulong)size) ? 0 : -1;
}
[BizExport(CallingConvention.Cdecl, EntryPoint = "__wsyscalltab[10]")]
public int MProtect(UIntPtr address, UIntPtr size, int prot)
{
MemoryBlock.Protection mprot;
switch (prot)
{
case 0: mprot = MemoryBlock.Protection.None; break;
default:
case 6: // W^X
case 7: // W^X
case 4: // exec only????
case 2: return -1; // write only????
case 3: mprot = MemoryBlock.Protection.RW; break;
case 1: mprot = MemoryBlock.Protection.R; break;
case 5: mprot = MemoryBlock.Protection.RX; break;
}
return _parent._mmapheap.Protect((ulong)address, (ulong)size, mprot) ? 0 : -1;
}
public void SaveStateBinary(BinaryWriter bw)
{
bw.Write(_availableFiles.Count);
@ -531,60 +462,4 @@ namespace BizHawk.Emulation.Cores.Waterbox
return RemoveFileInternal<TransientFile>(name).GetContents();
}
}
/// <summary>
/// Provides useful traps for any syscalls that are not implemented by libc
/// </summary>
internal class NotImplementedSyscalls : IImportResolver
{
private class Trap
{
private readonly int _index;
private readonly IImportResolver _resolver;
public Trap(int index)
{
_index = index;
_resolver = BizExvoker.GetExvoker(this, CallingConventionAdapters.Waterbox);
}
[BizExport(CallingConvention.Cdecl, EntryPoint="@@")]
public void RunTrap()
{
var s = $"Trapped on unimplemented syscall {_index}";
Console.WriteLine(s);
throw new InvalidOperationException(s);
}
public IntPtr FunctionPointer => _resolver.GetProcAddrOrThrow("@@");
}
private readonly List<Trap> _traps;
private NotImplementedSyscalls()
{
_traps = Enumerable.Range(0, 512)
.Select(i => new Trap(i))
.ToList();
}
private static readonly Regex ExportRegex = new Regex("__wsyscalltab\\[(\\d+)\\]");
public IntPtr GetProcAddrOrZero(string entryPoint)
{
var m = ExportRegex.Match(entryPoint);
if (m.Success)
{
return _traps[int.Parse(m.Groups[1].Value)].FunctionPointer;
}
return IntPtr.Zero;
}
public IntPtr GetProcAddrOrThrow(string entryPoint)
{
var m = ExportRegex.Match(entryPoint);
if (m.Success)
{
return _traps[int.Parse(m.Groups[1].Value)].FunctionPointer;
}
throw new InvalidOperationException($"{entryPoint} was not of the format __wsyscalltab[#]");
}
public static NotImplementedSyscalls Instance { get; } = new NotImplementedSyscalls();
}
}

80
src/BizHawk.Emulation.Cores/Waterbox/WaterboxCore.cs
View File

@ -64,18 +64,21 @@ namespace BizHawk.Emulation.Cores.Waterbox
_core.GetMemoryAreas(areas);
_memoryAreas = areas.Where(a => a.Data != IntPtr.Zero && a.Size != 0)
.ToArray();
_saveramAreas = _memoryAreas.Where(a => (a.Flags & LibWaterboxCore.MemoryDomainFlags.Saverammable) != 0)
var memoryDomains = _memoryAreas.Select(a => WaterboxMemoryDomain.Create(a, _exe)).ToList();
var primaryDomain = memoryDomains
.Where(md => md.Definition.Flags.HasFlag(LibWaterboxCore.MemoryDomainFlags.Primary))
.Single();
var mdl = new MemoryDomainList(memoryDomains.Cast<MemoryDomain>().ToList());
mdl.MainMemory = primaryDomain;
_serviceProvider.Register<IMemoryDomains>(mdl);
_saveramAreas = memoryDomains
.Where(md => md.Definition.Flags.HasFlag(LibWaterboxCore.MemoryDomainFlags.Saverammable))
.ToArray();
_saveramSize = (int)_saveramAreas.Sum(a => a.Size);
var memoryDomains = _memoryAreas.Select(a => new LibWaterboxCore.WaterboxMemoryDomain(a, _exe));
var primaryIndex = _memoryAreas
.Select((a, i) => new { a, i })
.Single(a => (a.a.Flags & LibWaterboxCore.MemoryDomainFlags.Primary) != 0).i;
var mdl = new MemoryDomainList(memoryDomains.Cast<MemoryDomain>().ToList());
mdl.MainMemory = mdl[primaryIndex];
_serviceProvider.Register<IMemoryDomains>(mdl);
var sr = _core as ICustomSaveram;
if (sr != null)
_serviceProvider.Register<ISaveRam>(new CustomSaverammer(sr)); // override the default implementation
@ -110,7 +113,7 @@ namespace BizHawk.Emulation.Cores.Waterbox
}
}
private LibWaterboxCore.MemoryArea[] _saveramAreas;
private WaterboxMemoryDomain[] _saveramAreas;
private int _saveramSize;
public unsafe bool SaveRamModified
@ -119,18 +122,29 @@ namespace BizHawk.Emulation.Cores.Waterbox
{
if (_saveramSize == 0)
return false;
var buff = new byte[4096];
using (_exe.EnterExit())
{
foreach (var area in _saveramAreas)
fixed(byte* bp = buff)
{
int* p = (int*)area.Data;
int* pend = p + area.Size / sizeof(int);
int cmp = (area.Flags & LibWaterboxCore.MemoryDomainFlags.OneFilled) != 0 ? -1 : 0;
while (p < pend)
foreach (var area in _saveramAreas)
{
if (*p++ != cmp)
return true;
var stream = new MemoryDomainStream(area);
int cmp = (area.Definition.Flags & LibWaterboxCore.MemoryDomainFlags.OneFilled) != 0 ? -1 : 0;
while (true)
{
int nread = stream.Read(buff, 0, 4096);
if (nread == 0)
break;
int* p = (int*)bp;
int* pend = p + nread / sizeof(int);
while (p < pend)
{
if (*p++ != cmp)
return true;
}
}
}
}
}
@ -145,11 +159,10 @@ namespace BizHawk.Emulation.Cores.Waterbox
using (_exe.EnterExit())
{
var ret = new byte[_saveramSize];
var offs = 0;
var dest = new MemoryStream(ret, true);
foreach (var area in _saveramAreas)
{
Marshal.Copy(area.Data, ret, offs, (int)area.Size);
offs += (int)area.Size;
new MemoryDomainStream(area).CopyTo(dest);
}
return ret;
}
@ -163,11 +176,10 @@ namespace BizHawk.Emulation.Cores.Waterbox
throw new InvalidOperationException("Saveram size mismatch");
using (_exe.EnterExit())
{
var offs = 0;
var source = new MemoryStream(data, false);
foreach (var area in _saveramAreas)
{
Marshal.Copy(data, offs, area.Data, (int)area.Size);
offs += (int)area.Size;
WaterboxUtils.CopySome(source, new MemoryDomainStream(area), area.Size);
}
}
}
@ -197,9 +209,19 @@ namespace BizHawk.Emulation.Cores.Waterbox
LagCount++;
AdvanceRtc();
BufferWidth = frame.Width;
BufferHeight = frame.Height;
_numSamples = frame.Samples;
if (render)
{
BufferWidth = frame.Width;
BufferHeight = frame.Height;
}
if (rendersound)
{
_numSamples = frame.Samples;
}
else
{
_numSamples = 0;
}
FrameAdvancePost();
}
@ -319,7 +341,7 @@ namespace BizHawk.Emulation.Cores.Waterbox
{
}
protected readonly short[] _soundBuffer;
protected short[] _soundBuffer;
protected int _numSamples;
public bool CanProvideAsync => false;
public SyncSoundMode SyncMode => SyncSoundMode.Sync;
@ -329,7 +351,7 @@ namespace BizHawk.Emulation.Cores.Waterbox
return _videoBuffer;
}
protected readonly int[] _videoBuffer;
protected int[] _videoBuffer;
public virtual int VirtualWidth => BufferWidth;
public virtual int VirtualHeight => BufferHeight;
public int BufferWidth { get; protected set; }

2
src/BizHawk.Emulation.Cores/Waterbox/WaterboxHost.cs
View File

@ -229,7 +229,7 @@ namespace BizHawk.Emulation.Cores.Waterbox
_disposeList.Add(_mmapheap);
}
Console.WriteLine("About to enter unmanaged code");
System.Diagnostics.Debug.WriteLine($"About to enter unmanaged code for {opt.Filename}");
if (!OSTailoredCode.IsUnixHost && !System.Diagnostics.Debugger.IsAttached && Win32Imports.IsDebuggerPresent())
{
// this means that GDB or another unconventional debugger is attached.

208
src/BizHawk.Emulation.Cores/Waterbox/WaterboxMemoryDomain.cs Normal file
View File

@ -0,0 +1,208 @@
using System;
using System.Runtime.InteropServices;
using BizHawk.BizInvoke;
using BizHawk.Common;
using BizHawk.Emulation.Common;
using static BizHawk.Emulation.Cores.Waterbox.LibWaterboxCore;
namespace BizHawk.Emulation.Cores.Waterbox
{
public abstract unsafe class WaterboxMemoryDomain : MemoryDomain
{
protected readonly IntPtr _data;
protected readonly IMonitor _monitor;
protected readonly long _addressMangler;
public MemoryArea Definition { get; }
public static WaterboxMemoryDomain Create(MemoryArea m, IMonitor monitor)
{
return m.Flags.HasFlag(MemoryDomainFlags.FunctionHook)
? (WaterboxMemoryDomain)new WaterboxMemoryDomainFunc(m, monitor)
: new WaterboxMemoryDomainPointer(m, monitor);
}
protected WaterboxMemoryDomain(MemoryArea m, IMonitor monitor)
{
Name = Mershul.PtrToStringUtf8(m.Name);
EndianType = (m.Flags & MemoryDomainFlags.YugeEndian) != 0 ? Endian.Big : Endian.Little;
_data = m.Data;
Size = m.Size;
Writable = (m.Flags & MemoryDomainFlags.Writable) != 0;
if ((m.Flags & MemoryDomainFlags.WordSize1) != 0)
WordSize = 1;
else if ((m.Flags & MemoryDomainFlags.WordSize2) != 0)
WordSize = 2;
else if ((m.Flags & MemoryDomainFlags.WordSize4) != 0)
WordSize = 4;
else if ((m.Flags & MemoryDomainFlags.WordSize8) != 0)
WordSize = 8;
else
throw new InvalidOperationException("Unknown word size for memory domain");
_monitor = monitor;
if ((m.Flags & MemoryDomainFlags.Swapped) != 0 && EndianType == Endian.Big)
{
_addressMangler = WordSize - 1;
}
else
{
_addressMangler = 0;
}
Definition = m;
}
}
public unsafe class WaterboxMemoryDomainPointer : WaterboxMemoryDomain
{
internal WaterboxMemoryDomainPointer(MemoryArea m, IMonitor monitor)
: base(m, monitor)
{
if (m.Flags.HasFlag(MemoryDomainFlags.FunctionHook))
throw new InvalidOperationException();
}
public override byte PeekByte(long addr)
{
if ((ulong)addr < (ulong)Size)
{
using (_monitor.EnterExit())
{
return ((byte*)_data)[addr ^ _addressMangler];
}
}
throw new ArgumentOutOfRangeException(nameof(addr));
}
public override void PokeByte(long addr, byte val)
{
if (Writable)
{
if ((ulong)addr < (ulong)Size)
{
using (_monitor.EnterExit())
{
((byte*)_data)[addr ^ _addressMangler] = val;
}
}
else
{
throw new ArgumentOutOfRangeException(nameof(addr));
}
}
}
public override void BulkPeekByte(Range<long> addresses, byte[] values)
{
if (_addressMangler != 0)
{
base.BulkPeekByte(addresses, values);
return;
}
var start = (ulong)addresses.Start;
var count = addresses.Count();
if (start < (ulong)Size && (start + count) <= (ulong)Size)
{
using (_monitor.EnterExit())
{
Marshal.Copy(Z.US((ulong)_data + start), values, 0, (int)count);
}
}
else
{
throw new ArgumentOutOfRangeException(nameof(addresses));
}
}
}
/// <summary>
/// For private use only! Don't touch
/// </summary>
public abstract class MemoryDomainAccessStub
{
[BizImport(CallingConvention.Cdecl)]
public abstract void Access(IntPtr buffer, long address, long count, bool write);
private class StubResolver : IImportResolver
{
private readonly IntPtr _p;
public StubResolver(IntPtr p)
{
_p = p;
}
public IntPtr GetProcAddrOrThrow(string entryPoint) => _p;
public IntPtr GetProcAddrOrZero(string entryPoint) => _p;
}
public static MemoryDomainAccessStub Create(IntPtr p, IMonitor monitor)
{
return BizInvoker.GetInvoker<MemoryDomainAccessStub>(new StubResolver(p), monitor, CallingConventionAdapters.Waterbox);
}
}
public unsafe class WaterboxMemoryDomainFunc : WaterboxMemoryDomain
{
private readonly MemoryDomainAccessStub _access;
internal WaterboxMemoryDomainFunc(MemoryArea m, IMonitor monitor)
: base(m, monitor)
{
if (!m.Flags.HasFlag(MemoryDomainFlags.FunctionHook))
throw new InvalidOperationException();
_access = MemoryDomainAccessStub.Create(m.Data, monitor);
}
public override byte PeekByte(long addr)
{
if ((ulong)addr < (ulong)Size)
{
byte ret = 0;
_access.Access((IntPtr)(byte*)&ret, addr, 1, false);
return ret;
}
throw new ArgumentOutOfRangeException(nameof(addr));
}
public override void PokeByte(long addr, byte val)
{
if (Writable)
{
if ((ulong)addr < (ulong)Size)
{
_access.Access((IntPtr)(byte*)&val, addr, 1, true);
}
else
{
throw new ArgumentOutOfRangeException(nameof(addr));
}
}
}
public override void BulkPeekByte(Range<long> addresses, byte[] values)
{
if (_addressMangler != 0)
{
base.BulkPeekByte(addresses, values);
return;
}
var start = (ulong)addresses.Start;
var count = addresses.Count();
if (start < (ulong)Size && (start + count) <= (ulong)Size)
{
fixed(byte* p = values)
_access.Access((IntPtr)p, (long)start, (long)count, false);
}
else
{
throw new ArgumentOutOfRangeException(nameof(addresses));
}
}
}
}

42
waterbox/common.mak
View File

@ -1,10 +1,13 @@
# common parts of all waterbox cores
WATERBOX_DIR := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))
ROOT_DIR := $(shell dirname $(realpath $(lastword $(filter-out $(lastword $(MAKEFILE_LIST)), $(MAKEFILE_LIST)))))
ROOT_DIR := $(shell dirname $(realpath $(lastword $(filter-out $(lastword $(MAKEFILE_LIST)),$(MAKEFILE_LIST)))))
OUTPUTDLL_DIR := $(realpath $(WATERBOX_DIR)/../output/dll)
OBJ_DIR := $(ROOT_DIR)/obj/release
DOBJ_DIR := $(ROOT_DIR)/obj/debug
ifeq ($(OUT_DIR),)
OUT_DIR := $(ROOT_DIR)/obj
endif
OBJ_DIR := $(OUT_DIR)/release
DOBJ_DIR := $(OUT_DIR)/debug
EMULIBC_OBJS := $(WATERBOX_DIR)/emulibc/obj/release/emulibc.c.o
EMULIBC_DOBJS := $(WATERBOX_DIR)/emulibc/obj/debug/emulibc.c.o
SYSROOT := $(WATERBOX_DIR)/sysroot
@ -19,25 +22,26 @@ print-%: ;
#LD_PLUGIN := $(shell gcc --print-file-name=liblto_plugin.so)
CC := $(SYSROOT)/bin/musl-gcc
CCFLAGS := $(CCFLAGS) -mabi=ms -fvisibility=hidden -I$(WATERBOX_DIR)/emulibc -Wall -mcmodel=large \
-mstack-protector-guard=global
LDFLAGS := $(LDFLAGS) -fuse-ld=gold -static -Wl,-Ttext,0x0000036f00000000 #-Wl,--plugin,$(LD_PLUGIN)
COMMONFLAGS := -mabi=ms -fvisibility=hidden -I$(WATERBOX_DIR)/emulibc -Wall -mcmodel=large \
-mstack-protector-guard=global -no-pie -fno-pic -fno-pie
CCFLAGS := $(CCFLAGS) $(COMMONFLAGS)
LDFLAGS := $(LDFLAGS) -static -Wl,--eh-frame-hdr -T $(WATERBOX_DIR)/linkscript.T #-Wl,--plugin,$(LD_PLUGIN)
CCFLAGS_DEBUG := -O0 -g
CCFLAGS_RELEASE := -O3 -flto
LDFLAGS_DEBUG :=
LDFLAGS_RELEASE :=
CXXFLAGS := $(CXXFLAGS) -I$(SYSROOT)/include/c++/v1 -fno-use-cxa-atexit
CXXFLAGS_DEBUG :=
CXXFLAGS_RELEASE :=
CXXFLAGS := $(CXXFLAGS) $(COMMONFLAGS) -I$(SYSROOT)/include/c++/v1 -fno-use-cxa-atexit
CXXFLAGS_DEBUG := -O0 -g
CXXFLAGS_RELEASE := -O3 -flto
EXTRA_LIBS := -L $(SYSROOT)/lib/linux -lclang_rt.builtins-x86_64
ifneq ($(filter %.cpp, $(SRCS)), )
EXTRA_LIBS := -L $(SYSROOT)/lib/linux -lclang_rt.builtins-x86_64 $(EXTRA_LIBS)
ifneq ($(filter %.cpp,$(SRCS)),)
EXTRA_LIBS := -lc++ -lc++abi -lunwind $(EXTRA_LIBS)
endif
_OBJS := $(addsuffix .o, $(realpath $(SRCS)))
OBJS := $(patsubst $(ROOT_DIR)%, $(OBJ_DIR)%, $(_OBJS))
DOBJS := $(patsubst $(ROOT_DIR)%, $(DOBJ_DIR)%, $(_OBJS))
_OBJS := $(addsuffix .o,$(realpath $(SRCS)))
OBJS := $(patsubst $(ROOT_DIR)%,$(OBJ_DIR)%,$(_OBJS))
DOBJS := $(patsubst $(ROOT_DIR)%,$(DOBJ_DIR)%,$(_OBJS))
$(OBJ_DIR)/%.c.o: %.c
@echo cc $<
@ -46,7 +50,7 @@ $(OBJ_DIR)/%.c.o: %.c
$(OBJ_DIR)/%.cpp.o: %.cpp
@echo cxx $<
@mkdir -p $(@D)
@$(CC) -c -o $@ $< $(CCFLAGS) $(CXXFLAGS) $(CCFLAGS_RELEASE)
@$(CC) -c -o $@ $< $(CXXFLAGS) $(CXXFLAGS_RELEASE)
$(DOBJ_DIR)/%.c.o: %.c
@echo cc $<
@mkdir -p $(@D)
@ -54,7 +58,7 @@ $(DOBJ_DIR)/%.c.o: %.c
$(DOBJ_DIR)/%.cpp.o: %.cpp
@echo cxx $<
@mkdir -p $(@D)
@$(CC) -c -o $@ $< $(CCFLAGS) $(CXXFLAGS) $(CCFLAGS_DEBUG) $(CXXFLAGS_DEBUG)
@$(CC) -c -o $@ $< $(CXXFLAGS) $(CXXFLAGS_DEBUG)
ifndef NO_WBX_TARGETS
@ -97,8 +101,8 @@ endif
.PHONY: clean clean-release clean-debug
clean:
rm -rf $(ROOT_DIR)/obj
rm -rf $(OUT_DIR)
clean-release:
rm -rf $(ROOT_DIR)/obj/release
rm -rf $(OUT_DIR)/release
clean-debug:
rm -rf $(ROOT_DIR)/obj/debug
rm -rf $(OUT_DIR)/debug

83
waterbox/emulibc/waterboxcore.h
View File

@ -1,40 +1,43 @@
#pragma once
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct
{
uint32_t* VideoBuffer;
int16_t* SoundBuffer;
int64_t Cycles;
int32_t Width;
int32_t Height;
int32_t Samples;
int32_t Lagged;
} FrameInfo;
typedef struct
{
void* Data;
const char* Name;
int64_t Size;
int64_t Flags;
} MemoryArea;
#define MEMORYAREA_FLAGS_WRITABLE 1
#define MEMORYAREA_FLAGS_SAVERAMMABLE 2
#define MEMORYAREA_FLAGS_ONEFILLED 4
#define MEMORYAREA_FLAGS_PRIMARY 8
#define MEMORYAREA_FLAGS_YUGEENDIAN 16
#define MEMORYAREA_FLAGS_WORDSIZE1 32
#define MEMORYAREA_FLAGS_WORDSIZE2 64
#define MEMORYAREA_FLAGS_WORDSIZE4 128
#define MEMORYAREA_FLAGS_WORDSIZE8 256
#define MEMORYAREA_FLAGS_SWAPPED 512
#ifdef __cplusplus
}
#endif
#pragma once
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct
{
uint32_t* VideoBuffer;
int16_t* SoundBuffer;
int64_t Cycles;
int32_t Width;
int32_t Height;
int32_t Samples;
int32_t Lagged;
} FrameInfo;
typedef struct
{
void* Data;
const char* Name;
int64_t Size;
int64_t Flags;
} MemoryArea;
typedef void (*MemoryFunctionHook)(uint8_t* buffer, int64_t address, int64_t count, bool write);
#define MEMORYAREA_FLAGS_WRITABLE 1
#define MEMORYAREA_FLAGS_SAVERAMMABLE 2
#define MEMORYAREA_FLAGS_ONEFILLED 4
#define MEMORYAREA_FLAGS_PRIMARY 8
#define MEMORYAREA_FLAGS_YUGEENDIAN 16
#define MEMORYAREA_FLAGS_WORDSIZE1 32
#define MEMORYAREA_FLAGS_WORDSIZE2 64
#define MEMORYAREA_FLAGS_WORDSIZE4 128
#define MEMORYAREA_FLAGS_WORDSIZE8 256
#define MEMORYAREA_FLAGS_SWAPPED 512
#define MEMORYAREA_FLAGS_FUNCTIONHOOK 1024
#ifdef __cplusplus
}
#endif

6
waterbox/libcxx/configure-for-waterbox-phase--
View File

@ -10,8 +10,8 @@ sed -i -e '13c\' -e '' "$SYSROOT/lib/musl-gcc.specs"
rm -rf build-
mkdir build-
cd build-
export CFLAGS="-mabi=ms -mcmodel=large -mstack-protector-guard=global"
export CXXFLAGS="-mabi=ms -mcmodel=large -mstack-protector-guard=global"
export CFLAGS="-mabi=ms -mcmodel=large -mstack-protector-guard=global -no-pie -fno-pic -fno-pie"
export CXXFLAGS="-mabi=ms -mcmodel=large -mstack-protector-guard=global -no-pie -fno-pic -fno-pie"
cmake \
-DCMAKE_C_COMPILER="$SYSROOT/bin/musl-gcc" \
-DCMAKE_CXX_COMPILER="$SYSROOT/bin/musl-gcc" \
@ -22,6 +22,8 @@ cmake \
-DCOMPILER_RT_BUILD_PROFILE=OFF \
-DCOMPILER_RT_CAN_EXECUTE_TESTS=OFF \
-DCOMPILER_RT_USE_BUILTINS_LIBRARY=ON \
-UCOMPILER_RT_BAREMETAL_BUILD \
-DCOMPILER_RT_BAREMETAL_BUILD=ON \
-DCMAKE_INSTALL_PREFIX="$SYSROOT" \
-DCMAKE_AR="/usr/bin/gcc-ar" \
-DCMAKE_RANLIB="/usr/bin/gcc-ranlib" \

4
waterbox/libcxx/configure-for-waterbox-phase-0
View File

@ -5,8 +5,8 @@ LLVMDIR="`realpath \"$MYPATH/../../../llvm-project\"`"
rm -rf build0
mkdir build0
cd build0
export CFLAGS="-mabi=ms -mcmodel=large -mstack-protector-guard=global -fno-use-cxa-atexit"
export CXXFLAGS="-mabi=ms -mcmodel=large -mstack-protector-guard=global -fno-use-cxa-atexit"
export CFLAGS="-mabi=ms -mcmodel=large -mstack-protector-guard=global -fno-use-cxa-atexit -no-pie -fno-pic -fno-pie -D_WIN64 -D_LIBUNWIND_IS_BAREMETAL -D_LIBUNWIND_SUPPORT_DWARF_UNWIND"
export CXXFLAGS="-mabi=ms -mcmodel=large -mstack-protector-guard=global -fno-use-cxa-atexit -no-pie -fno-pic -fno-pie -D_WIN64 -D_LIBUNWIND_IS_BAREMETAL -D_LIBUNWIND_SUPPORT_DWARF_UNWIND"
cmake \
-DCMAKE_C_COMPILER="$SYSROOT/bin/musl-gcc" \
-DCMAKE_CXX_COMPILER="$SYSROOT/bin/musl-gcc" \

4
waterbox/libcxx/configure-for-waterbox-phase-1
View File

@ -5,8 +5,8 @@ LLVMDIR="`realpath \"$MYPATH/../../../llvm-project\"`"
rm -rf build1
mkdir build1
cd build1
export CFLAGS="-mabi=ms -mcmodel=large -mstack-protector-guard=global -fno-use-cxa-atexit"
export CXXFLAGS="-mabi=ms -mcmodel=large -mstack-protector-guard=global -fno-use-cxa-atexit"
export CFLAGS="-mabi=ms -mcmodel=large -mstack-protector-guard=global -fno-use-cxa-atexit -no-pie -fno-pic -fno-pie"
export CXXFLAGS="-mabi=ms -mcmodel=large -mstack-protector-guard=global -fno-use-cxa-atexit -no-pie -fno-pic -fno-pie"
cmake \
-DCMAKE_C_COMPILER="$SYSROOT/bin/musl-gcc" \
-DCMAKE_CXX_COMPILER="$SYSROOT/bin/musl-gcc" \

4
waterbox/libcxx/configure-for-waterbox-phase-2
View File

@ -10,8 +10,8 @@ cp -n "/usr/include/linux/version.h" "$SYSROOT/include/linux"
rm -rf build2
mkdir build2
cd build2
export CFLAGS="-mabi=ms -mcmodel=large -mstack-protector-guard=global -fno-use-cxa-atexit"
export CXXFLAGS="-mabi=ms -mcmodel=large -mstack-protector-guard=global -fno-use-cxa-atexit"
export CFLAGS="-mabi=ms -mcmodel=large -mstack-protector-guard=global -fno-use-cxa-atexit -no-pie -fno-pic -fno-pie"
export CXXFLAGS="-mabi=ms -mcmodel=large -mstack-protector-guard=global -fno-use-cxa-atexit -no-pie -fno-pic -fno-pie"
cmake \
-DCMAKE_C_COMPILER="$SYSROOT/bin/musl-gcc" \
-DCMAKE_CXX_COMPILER="$SYSROOT/bin/musl-gcc" \

2
waterbox/libsnes/Makefile
View File

@ -1,7 +1,7 @@
NEED_LIBCO := 1
#-DPROFILE_PERFORMANCE
CCFLAGS := -DHOOKS -DBIZHAWK -DPROFILE_COMPATIBILITY -DGAMEBOY \
CXXFLAGS := -DHOOKS -DBIZHAWK -DPROFILE_COMPATIBILITY -DGAMEBOY \
-D_GNU_SOURCE \
-Werror=int-to-pointer-cast \
-I../libco -I./bsnes \

251
waterbox/linkscript.T Normal file
View File

@ -0,0 +1,251 @@
/* Script for -z combreloc -z separate-code */
/* Copyright (C) 2014-2020 Free Software Foundation, Inc.
Copying and distribution of this script, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. */
OUTPUT_FORMAT("elf64-x86-64", "elf64-x86-64",
"elf64-x86-64")
OUTPUT_ARCH(i386:x86-64)
ENTRY(_start)
SEARCH_DIR("=/usr/local/lib/x86_64-linux-gnu"); SEARCH_DIR("=/lib/x86_64-linux-gnu"); SEARCH_DIR("=/usr/lib/x86_64-linux-gnu"); SEARCH_DIR("=/usr/lib/x86_64-linux-gnu64"); SEARCH_DIR("=/usr/local/lib64"); SEARCH_DIR("=/lib64"); SEARCH_DIR("=/usr/lib64"); SEARCH_DIR("=/usr/local/lib"); SEARCH_DIR("=/lib"); SEARCH_DIR("=/usr/lib"); SEARCH_DIR("=/usr/x86_64-linux-gnu/lib64"); SEARCH_DIR("=/usr/x86_64-linux-gnu/lib");
SECTIONS
{
PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x36f00000000)); . = SEGMENT_START("text-segment", 0x36f00000000) + SIZEOF_HEADERS;
.interp : { *(.interp) }
.note.gnu.build-id : { *(.note.gnu.build-id) }
.hash : { *(.hash) }
.gnu.hash : { *(.gnu.hash) }
.dynsym : { *(.dynsym) }
.dynstr : { *(.dynstr) }
.gnu.version : { *(.gnu.version) }
.gnu.version_d : { *(.gnu.version_d) }
.gnu.version_r : { *(.gnu.version_r) }
.rela.dyn :
{
*(.rela.init)
*(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
*(.rela.fini)
*(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
*(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
*(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
*(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
*(.rela.ctors)
*(.rela.dtors)
*(.rela.got)
*(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
*(.rela.ldata .rela.ldata.* .rela.gnu.linkonce.l.*)
*(.rela.lbss .rela.lbss.* .rela.gnu.linkonce.lb.*)
*(.rela.lrodata .rela.lrodata.* .rela.gnu.linkonce.lr.*)
*(.rela.ifunc)
}
.rela.plt :
{
*(.rela.plt)
PROVIDE_HIDDEN (__rela_iplt_start = .);
*(.rela.iplt)
PROVIDE_HIDDEN (__rela_iplt_end = .);
}
. = ALIGN(CONSTANT (MAXPAGESIZE));
.init :
{
KEEP (*(SORT_NONE(.init)))
}
.plt : { *(.plt) *(.iplt) }
.plt.got : { *(.plt.got) }
.plt.sec : { *(.plt.sec) }
.text :
{
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
*(.text.exit .text.exit.*)
*(.text.startup .text.startup.*)
*(.text.hot .text.hot.*)
*(SORT(.text.sorted.*))
*(.text .stub .text.* .gnu.linkonce.t.*)
/* .gnu.warning sections are handled specially by elf.em. */
*(.gnu.warning)
}
.fini :
{
KEEP (*(SORT_NONE(.fini)))
}
PROVIDE (__etext = .);
PROVIDE (_etext = .);
PROVIDE (etext = .);
. = ALIGN(CONSTANT (MAXPAGESIZE));
/* Adjust the address for the rodata segment. We want to adjust up to
the same address within the page on the next page up. */
. = SEGMENT_START("rodata-segment", ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)));
.rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
.rodata1 : { *(.rodata1) }
__eh_frame_hdr_start = .;
.eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) }
__eh_frame_hdr_end = .;
__eh_frame_start = .;
.eh_frame : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) }
__eh_frame_end = .;
.gcc_except_table : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
.gnu_extab : ONLY_IF_RO { *(.gnu_extab*) }
/* These sections are generated by the Sun/Oracle C++ compiler. */
.exception_ranges : ONLY_IF_RO { *(.exception_ranges*) }
/* Adjust the address for the data segment. We want to adjust up to
the same address within the page on the next page up. */
. = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
/* Exception handling */
.eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
.gnu_extab : ONLY_IF_RW { *(.gnu_extab) }
.gcc_except_table : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
.exception_ranges : ONLY_IF_RW { *(.exception_ranges*) }
/* Thread Local Storage sections */
.tdata :
{
PROVIDE_HIDDEN (__tdata_start = .);
*(.tdata .tdata.* .gnu.linkonce.td.*)
}
.tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
.preinit_array :
{
PROVIDE_HIDDEN (__preinit_array_start = .);
KEEP (*(.preinit_array))
PROVIDE_HIDDEN (__preinit_array_end = .);
}
.init_array :
{
PROVIDE_HIDDEN (__init_array_start = .);
KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
PROVIDE_HIDDEN (__init_array_end = .);
}
.fini_array :
{
PROVIDE_HIDDEN (__fini_array_start = .);
KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
PROVIDE_HIDDEN (__fini_array_end = .);
}
.ctors :
{
/* gcc uses crtbegin.o to find the start of
the constructors, so we make sure it is
first. Because this is a wildcard, it
doesn't matter if the user does not
actually link against crtbegin.o; the
linker won't look for a file to match a
wildcard. The wildcard also means that it
doesn't matter which directory crtbegin.o
is in. */
KEEP (*crtbegin.o(.ctors))
KEEP (*crtbegin?.o(.ctors))
/* We don't want to include the .ctor section from
the crtend.o file until after the sorted ctors.
The .ctor section from the crtend file contains the
end of ctors marker and it must be last */
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
KEEP (*(SORT(.ctors.*)))
KEEP (*(.ctors))
}
.dtors :
{
KEEP (*crtbegin.o(.dtors))
KEEP (*crtbegin?.o(.dtors))
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
KEEP (*(SORT(.dtors.*)))
KEEP (*(.dtors))
}
.jcr : { KEEP (*(.jcr)) }
.data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
.dynamic : { *(.dynamic) }
.got : { *(.got) *(.igot) }
. = DATA_SEGMENT_RELRO_END (SIZEOF (.got.plt) >= 24 ? 24 : 0, .);
.got.plt : { *(.got.plt) *(.igot.plt) }
/* waterbox sections that are eventually RO at runtime */
. = ALIGN(CONSTANT (MAXPAGESIZE));
.wbxsyscall : { *(.wbxsyscall) }
.sealed : { *(.sealed) }
. = ALIGN(CONSTANT (MAXPAGESIZE));
/* Put the invisible section by itself */
.invis : { *(.invis) }
. = ALIGN(CONSTANT (MAXPAGESIZE));
.data :
{
*(.data .data.* .gnu.linkonce.d.*)
SORT(CONSTRUCTORS)
}
.data1 : { *(.data1) }
_edata = .; PROVIDE (edata = .);
. = .;
__bss_start = .;
.bss :
{
*(.dynbss)
*(.bss .bss.* .gnu.linkonce.b.*)
*(COMMON)
/* Align here to ensure that the .bss section occupies space up to
_end. Align after .bss to ensure correct alignment even if the
.bss section disappears because there are no input sections.
FIXME: Why do we need it? When there is no .bss section, we do not
pad the .data section. */
. = ALIGN(. != 0 ? 64 / 8 : 1);
}
.lbss :
{
*(.dynlbss)
*(.lbss .lbss.* .gnu.linkonce.lb.*)
*(LARGE_COMMON)
}
. = ALIGN(64 / 8);
. = SEGMENT_START("ldata-segment", .);
.lrodata ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) :
{
*(.lrodata .lrodata.* .gnu.linkonce.lr.*)
}
.ldata ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) :
{
*(.ldata .ldata.* .gnu.linkonce.l.*)
. = ALIGN(. != 0 ? 64 / 8 : 1);
}
. = ALIGN(64 / 8);
_end = .; PROVIDE (end = .);
. = DATA_SEGMENT_END (.);
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
.gnu.build.attributes : { *(.gnu.build.attributes .gnu.build.attributes.*) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
/* SGI/MIPS DWARF 2 extensions */
.debug_weaknames 0 : { *(.debug_weaknames) }
.debug_funcnames 0 : { *(.debug_funcnames) }
.debug_typenames 0 : { *(.debug_typenames) }
.debug_varnames 0 : { *(.debug_varnames) }
/* DWARF 3 */
.debug_pubtypes 0 : { *(.debug_pubtypes) }
.debug_ranges 0 : { *(.debug_ranges) }
/* DWARF Extension. */
.debug_macro 0 : { *(.debug_macro) }
.debug_addr 0 : { *(.debug_addr) }
.gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }
/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }
}

2
waterbox/musl

@ -1 +1 @@
Subproject commit 8e064437203731ae3d9f17b953a31e885a71f879
Subproject commit e164b6965f33eb07b1002d79f8926fffbff3b639

2
waterbox/ngp/Makefile
View File

@ -1,4 +1,4 @@
CCFLAGS:= -I. \
CXXFLAGS:= -I. \
-Wall -Werror=int-to-pointer-cast \
-std=c++0x -fomit-frame-pointer -fno-exceptions -fno-rtti \
-DLSB_FIRST

20
waterbox/nyma/.vscode/c_cpp_properties.json vendored Normal file
View File

@ -0,0 +1,20 @@
{
"configurations": [
{
"name": "Waterbox",
"includePath": [
"${workspaceFolder}",
"${workspaceFolder}/mednafen/include",
"${workspaceFolder}/common",
"${workspaceFolder}/mednafen/src/trio",
"${workspaceFolder}/../sysroot/include",
"${workspaceFolder}/../sysroot/include/c++/v1",
"${workspaceFolder}/../emulibc"
],
"defines": [
],
"intelliSenseMode": "gcc-x64"
}
],
"version": 4
}

53
waterbox/nyma/.vscode/settings.json vendored Normal file
View File

@ -0,0 +1,53 @@
{
"files.associations": {
"*.mak": "makefile",
"typeinfo": "cpp",
"*.inc": "cpp",
"new": "cpp",
"__bit_reference": "cpp",
"__config": "cpp",
"__debug": "cpp",
"__functional_base": "cpp",
"__hash_table": "cpp",
"__node_handle": "cpp",
"__nullptr": "cpp",
"__split_buffer": "cpp",
"__string": "cpp",
"__tree": "cpp",
"__tuple": "cpp",
"algorithm": "cpp",
"array": "cpp",
"atomic": "cpp",
"bit": "cpp",
"bitset": "cpp",
"cctype": "cpp",
"cmath": "cpp",
"cstddef": "cpp",
"cstdint": "cpp",
"cstdio": "cpp",
"cstdlib": "cpp",
"cstring": "cpp",
"cwchar": "cpp",
"cwctype": "cpp",
"deque": "cpp",
"exception": "cpp",
"functional": "cpp",
"initializer_list": "cpp",
"iosfwd": "cpp",
"iterator": "cpp",
"limits": "cpp",
"list": "cpp",
"map": "cpp",
"memory": "cpp",
"optional": "cpp",
"queue": "cpp",
"stdexcept": "cpp",
"string": "cpp",
"string_view": "cpp",
"tuple": "cpp",
"type_traits": "cpp",
"unordered_map": "cpp",
"utility": "cpp",
"vector": "cpp"
}
}

177
waterbox/nyma/Interfaces.cpp Normal file
View File

@ -0,0 +1,177 @@
#include "mednafen/src/mednafen.h"
#include "mednafen/src/general.h"
#include "mednafen/src/state.h"
#include "mednafen/src/settings.h"
#include "mednafen/src/mempatcher.h"
#include "mednafen/src/mednafen-driver.h"
#include "mednafen/src/player.h"
#include <stdio.h>
#include <stdarg.h>
#include <emulibc.h>
enum { SETTING_VALUE_MAX_LENGTH = 256 };
static void (*FrontendSettingQuery)(const char* setting, char* dest);
ECL_EXPORT void SetFrontendSettingQuery(void (*q)(const char* setting, char* dest))
{
FrontendSettingQuery = q;
}
namespace Mednafen
{
MDFNGI *MDFNGameInfo = NULL;
NativeVFS NVFS;
std::string MDFN_MakeFName(MakeFName_Type type, int id1, const char *cd1)
{
std::string ret;
switch (type)
{
case MDFNMKF_STATE: ret += "STATE:"; break;
case MDFNMKF_SNAP: ret += "SNAP:"; break;
case MDFNMKF_SAV: ret += "SAV:"; break;
case MDFNMKF_SAVBACK: ret += "SAVBACK:"; break;
case MDFNMKF_CHEAT: ret += "CHEAT:"; break;
case MDFNMKF_PALETTE: ret += "PALETTE:"; break;
case MDFNMKF_IPS: ret += "IPS:"; break;
case MDFNMKF_MOVIE: ret += "MOVIE:"; break;
case MDFNMKF_SNAP_DAT: ret += "SNAP_DAT:"; break;
case MDFNMKF_CHEAT_TMP: ret += "CHEAT_TMP:"; break;
case MDFNMKF_FIRMWARE: ret += "FIRMWARE:"; break;
case MDFNMKF_PGCONFIG: ret += "PGCONFIG:"; break;
default: ret += "UNKNOWN:"; break;
}
ret += cd1;
return ret;
}
// mednafen-driver.h
static int curindent = 0;
void MDFN_indent(int indent)
{
curindent += indent;
if(curindent < 0)
{
fprintf(stderr, "MDFN_indent negative!\n");
curindent = 0;
}
}
void MDFN_printf(const char *format, ...) noexcept
{
for (int i = 0; i < curindent; i++)
putchar('\t');
va_list argp;
va_start(argp, format);
vprintf(format, argp);
va_end(argp);
}
void MDFND_OutputNotice(MDFN_NoticeType t, const char* s) noexcept
{
fputs(s, t == MDFN_NOTICE_ERROR ? stderr : stdout);
fputc('\n', t == MDFN_NOTICE_ERROR ? stderr : stdout);
}
void MDFND_OutputInfo(const char* s) noexcept
{
puts(s);
}
void MDFN_Notify(MDFN_NoticeType t, const char* format, ...) noexcept
{
va_list argp;
va_start(argp, format);
vfprintf(t == MDFN_NOTICE_ERROR ? stderr : stdout, format, argp);
}
void MDFN_MidSync(EmulateSpecStruct *espec, const unsigned flags)
{}
bool MDFNSS_StateAction(StateMem *sm, const unsigned load, const bool data_only, const SFORMAT *sf, const char *sname, const bool optional) noexcept
{
abort();
}
static const MDFNSetting* GetSetting(const char* name)
{
const MDFNSetting* s;
for (int i = 0; s = &MDFNGameInfo->Settings[i], s->name; i++)
{
if (strcmp(s->name, name) == 0)
return s;
}
return nullptr;
}
uint64 MDFN_GetSettingUI(const char *name)
{
auto s = GetSetting(name);
char tmp[SETTING_VALUE_MAX_LENGTH];
FrontendSettingQuery(name, tmp);
if (s && s->type == MDFNST_ENUM)
{
for (int i = 0; s->enum_list[i].string; i++)
{
if (strcmp(s->enum_list[i].string, tmp) == 0)
return s->enum_list[i].number;
}
for (int i = 0; s->enum_list[i].string; i++)
{
if (strcmp(s->enum_list[i].string, s->default_value) == 0)
return s->enum_list[i].number;
}
return 0;
}
else
{
return strtoul(tmp, nullptr, 10);
}
}
int64 MDFN_GetSettingI(const char *name)
{
char tmp[SETTING_VALUE_MAX_LENGTH];
FrontendSettingQuery(name, tmp);
return strtol(tmp, nullptr, 10);
}
double MDFN_GetSettingF(const char *name)
{
char tmp[SETTING_VALUE_MAX_LENGTH];
FrontendSettingQuery(name, tmp);
return strtod(tmp, nullptr);
}
bool MDFN_GetSettingB(const char *name)
{
char tmp[SETTING_VALUE_MAX_LENGTH];
FrontendSettingQuery(name, tmp);
return strtol(tmp, nullptr, 10) != 0;
}
std::string MDFN_GetSettingS(const char *name)
{
char tmp[SETTING_VALUE_MAX_LENGTH];
FrontendSettingQuery(name, tmp);
return std::string(tmp);
}
void MDFNMP_Init(uint32 ps, uint32 numpages)
{}
void MDFNMP_AddRAM(uint32 size, uint32 address, uint8 *RAM, bool use_in_search) // Deprecated
{}
void MDFNMP_RegSearchable(uint32 addr, uint32 size)
{}
void MDFNMP_Kill(void)
{}
void MDFN_LoadGameCheats(Stream* override)
{}
void MDFNMP_InstallReadPatches(void)
{}
void MDFNMP_RemoveReadPatches(void)
{}
void MDFNMP_ApplyPeriodicCheats(void)
{}
std::vector<SUBCHEAT> SubCheats[8];
bool SubCheatsOn;
// player.h
void Player_Init(int tsongs, const std::string &album, const std::string &artist, const std::string &copyright, const std::vector<std::string> &snames, bool override_gi)
{}
void Player_Draw(MDFN_Surface *surface, MDFN_Rect *dr, int CurrentSong, int16 *samples, int32 sampcount)
{}
}

398
waterbox/nyma/NymaCore.cpp Normal file
View File

@ -0,0 +1,398 @@
#include "mednafen/src/types.h"
#include <emulibc.h>
#include <waterboxcore.h>
#include <mednafen/mednafen.h>
#include <stdint.h>
#include "mednafen/src/FileStream.h"
#include "nyma.h"
using namespace Mednafen;
#define Game MDFNGameInfo
static EmulateSpecStruct* EES;
static MDFN_Surface* Surf;
static uint32_t* pixels;
static int16_t* samples;
struct InitData
{
const char* FileNameBase;
const char* FileNameExt;
const char* FileNameFull;
};
enum { MAX_PORTS = 16 };
enum { MAX_PORT_DATA = 16 };
static uint8_t InputPortData[(MAX_PORTS + 1) * MAX_PORT_DATA];
ECL_EXPORT void PreInit()
{
SetupMDFNGameInfo();
}
static void Setup()
{
pixels = new uint32_t[Game->fb_width * Game->fb_height];
samples = new int16_t[22050 * 2];
Surf = new MDFN_Surface(
pixels, Game->fb_width, Game->fb_height, Game->fb_width,
MDFN_PixelFormat(MDFN_COLORSPACE_RGB, 16, 8, 0, 24)
);
EES = new EmulateSpecStruct();
EES->surface = Surf;
EES->VideoFormatChanged = true;
EES->LineWidths = new int32_t[Game->fb_height];
memset(EES->LineWidths, 0xff, Game->fb_height * sizeof(int32_t));
EES->SoundBuf = samples;
EES->SoundBufMaxSize = 22050;
EES->SoundFormatChanged = true;
EES->SoundRate = 44100;
}
ECL_EXPORT bool InitRom(const InitData& data)
{
try
{
Setup();
std::unique_ptr<Stream> gamestream(new FileStream(data.FileNameFull, FileStream::MODE_READ, false));
GameFile gf({
&NVFS,
"",
gamestream.get(),
data.FileNameExt,
data.FileNameBase,
&NVFS,
"",
data.FileNameBase
});
Game->Load(&gf);
}
catch(...)
{
return false;
}
return true;
}
void StartGameWithCds(int numdisks);
ECL_EXPORT bool InitCd(int numdisks)
{
try
{
Setup();
StartGameWithCds(numdisks);
}
catch(...)
{
return false;
}
return true;
}
struct MyFrameInfo: public FrameInfo
{
// true to skip video rendering
int16_t SkipRendering;
int16_t SkipSoundening;
// a single MDFN_MSC_* command to run at the start of this frame; 0 if none
int32_t Command;
// raw data for each input port, assumed to be MAX_PORTS * MAX_PORT_DATA long
uint8_t* InputPortData;
};
ECL_EXPORT void FrameAdvance(MyFrameInfo& frame)
{
EES->skip = frame.SkipRendering;
if (frame.Command)
Game->DoSimpleCommand(frame.Command);
memcpy(InputPortData, frame.InputPortData, sizeof(InputPortData));
Game->TransformInput();
Game->Emulate(EES);
EES->VideoFormatChanged = false;
EES->SoundFormatChanged = false;
frame.Cycles = EES->MasterCycles;
if (!frame.SkipSoundening)
{
memcpy(frame.SoundBuffer, EES->SoundBuf, EES->SoundBufSize * 4);
frame.Samples = EES->SoundBufSize;
}
if (!frame.SkipRendering)
{
int h = EES->DisplayRect.h;
int lineStart = EES->DisplayRect.y;
int lineEnd = lineStart + h;
auto multiWidth = EES->LineWidths[0] != -1;
int w;
if (multiWidth)
{
w = 0;
for (int line = lineStart; line < lineEnd; line++)
w = std::max(w, EES->LineWidths[line]);
}
else
{
w = EES->DisplayRect.w;
}
frame.Width = w;
frame.Height = h;
int srcp = Game->fb_width;
int dstp = w;
uint32_t* src = pixels + EES->DisplayRect.x + EES->DisplayRect.y * srcp;
uint32_t* dst = frame.VideoBuffer;
for (int line = lineStart; line < lineEnd; line++)
{
memcpy(dst, src, (multiWidth ? EES->LineWidths[line] : w) * sizeof(uint32_t));
src += srcp;
dst += dstp;
}
}
}
struct SystemInfo
{
int32_t MaxWidth;
int32_t MaxHeight;
int32_t NominalWidth;
int32_t NominalHeight;
int32_t VideoSystem;
int32_t FpsFixed;
};
SystemInfo SI;
ECL_EXPORT SystemInfo* GetSystemInfo()
{
SI.MaxWidth = Game->fb_width;
SI.MaxHeight = Game->fb_height;
SI.NominalWidth = Game->nominal_width;
SI.NominalHeight = Game->nominal_height;
SI.VideoSystem = Game->VideoSystem;
SI.FpsFixed = Game->fps;
return &SI;
}
ECL_EXPORT const char* GetLayerData()
{
return Game->LayerNames;
}
ECL_EXPORT void SetLayers(uint64_t layers)
{
Game->SetLayerEnableMask(layers);
}
ECL_EXPORT void SetInputCallback(void (*cb)())
{}
// same information as PortInfo, but easier to marshal
struct NPortInfo
{
const char* ShortName;
const char* FullName;
const char* DefaultDeviceShortName;
uint32_t NumDevices;
};
struct NDeviceInfo
{
const char* ShortName;
const char* FullName;
const char* Description;
uint32_t Flags;
uint32_t ByteLength;
uint32_t NumInputs;
};
struct NInputInfo
{
const char* SettingName;
const char* Name;
int16_t ConfigOrder;
uint16_t BitOffset;
InputDeviceInputType Type; // uint8_t
uint8_t Flags;
uint8_t BitSize;
};
struct NButtonInfo
{
const char* ExcludeName;
};
struct NAxisInfo
{
// negative, then positive
const char* SettingName[2];
const char* Name[2];
};
struct NSwitchInfo
{
uint32_t NumPositions;
uint32_t DefaultPosition;
struct Position
{
const char* SettingName;
const char* Name;
const char* Description;
};
};
struct NStatusInfo
{
uint32_t NumStates;
struct State
{
const char* ShortName;
const char* Name;
int32_t Color; // (msb)0RGB(lsb), -1 for unused.
int32_t _Padding;
};
};
ECL_EXPORT uint32_t GetNumPorts()
{
return Game->PortInfo.size();
}
ECL_EXPORT NPortInfo& GetPort(uint32_t port)
{
auto& a = *(NPortInfo*)InputPortData;
auto& x = Game->PortInfo[port];
a.ShortName = x.ShortName;
a.FullName = x.FullName;
a.DefaultDeviceShortName = x.DefaultDevice;
a.NumDevices = x.DeviceInfo.size();
return a;
}
ECL_EXPORT NDeviceInfo& GetDevice(uint32_t port, uint32_t dev)
{
auto& b = *(NDeviceInfo*)InputPortData;
auto& y = Game->PortInfo[port].DeviceInfo[dev];
b.ShortName = y.ShortName;
b.FullName = y.FullName;
b.Description = y.Description;
b.Flags = y.Flags;
b.ByteLength = y.IDII.InputByteSize;
b.NumInputs = y.IDII.size();
return b;
}
ECL_EXPORT NInputInfo& GetInput(uint32_t port, uint32_t dev, uint32_t input)
{
auto& c = *(NInputInfo*)InputPortData;
auto& z = Game->PortInfo[port].DeviceInfo[dev].IDII[input];
c.SettingName = z.SettingName;
c.Name = z.Name;
c.ConfigOrder = z.ConfigOrder;
c.BitOffset = z.BitOffset;
c.Type = z.Type;
c.Flags = z.Flags;
c.BitSize = z.BitSize;
return c;
}
ECL_EXPORT NButtonInfo& GetButton(uint32_t port, uint32_t dev, uint32_t input)
{
auto& c = *(NButtonInfo*)InputPortData;
auto& z = Game->PortInfo[port].DeviceInfo[dev].IDII[input].Button;
c.ExcludeName = z.ExcludeName;
return c;
}
ECL_EXPORT NSwitchInfo& GetSwitch(uint32_t port, uint32_t dev, uint32_t input)
{
auto& c = *(NSwitchInfo*)InputPortData;
auto& z = Game->PortInfo[port].DeviceInfo[dev].IDII[input].Switch;
c.NumPositions = z.NumPos;
c.DefaultPosition = z.DefPos;
return c;
}
ECL_EXPORT NSwitchInfo::Position& GetSwitchPosition(uint32_t port, uint32_t dev, uint32_t input, int i)
{
auto& c = *(NSwitchInfo::Position*)InputPortData;
auto& z = Game->PortInfo[port].DeviceInfo[dev].IDII[input].Switch;
c.SettingName = z.Pos[i].SettingName;
c.Name = z.Pos[i].Name;
c.Description = z.Pos[i].Description;
return c;
}
ECL_EXPORT NStatusInfo& GetStatus(uint32_t port, uint32_t dev, uint32_t input)
{
auto& c = *(NStatusInfo*)InputPortData;
auto& z = Game->PortInfo[port].DeviceInfo[dev].IDII[input].Status;
c.NumStates = z.NumStates;
return c;
}
ECL_EXPORT NStatusInfo::State& GetStatusState(uint32_t port, uint32_t dev, uint32_t input, int i)
{
auto& c = *(NStatusInfo::State*)InputPortData;
auto& z = Game->PortInfo[port].DeviceInfo[dev].IDII[input].Status;
c.ShortName = z.States[i].ShortName;
c.Name = z.States[i].Name;
c.Color = z.States[i].Color;
return c;
}
ECL_EXPORT NAxisInfo& GetAxis(uint32_t port, uint32_t dev, uint32_t input)
{
auto& c = *(NAxisInfo*)InputPortData;
auto& z = Game->PortInfo[port].DeviceInfo[dev].IDII[input].Axis;
c.SettingName[0] = z.sname_dir[0];
c.SettingName[1] = z.sname_dir[1];
c.Name[0] = z.name_dir[0];
c.Name[1] = z.name_dir[1];
return c;
}
ECL_EXPORT void SetInputDevices(const char** devices)
{
for (unsigned port = 0; port < MAX_PORTS && devices[port]; port++)
{
std::string dev(devices[port]);
Game->SetInput(port, dev.c_str(), &InputPortData[port * MAX_PORT_DATA]);
}
}
struct NSetting
{
const char* Name;
const char* Description;
const char* SettingsKey;
const char* DefaultValue;
const char* Min;
const char* Max;
uint32_t Flags;
uint32_t Type;
};
struct NEnumValue
{
const char* Name;
const char* Description;
const char* Value;
};
ECL_EXPORT void IterateSettings(int index, NSetting& s)
{
auto& a = Game->Settings[index];
if (a.name)
{
s.Name = a.description;
s.Description = a.description_extra;
s.SettingsKey = a.name;
s.DefaultValue = a.default_value;
s.Min = a.minimum;
s.Max = a.maximum;
s.Flags = a.flags;
s.Type = a.type;
}
}
ECL_EXPORT void IterateSettingEnums(int index, int enumIndex, NEnumValue& e)
{
auto& a = Game->Settings[index].enum_list[enumIndex];
if (a.string)
{
e.Name = a.description;
e.Description = a.description_extra;
e.Value = a.string;
}
}

5
waterbox/nyma/build-and-install-zlib.sh Normal file
View File

@ -0,0 +1,5 @@
#!/bin/sh
cd zlib
./configure-for-waterbox
make
./install-for-waterbox

140
waterbox/nyma/cdrom.cpp Normal file
View File

@ -0,0 +1,140 @@
#include "mednafen/src/types.h"
#include <emulibc.h>
#include <waterboxcore.h>
#include <mednafen/mednafen.h>
#include <stdint.h>
#include <mednafen/cdrom/CDInterface.h>
#include <mednafen/cdrom/CDInterface_MT.h>
#include <mednafen/cdrom/CDInterface_ST.h>
#include <mednafen/cdrom/CDAccess.h>
#include <trio/trio.h>
#include "cdrom.h"
using namespace Mednafen;
struct NymaTOC
{
int32_t FirstTrack;
int32_t LastTrack;
int32_t DiskType;
struct
{
int32_t Adr;
int32_t Control;
int32_t Lba;
int32_t Valid;
} Tracks[101];
};
static void (*ReadTOCCallback)(int disk, NymaTOC *dest);
static void (*ReadSector2448Callback)(int disk, int lba, uint8 *dest);
ECL_EXPORT void SetCDCallbacks(void (*toccallback)(int disk, NymaTOC *dest), void (*sectorcallback)(int disk, int lba, uint8 *dest))
{
ReadTOCCallback = toccallback;
ReadSector2448Callback = sectorcallback;
}
CDInterfaceNyma::CDInterfaceNyma(int d) : disk(d)
{
NymaTOC t;
ReadTOCCallback(disk, &t);
disc_toc.first_track = t.FirstTrack;
disc_toc.last_track = t.LastTrack;
disc_toc.disc_type = t.DiskType;
for (int i = 0; i < 101; i++)
{
disc_toc.tracks[i].adr = t.Tracks[i].Adr;
disc_toc.tracks[i].control = t.Tracks[i].Control;
disc_toc.tracks[i].lba = t.Tracks[i].Lba;
disc_toc.tracks[i].valid = t.Tracks[i].Valid;
}
}
void CDInterfaceNyma::HintReadSector(int32 lba) {}
bool CDInterfaceNyma::ReadRawSector(uint8 *buf, int32 lba)
{
ReadSector2448Callback(disk, lba, buf);
return true;
}
bool CDInterfaceNyma::ReadRawSectorPWOnly(uint8 *pwbuf, int32 lba, bool hint_fullread)
{
uint8 buff[2448];
ReadSector2448Callback(disk, lba, buff);
memcpy(pwbuf, buff + 2352, 96);
return true;
}
std::vector<CDInterface*>* CDInterfaces;
void StartGameWithCds(int numdisks)
{
CDInterfaces = new std::vector<CDInterface*>();
for (int d = 0; d < numdisks; d++)
{
CDInterfaces->push_back(new CDInterfaceNyma(d));
}
MDFNGameInfo->LoadCD(CDInterfaces);
// TODO: Figure out wtf all this RMD stuff is
auto rmd = new RMD_Layout();
{
RMD_Drive dr;
dr.Name = "Virtual CD Drive";
dr.PossibleStates.push_back(RMD_State({"Tray Open", false, false, true}));
dr.PossibleStates.push_back(RMD_State({"Tray Closed (Empty)", false, false, false}));
dr.PossibleStates.push_back(RMD_State({"Tray Closed", true, true, false}));
dr.CompatibleMedia.push_back(0);
dr.MediaMtoPDelay = 2000;
rmd->Drives.push_back(dr);
rmd->DrivesDefaults.push_back(RMD_DriveDefaults({0, 0, 0}));
rmd->MediaTypes.push_back(RMD_MediaType({"CD"}));
}
const int default_cd = 0;
for(size_t i = 0; i < CDInterfaces->size(); i++)
{
if (i == default_cd)
{
rmd->DrivesDefaults[0].State = 2; // Tray Closed
rmd->DrivesDefaults[0].Media = i;
rmd->DrivesDefaults[0].Orientation = 0;
}
char namebuf[128];
trio_snprintf(namebuf, sizeof(namebuf), _("Disc %zu of %zu"), i + 1, CDInterfaces->size());
rmd->Media.push_back(RMD_Media({namebuf, 0}));
}
MDFNGameInfo->RMD = rmd;
// TODO: Wire up a way for the user to change disks
Mednafen::MDFNGameInfo->SetMedia(
0, // drive: 0 unless there's more than one drive
2, // state: 0 = open, 1 = closed (media absent), 2 = closed (media present)
0, // media: index into the disk list
0 // orientation: flip sides on NES FDS. not used elsewhere?
);
}
// CDInterface::Load pulls in a bunch of things that we do not want, stub them out here
namespace Mednafen
{
using namespace CDUtility;
CDInterface_MT::CDInterface_Message::~CDInterface_Message(){}
CDInterface_MT::CDInterface_Queue::CDInterface_Queue(){}
CDInterface_MT::CDInterface_Queue::~CDInterface_Queue(){}
CDInterface_MT::CDInterface_MT(std::unique_ptr<CDAccess> cda, const uint64 affinity){}
CDInterface_MT::~CDInterface_MT(){}
bool CDInterface_MT::ReadRawSector(uint8 *buf, int32 lba){return false;}
bool CDInterface_MT::ReadRawSectorPWOnly(uint8* pwbuf, int32 lba, bool hint_fullread){return false;}
void CDInterface_MT::HintReadSector(int32 lba){}
CDInterface_ST::CDInterface_ST(std::unique_ptr<CDAccess> cda) : disc_cdaccess(std::move(cda)){}
CDInterface_ST::~CDInterface_ST(){}
void CDInterface_ST::HintReadSector(int32 lba){}
bool CDInterface_ST::ReadRawSector(uint8 *buf, int32 lba){return false;}
bool CDInterface_ST::ReadRawSectorPWOnly(uint8* pwbuf, int32 lba, bool hint_fullread){return false;}
CDAccess* CDAccess_Open(VirtualFS* vfs, const std::string& path, bool image_memcache){return nullptr;}
}

17
waterbox/nyma/cdrom.h Normal file
View File

@ -0,0 +1,17 @@
#pragma once
#include "mednafen/src/types.h"
#include <mednafen/mednafen.h>
#include <mednafen/cdrom/CDInterface.h>
class CDInterfaceNyma : public Mednafen::CDInterface
{
private:
int disk;
public:
CDInterfaceNyma(int disk);
virtual void HintReadSector(int32 lba) override;
virtual bool ReadRawSector(uint8 *buf, int32 lba) override;
virtual bool ReadRawSectorPWOnly(uint8 *pwbuf, int32 lba, bool hint_fullread) override;
};

52
waterbox/nyma/common.mak Normal file
View File

@ -0,0 +1,52 @@
# common things across all mednafen cores
MEDNAFLAGS := \
-Imednafen/include -Icommon -Imednafen/src/trio \
-DHAVE_CONFIG_H=1 -DMDFN_DISABLE_NO_OPT_ERRWARN=1 \
-fwrapv \
-fno-strict-aliasing \
-fomit-frame-pointer \
-fsigned-char \
-fno-aggressive-loop-optimizations \
-fno-fast-math \
-fno-unsafe-math-optimizations \
-fjump-tables \
-mfunction-return=keep \
-mindirect-branch=keep \
-mno-indirect-branch-register \
-Wall -Wshadow -Wempty-body -Wignored-qualifiers \
-Wvla -Wvariadic-macros -Wdisabled-optimization -Werror=write-strings
CCFLAGS := $(MEDNAFLAGS) -std=gnu99
CXXFLAGS := $(MEDNAFLAGS) -std=gnu++11
EXTRA_LIBS := -lz
cppdir = $(shell find mednafen/src/$(1) -type f -name '*.cpp')
cdir = $(shell find mednafen/src/$(1) -type f -name '*.c')
MODULENAME := $(lastword $(filter-out $(lastword $(MAKEFILE_LIST)),$(MAKEFILE_LIST)))
MODULENAME := $(MODULENAME:.mak=)
TARGET := $(MODULENAME).wbx
OUT_DIR := obj/$(MODULENAME)
SRCS := \
mednafen/src/error.cpp \
mednafen/src/VirtualFS.cpp \
mednafen/src/FileStream.cpp \
mednafen/src/MemoryStream.cpp \
mednafen/src/Stream.cpp \
mednafen/src/file.cpp \
mednafen/src/NativeVFS.cpp \
mednafen/src/IPSPatcher.cpp \
mednafen/src/Time.cpp \
mednafen/src/git.cpp \
mednafen/src/endian.cpp \
$(call cppdir,string) \
$(call cppdir,hash) \
$(call cdir,trio) \
$(call cdir,cputest) \
$(call cppdir,compress) \
$(call cppdir,video) \
$(filter-out %generate.cpp,$(call cppdir,sound)) \
Interfaces.cpp NymaCore.cpp

864
waterbox/nyma/common/config.h Normal file
View File

@ -0,0 +1,864 @@
/* manually modified */
/* Define if building universal (internal helper macro) */
#undef AC_APPLE_UNIVERSAL_BUILD
/* Define if we are compiling for PPC architectures. */
#undef ARCH_POWERPC
/* Define if we are compiling for 32-bit or 64-bit x86 architectures. */
#define ARCH_X86 1
/* Define if we are compiling for 32-bit x86 architectures. */
#undef ARCH_X86_32
/* Define if we are compiling for 64-bit x86 architectures. */
#define ARCH_X86_64 1
/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
systems. This function is required for `alloca.c' support on those systems.
*/
#undef CRAY_STACKSEG_END
/* Define to 1 if using `alloca.c'. */
#undef C_ALLOCA
/* Define if we are compiling for DOS. */
#undef DOS
/* Define if we are compiling in libxxx mode. */
#define ENABLE_LIBXXX_MODE 1
/* Define to 1 if translation of program messages to the user's native
language is requested. */
#undef ENABLE_NLS
/* Define to 1 if you have the `accept' function. */
#undef HAVE_ACCEPT
/* Define to 1 if you have `alloca', as a function or macro. */
#undef HAVE_ALLOCA
/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
*/
#undef HAVE_ALLOCA_H
/* Define if we are compiling with ALSA support. */
#undef HAVE_ALSA
/* Define if altivec.h is present and usable. */
#undef HAVE_ALTIVEC_H
/* Define to 1 if you have the `argz_count' function. */
#undef HAVE_ARGZ_COUNT
/* Define to 1 if you have the <argz.h> header file. */
#undef HAVE_ARGZ_H
/* Define to 1 if you have the `argz_next' function. */
#undef HAVE_ARGZ_NEXT
/* Define to 1 if you have the `argz_stringify' function. */
#undef HAVE_ARGZ_STRINGIFY
/* Define to 1 if you have the `asprintf' function. */
#undef HAVE_ASPRINTF
/* Define to 1 if you have the `bind' function. */
#undef HAVE_BIND
/* Define to 1 if the compiler understands __builtin_expect. */
#define HAVE_BUILTIN_EXPECT 1
/* Define to 1 if you have the MacOS X function CFLocaleCopyCurrent in the
CoreFoundation framework. */
#undef HAVE_CFLOCALECOPYCURRENT
/* Define to 1 if you have the MacOS X function CFPreferencesCopyAppValue in
the CoreFoundation framework. */
#undef HAVE_CFPREFERENCESCOPYAPPVALUE
/* Define to 1 if you have the `clock_gettime' function. */
#undef HAVE_CLOCK_GETTIME
/* Define to 1 if you have the `close' function. */
#undef HAVE_CLOSE
/* Define to 1 if you have the `connect' function. */
#undef HAVE_CONNECT
/* Define if the GNU dcgettext() function is already present or preinstalled.
*/
#undef HAVE_DCGETTEXT
/* Define to 1 if you have the declaration of `feof_unlocked', and to 0 if you
don't. */
#undef HAVE_DECL_FEOF_UNLOCKED
/* Define to 1 if you have the declaration of `fgets_unlocked', and to 0 if
you don't. */
#undef HAVE_DECL_FGETS_UNLOCKED
/* Define to 1 if you have the declaration of `getc_unlocked', and to 0 if you
don't. */
#undef HAVE_DECL_GETC_UNLOCKED
/* Define to 1 if you have the declaration of `_snprintf', and to 0 if you
don't. */
#undef HAVE_DECL__SNPRINTF
/* Define to 1 if you have the declaration of `_snwprintf', and to 0 if you
don't. */
#undef HAVE_DECL__SNWPRINTF
/* Define if we are compiling with DirectSound support. */
#undef HAVE_DIRECTSOUND
/* Define to 1 if you have the `dup2' function. */
#undef HAVE_DUP2
/* Define if we are compiling and linking with external LZO. */
#undef HAVE_EXTERNAL_LZO2
/* Define if we are compiling and linking with external mpcdec. */
#undef HAVE_EXTERNAL_MPCDEC
/* Define if we are compiling and linking with external tremor. */
#undef HAVE_EXTERNAL_TREMOR
/* Define if we are compiling and linking with external trio. */
#undef HAVE_EXTERNAL_TRIO
/* Define to 1 if you have the `fcntl' function. */
#undef HAVE_FCNTL
/* Define to 1 if you have the <fcntl.h> header file. */
#undef HAVE_FCNTL_H
/* Define to 1 if you have the <fenv.h> header file. */
#undef HAVE_FENV_H
/* Define to 1 if you have the `fopen64' function. */
#undef HAVE_FOPEN64
/* Define to 1 if you have the `fork' function. */
#undef HAVE_FORK
/* Define to 1 if you have the `freeaddrinfo' function. */
#undef HAVE_FREEADDRINFO
/* Define to 1 if fseeko (and presumably ftello) exists and is declared. */
#undef HAVE_FSEEKO
/* Define to 1 if you have the `fseeko64' function. */
#undef HAVE_FSEEKO64
/* Define to 1 if you have the `fstat64' function. */
#undef HAVE_FSTAT64
/* Define to 1 if you have the `ftello' function. */
#undef HAVE_FTELLO
/* Define to 1 if you have the `ftello64' function. */
#undef HAVE_FTELLO64
/* Define to 1 if you have the `ftruncate64' function. */
#undef HAVE_FTRUNCATE64
/* Define to 1 if you have the `fwprintf' function. */
#undef HAVE_FWPRINTF
/* Define to 1 if you have the `gai_strerror' function. */
#undef HAVE_GAI_STRERROR
/* Define to 1 if you have the `getaddrinfo' function. */
#undef HAVE_GETADDRINFO
/* Define to 1 if you have the `getcwd' function. */
#undef HAVE_GETCWD
/* Define to 1 if you have the `getegid' function. */
#undef HAVE_GETEGID
/* Define to 1 if you have the `getenv' function. */
#undef HAVE_GETENV
/* Define to 1 if you have the `geteuid' function. */
#undef HAVE_GETEUID
/* Define to 1 if you have the `getgid' function. */
#undef HAVE_GETGID
/* Define to 1 if you have the `gethostbyaddr' function. */
#undef HAVE_GETHOSTBYADDR
/* Define to 1 if you have the `gethostbyname' function. */
#undef HAVE_GETHOSTBYNAME
/* Define to 1 if you have the `getpagesize' function. */
#undef HAVE_GETPAGESIZE
/* Define to 1 if you have the `getpwuid' function. */
#undef HAVE_GETPWUID
/* Define to 1 if you have the `getsockopt' function. */
#undef HAVE_GETSOCKOPT
/* Define if the GNU gettext() function is already present or preinstalled. */
#undef HAVE_GETTEXT
/* Define to 1 if you have the `gettimeofday' function. */
#undef HAVE_GETTIMEOFDAY
/* Define to 1 if you have the `getuid' function. */
#undef HAVE_GETUID
/* Define to 1 if you have the `gmtime_r' function. */
#undef HAVE_GMTIME_R
/* Define if you have the iconv() function and it works. */
#undef HAVE_ICONV
/* Define if GNU-style AVX inline assembly is supported. */
#undef HAVE_INLINEASM_AVX
/* Define if you have the 'intmax_t' type in <stdint.h> or <inttypes.h>. */
#define HAVE_INTMAX_T 1
/* Define to 1 if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H 1
/* Define if <inttypes.h> exists, doesn't clash with <sys/types.h>, and
declares uintmax_t. */
#define HAVE_INTTYPES_H_WITH_UINTMAX 1
/* Define if we are compiling with JACK support. */
#undef HAVE_JACK
/* Define if you have <langinfo.h> and nl_langinfo(CODESET). */
#undef HAVE_LANGINFO_CODESET
/* Define if your <locale.h> file defines LC_MESSAGES. */
#undef HAVE_LC_MESSAGES
/* Define to 1 if you have the `asound' library (-lasound). */
#undef HAVE_LIBASOUND
/* Define to 1 if you have the `mpcdec' library (-lmpcdec). */
#undef HAVE_LIBMPCDEC
/* Define if we are compiling with libsndfile support. */
#undef HAVE_LIBSNDFILE
/* Define to 1 if you have the `trio' library (-ltrio). */
#undef HAVE_LIBTRIO
/* Define to 1 if you have the `vorbisidec' library (-lvorbisidec). */
#undef HAVE_LIBVORBISIDEC
/* Define to 1 if you have the <limits.h> header file. */
#define HAVE_LIMITS_H 1
/* Define if we are compiling with Linux joystick support. */
#undef HAVE_LINUX_JOYSTICK
/* Define to 1 if you have the `listen' function. */
#undef HAVE_LISTEN
/* Define to 1 if you have the `localtime_r' function. */
#undef HAVE_LOCALTIME_R
/* Define to 1 if the system has the type `long long int'. */
#define HAVE_LONG_LONG_INT 1
/* Define to 1 if you have the `madvise' function. */
#undef HAVE_MADVISE
/* Define to 1 if you have the `mbrtowc' function. */
#undef HAVE_MBRTOWC
/* Define to 1 if you have the `memcmp' function. */
#define HAVE_MEMCMP 1
/* Define to 1 if you have the `memcpy' function. */
#define HAVE_MEMCPY 1
/* Define to 1 if you have the `memmove' function. */
#define HAVE_MEMMOVE 1
/* Define to 1 if you have the <memory.h> header file. */
#define HAVE_MEMORY_H 1
/* Define to 1 if you have the `mempcpy' function. */
#define HAVE_MEMPCPY 1
/* Define to 1 if you have the `memset' function. */
#define HAVE_MEMSET 1
/* Define to 1 if you have the `mkdir' function. */
#define HAVE_MKDIR 1
/* Define to 1 if you have a working `mmap' system call. */
#undef HAVE_MMAP
/* Define to 1 if you have the `munmap' function. */
#undef HAVE_MUNMAP
/* Define to 1 if you have the `nanosleep' function. */
#undef HAVE_NANOSLEEP
/* Define to 1 if you have the `nearbyint' function. */
#undef HAVE_NEARBYINT
/* Define to 1 if you have the `nearbyintf' function. */
#undef HAVE_NEARBYINTF
/* Define to 1 if you have the `newlocale' function. */
#undef HAVE_NEWLOCALE
/* Define if we are compiling with OpenBSD audio support. */
#undef HAVE_OPENBSD_AUDIO
/* Define if we are compiling with OSS support. */
#undef HAVE_OSSDSP
/* Define to 1 if you have the `pipe' function. */
#undef HAVE_PIPE
/* Define to 1 if you have the `poll' function. */
#undef HAVE_POLL
/* Define if your printf() function supports format strings with positions. */
#define HAVE_POSIX_PRINTF 1
/* Define if we are compiling with POSIX sockets support. */
#undef HAVE_POSIX_SOCKETS
/* Define to 1 if you have the `pthread_condattr_setclock' function. */
#undef HAVE_PTHREAD_CONDATTR_SETCLOCK
/* Define to 1 if you have the `pthread_cond_timedwait_relative_np' function.
*/
#undef HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE_NP
/* Define to 1 if you have the `pthread_create' function. */
#undef HAVE_PTHREAD_CREATE
/* Define to 1 if you have the `pthread_getaffinity_np' function. */
#undef HAVE_PTHREAD_GETAFFINITY_NP
/* Define to 1 if you have the <pthread.h> header file. */
#undef HAVE_PTHREAD_H
/* Define if the <pthread.h> defines PTHREAD_MUTEX_RECURSIVE. */
#undef HAVE_PTHREAD_MUTEX_RECURSIVE
/* Define to 1 if you have the <pthread_np.h> header file. */
#undef HAVE_PTHREAD_NP_H
/* Define if the POSIX multithreading library has read/write locks. */
#undef HAVE_PTHREAD_RWLOCK
/* Define to 1 if you have the `pthread_setaffinity_np' function. */
#undef HAVE_PTHREAD_SETAFFINITY_NP
/* Define to 1 if you have the `pthread_setname_np' function. */
#undef HAVE_PTHREAD_SETNAME_NP
/* Define to 1 if you have the `pthread_set_name_np' function. */
#undef HAVE_PTHREAD_SET_NAME_NP
/* Define to 1 if you have the `putenv' function. */
#undef HAVE_PUTENV
/* Define to 1 if you have the `recv' function. */
#undef HAVE_RECV
/* Define to 1 if you have the `rint' function. */
#undef HAVE_RINT
/* Define to 1 if you have the `rintf' function. */
#undef HAVE_RINTF
/* Define to 1 if you have the `round' function. */
#undef HAVE_ROUND
/* Define to 1 if you have the <sched.h> header file. */
#undef HAVE_SCHED_H
/* Define if we are compiling with SDL. */
#undef HAVE_SDL
/* Define to 1 if you have the `select' function. */
#undef HAVE_SELECT
/* Define to 1 if you have the `sem_clockwait' function. */
#undef HAVE_SEM_CLOCKWAIT
/* Define to 1 if you have the `sem_clockwait_np' function. */
#undef HAVE_SEM_CLOCKWAIT_NP
/* Define to 1 if you have the `sem_init' function. */
#undef HAVE_SEM_INIT
/* Define to 1 if you have the `sem_timedwait' function. */
#undef HAVE_SEM_TIMEDWAIT
/* Define to 1 if you have the `sem_timedwait_monotonic' function. */
#undef HAVE_SEM_TIMEDWAIT_MONOTONIC
/* Define to 1 if you have the `send' function. */
#undef HAVE_SEND
/* Define to 1 if you have the `setenv' function. */
#undef HAVE_SETENV
/* Define to 1 if you have the `setlocale' function. */
#undef HAVE_SETLOCALE
/* Define to 1 if you have the `setsockopt' function. */
#undef HAVE_SETSOCKOPT
/* Define to 1 if you have the `sigaction' function. */
#undef HAVE_SIGACTION
/* Define to 1 if you have the `signal' function. */
#undef HAVE_SIGNAL
/* Define to 1 if you have the `snprintf' function. */
#undef HAVE_SNPRINTF
/* Define to 1 if you have the `socket' function. */
#undef HAVE_SOCKET
/* Define to 1 if you have the <stddef.h> header file. */
#define HAVE_STDDEF_H 1
/* Define to 1 if you have the <stdint.h> header file. */
#define HAVE_STDINT_H 1
/* Define if <stdint.h> exists, doesn't clash with <sys/types.h>, and declares
uintmax_t. */
#define HAVE_STDINT_H_WITH_UINTMAX 1
/* Define to 1 if you have the <stdlib.h> header file. */
#define HAVE_STDLIB_H 1
/* Define to 1 if you have the `stpcpy' function. */
#define HAVE_STPCPY 1
/* Define to 1 if you have the `strcasecmp' function. */
#define HAVE_STRCASECMP 1
/* Define to 1 if you have the `strdup' function. */
#define HAVE_STRDUP 1
/* Define to 1 if you have the `strerror' function. */
#undef HAVE_STRERROR
/* Define to 1 if you have the `strerror_r' function. */
#undef HAVE_STRERROR_R
/* Define to 1 if you have the <strings.h> header file. */
#define HAVE_STRINGS_H 1
/* Define to 1 if you have the <string.h> header file. */
#define HAVE_STRING_H 1
/* Define to 1 if you have the `strnlen' function. */
#define HAVE_STRNLEN 1
/* Define to 1 if you have the `strtoul' function. */
#define HAVE_STRTOUL 1
/* Define to 1 if you have the <sys/param.h> header file. */
#undef HAVE_SYS_PARAM_H
/* Define to 1 if you have the <sys/stat.h> header file. */
#undef HAVE_SYS_STAT_H
/* Define to 1 if you have the <sys/types.h> header file. */
#undef HAVE_SYS_TYPES_H
/* Define to 1 if you have the `tsearch' function. */
#undef HAVE_TSEARCH
/* Define if you have the 'uintmax_t' type in <stdint.h> or <inttypes.h>. */
#define HAVE_UINTMAX_T 1
/* Define to 1 if you have the <unistd.h> header file. */
#undef HAVE_UNISTD_H
/* Define to 1 if the system has the type `unsigned long long int'. */
#define HAVE_UNSIGNED_LONG_LONG_INT 1
/* Define to 1 if you have the `uselocale' function. */
#undef HAVE_USELOCALE
/* Define to 1 if you have the `usleep' function. */
#undef HAVE_USLEEP
/* Define to 1 or 0, depending whether the compiler supports simple visibility
declarations. */
#undef HAVE_VISIBILITY
/* Define if we are compiling with WASAPI support. */
#undef HAVE_WASAPI
/* Define if you have the 'wchar_t' type. */
#define HAVE_WCHAR_T 1
/* Define to 1 if you have the `wcrtomb' function. */
#define HAVE_WCRTOMB 1
/* Define to 1 if you have the `wcslen' function. */
#define HAVE_WCSLEN 1
/* Define to 1 if you have the `wcsnlen' function. */
#define HAVE_WCSNLEN 1
/* Define if you have the 'wint_t' type. */
#undef HAVE_WINT_T
/* Define to 1 if O_NOATIME works. */
#undef HAVE_WORKING_O_NOATIME
/* Define to 1 if O_NOFOLLOW works. */
#undef HAVE_WORKING_O_NOFOLLOW
/* Define to 1 if you have the `_mkdir' function. */
#undef HAVE__MKDIR
/* Define to 1 if you have the `__fsetlocking' function. */
#undef HAVE___FSETLOCKING
/* Define to 1 if you have the `__mingw_get_crt_info' function. */
#undef HAVE___MINGW_GET_CRT_INFO
/* Define as const if the declaration of iconv() needs const. */
#define ICONV_CONST
/* Define if integer division by zero raises signal SIGFPE. */
#undef INTDIV0_RAISES_SIGFPE
/* Define on little-endian platforms. */
#define LSB_FIRST 1
/* Define if we are compiling with expensive Mednafen developer features
enabled. */
#undef MDFN_ENABLE_DEV_BUILD
/* Mednafen version definition. */
#define MEDNAFEN_VERSION "1.24.3"
/* Mednafen version numeric. */
#define MEDNAFEN_VERSION_NUMERIC 0x00102403
/* Define if config.h is present */
#undef MINILZO_HAVE_CONFIG_H
/* Define if mkdir takes only one argument. */
#undef MKDIR_TAKES_ONE_ARG
/* Define to use fixed-point MPC decoder. */
#undef MPC_FIXED_POINT
/* Define on big-endian platforms. */
#undef MSB_FIRST
/* Name of package */
#undef PACKAGE
/* Define to the address where bug reports for this package should be sent. */
#undef PACKAGE_BUGREPORT
/* Define to the full name of this package. */
#undef PACKAGE_NAME
/* Define to the full name and version of this package. */
#undef PACKAGE_STRING
/* Define to the one symbol short name of this package. */
#undef PACKAGE_TARNAME
/* Define to the home page for this package. */
#undef PACKAGE_URL
/* Define to the version of this package. */
#undef PACKAGE_VERSION
/* Define if <inttypes.h> exists and defines unusable PRI* macros. */
#undef PRI_MACROS_BROKEN
/* Defines the filesystem path-separator type. */
#define PSS_STYLE 1
/* Define to CPU set type if we are compiling with pthreads affinity setting
support. */
#undef PTHREAD_AFFINITY_NP
/* Define if the pthread_in_use() detection is hard. */
#undef PTHREAD_IN_USE_DETECTION_HARD
/* The size of `char', as computed by sizeof. */
#undef SIZEOF_CHAR
/* The size of `int', as computed by sizeof. */
#undef SIZEOF_INT
/* The size of `long', as computed by sizeof. */
#undef SIZEOF_LONG
/* The size of `long long', as computed by sizeof. */
#undef SIZEOF_LONG_LONG
/* The size of `off_t', as computed by sizeof. */
#undef SIZEOF_OFF_T
/* The size of `ptrdiff_t', as computed by sizeof. */
#undef SIZEOF_PTRDIFF_T
/* The size of `short', as computed by sizeof. */
#undef SIZEOF_SHORT
/* The size of `size_t', as computed by sizeof. */
#undef SIZEOF_SIZE_T
/* The size of `void *', as computed by sizeof. */
#undef SIZEOF_VOID_P
/* The size of `__int64', as computed by sizeof. */
#undef SIZEOF___INT64
/* Define as the maximum value of type 'size_t', if the system doesn't define
it. */
#ifndef SIZE_MAX
# undef SIZE_MAX
#endif
/* If using the C implementation of alloca, define if you know the
direction of stack growth for your system; otherwise it will be
automatically deduced at runtime.
STACK_DIRECTION > 0 => grows toward higher addresses
STACK_DIRECTION < 0 => grows toward lower addresses
STACK_DIRECTION = 0 => direction of growth unknown */
#undef STACK_DIRECTION
/* Define to 1 if you have the ANSI C header files. */
#define STDC_HEADERS 1
/* Define if the POSIX multithreading library can be used. */
#undef USE_POSIX_THREADS
/* Define if references to the POSIX multithreading library should be made
weak. */
#undef USE_POSIX_THREADS_WEAK
/* Define if the GNU Pth multithreading library can be used. */
#undef USE_PTH_THREADS
/* Define if references to the GNU Pth multithreading library should be made
weak. */
#undef USE_PTH_THREADS_WEAK
/* Define if the old Solaris multithreading library can be used. */
#undef USE_SOLARIS_THREADS
/* Define if references to the old Solaris multithreading library should be
made weak. */
#undef USE_SOLARIS_THREADS_WEAK
/* Enable extensions on AIX 3, Interix. */
#ifndef _ALL_SOURCE
# undef _ALL_SOURCE
#endif
/* Enable GNU extensions on systems that have them. */
#ifndef _GNU_SOURCE
# define _GNU_SOURCE
#endif
/* Enable threading extensions on Solaris. */
#ifndef _POSIX_PTHREAD_SEMANTICS
# undef _POSIX_PTHREAD_SEMANTICS
#endif
/* Enable extensions on HP NonStop. */
#ifndef _TANDEM_SOURCE
# undef _TANDEM_SOURCE
#endif
/* Enable general extensions on Solaris. */
#ifndef __EXTENSIONS__
# undef __EXTENSIONS__
#endif
/* Define if the Win32 multithreading API can be used. */
#undef USE_WIN32_THREADS
/* Version number of package */
#undef VERSION
/* Define if we are compiling with Apple II+ emulation. */
#undef WANT_APPLE2_EMU
/* Define if we are compiling with debugger. */
#undef WANT_DEBUGGER
/* Define if we are compiling with with fancy CPU-intensive software video
scalers. */
#undef WANT_FANCY_SCALERS
/* Define if we are compiling with GBA emulation. */
#undef WANT_GBA_EMU
/* Define if we are compiling with GB emulation. */
#undef WANT_GB_EMU
/* Define if we are compiling with internal CJK fonts. */
#undef WANT_INTERNAL_CJK
/* Define if we are compiling with Lynx emulation. */
#define WANT_LYNX_EMU 1
/* Define if we are compiling with Sega Genesis/MegaDrive emulation. */
#undef WANT_MD_EMU
/* Define if we are compiling with NES emulation. */
#undef WANT_NES_EMU
/* Define if we are compiling with NGP emulation. */
#define WANT_NGP_EMU 1
/* Define if we are compiling with PCE emulation. */
#define WANT_PCE_EMU 1
/* Define if we are compiling with separate fast PCE emulation. */
#undef WANT_PCE_FAST_EMU
/* Define if we are compiling with PC-FX emulation. */
#define WANT_PCFX_EMU 1
/* Define if we are compiling with PlayStation emulation. */
#define WANT_PSX_EMU 1
/* Define if we are compiling with SMS+GG emulation. */
#define WANT_SMS_EMU 1
/* Define if we are compiling with SNES emulation. */
#undef WANT_SNES_EMU
/* Define if we are compiling with experimental fast SNES emulation. */
#undef WANT_SNES_FAUST_EMU
/* Define if we are compiling with SSF playback support. */
#undef WANT_SSFPLAY_EMU
/* Define if we are compiling with Sega Saturn emulation. */
#define WANT_SS_EMU 1
/* Define if we are compiling with Virtual Boy emulation. */
#define WANT_VB_EMU 1
/* Define if we are compiling with WonderSwan emulation. */
#define WANT_WSWAN_EMU 1
/* Define if we are compiling for Win32. */
#undef WIN32
/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
significant byte first (like Motorola and SPARC, unlike Intel). */
#if defined AC_APPLE_UNIVERSAL_BUILD
# if defined __BIG_ENDIAN__
# define WORDS_BIGENDIAN 1
# endif
#else
# ifndef WORDS_BIGENDIAN
# undef WORDS_BIGENDIAN
# endif
#endif
/* Enable large inode numbers on Mac OS X 10.5. */
#ifndef _DARWIN_USE_64_BIT_INODE
# define _DARWIN_USE_64_BIT_INODE 1
#endif
/* Number of bits in a file offset, on hosts where this is settable. */
#undef _FILE_OFFSET_BITS
/* Define for largefile support through extra functions. */
#undef _LARGEFILE64_SOURCE
/* Define for fseeko and ftello on some hosts. */
#undef _LARGEFILE_SOURCE
/* Define for large files, on AIX-style hosts. */
#undef _LARGE_FILES
/* Define to 1 if on MINIX. */
#undef _MINIX
/* Define to 2 if the system does not provide POSIX.1 features except with
this defined. */
#undef _POSIX_1_SOURCE
/* Define to 1 if you need to in order for `stat' and other things to work. */
#undef _POSIX_SOURCE
/* Define to empty if `const' does not conform to ANSI C. */
#undef const
/* Define to `__inline__' or `__inline' if that's what the C compiler
calls it, or to nothing if 'inline' is not supported under any name. */
#ifndef __cplusplus
#undef inline
#endif
/* Define as the type of the result of subtracting two pointers, if the system
doesn't define it. */
#undef ptrdiff_t
/* Define to `unsigned int' if <sys/types.h> does not define. */
#undef size_t
/* Define to unsigned long or unsigned long long if <stdint.h> and
<inttypes.h> don't define. */
#undef uintmax_t
#define __libc_lock_t gl_lock_t
#define __libc_lock_define gl_lock_define
#define __libc_lock_define_initialized gl_lock_define_initialized
#define __libc_lock_init gl_lock_init
#define __libc_lock_lock gl_lock_lock
#define __libc_lock_unlock gl_lock_unlock
#define __libc_lock_recursive_t gl_recursive_lock_t
#define __libc_lock_define_recursive gl_recursive_lock_define
#define __libc_lock_define_initialized_recursive gl_recursive_lock_define_initialized
#define __libc_lock_init_recursive gl_recursive_lock_init
#define __libc_lock_lock_recursive gl_recursive_lock_lock
#define __libc_lock_unlock_recursive gl_recursive_lock_unlock
#define glthread_in_use libintl_thread_in_use
#define glthread_lock_init_func libintl_lock_init_func
#define glthread_lock_lock_func libintl_lock_lock_func
#define glthread_lock_unlock_func libintl_lock_unlock_func
#define glthread_lock_destroy_func libintl_lock_destroy_func
#define glthread_rwlock_init_multithreaded libintl_rwlock_init_multithreaded
#define glthread_rwlock_init_func libintl_rwlock_init_func
#define glthread_rwlock_rdlock_multithreaded libintl_rwlock_rdlock_multithreaded
#define glthread_rwlock_rdlock_func libintl_rwlock_rdlock_func
#define glthread_rwlock_wrlock_multithreaded libintl_rwlock_wrlock_multithreaded
#define glthread_rwlock_wrlock_func libintl_rwlock_wrlock_func
#define glthread_rwlock_unlock_multithreaded libintl_rwlock_unlock_multithreaded
#define glthread_rwlock_unlock_func libintl_rwlock_unlock_func
#define glthread_rwlock_destroy_multithreaded libintl_rwlock_destroy_multithreaded
#define glthread_rwlock_destroy_func libintl_rwlock_destroy_func
#define glthread_recursive_lock_init_multithreaded libintl_recursive_lock_init_multithreaded
#define glthread_recursive_lock_init_func libintl_recursive_lock_init_func
#define glthread_recursive_lock_lock_multithreaded libintl_recursive_lock_lock_multithreaded
#define glthread_recursive_lock_lock_func libintl_recursive_lock_lock_func
#define glthread_recursive_lock_unlock_multithreaded libintl_recursive_lock_unlock_multithreaded
#define glthread_recursive_lock_unlock_func libintl_recursive_lock_unlock_func
#define glthread_recursive_lock_destroy_multithreaded libintl_recursive_lock_destroy_multithreaded
#define glthread_recursive_lock_destroy_func libintl_recursive_lock_destroy_func
#define glthread_once_func libintl_once_func
#define glthread_once_singlethreaded libintl_once_singlethreaded
#define glthread_once_multithreaded libintl_once_multithreaded

1
waterbox/nyma/common/minilzo/minilzo.h Normal file
View File

@ -0,0 +1 @@
#include <mednafen/minilzo/_minilzo.h>

4
waterbox/nyma/common/nyma.h Normal file
View File

@ -0,0 +1,4 @@
#pragma once
// the one linked core should set the MDFNGameInfo global
void SetupMDFNGameInfo();

1
waterbox/nyma/common/trio/trio.h Normal file
View File

@ -0,0 +1 @@
#include <trio.h>

1
waterbox/nyma/common/trio/triodef.h Normal file
View File

@ -0,0 +1 @@
#include <triodef.h>

1
waterbox/nyma/common/trio/trionan.h Normal file
View File

@ -0,0 +1 @@
#include <trionan.h>

1
waterbox/nyma/common/trio/triop.h Normal file
View File

@ -0,0 +1 @@
#include <triop.h>

1
waterbox/nyma/common/trio/triostr.h Normal file
View File

@ -0,0 +1 @@
#include <triostr.h>

6
waterbox/nyma/lynx.mak Normal file
View File

@ -0,0 +1,6 @@
include common.mak
SRCS += \
$(call cppdir,lynx)
include ../common.mak

1
waterbox/nyma/mednafen Submodule

@ -0,0 +1 @@
Subproject commit 740d63996fc7cebffd39ee253a29ee434965db21

13
waterbox/nyma/ngp.cpp Normal file
View File

@ -0,0 +1,13 @@
#include "mednafen/src/types.h"
#include "nyma.h"
#include <emulibc.h>
#include "mednafen/src/ngp/neopop.h"
using namespace MDFN_IEN_NGP;
extern Mednafen::MDFNGI EmulatedNGP;
void SetupMDFNGameInfo()
{
Mednafen::MDFNGameInfo = &EmulatedNGP;
}

8
waterbox/nyma/ngp.mak Normal file
View File

@ -0,0 +1,8 @@
include common.mak
SRCS += \
$(call cppdir,ngp) \
$(call cppdir,hw_cpu/z80-fuse) \
ngp.cpp
include ../common.mak

138
waterbox/nyma/pce.cpp Normal file
View File

@ -0,0 +1,138 @@
#include "mednafen/src/types.h"
#include "nyma.h"
#include <emulibc.h>
#include "mednafen/src/pce/pce.h"
#include <waterboxcore.h>
#include "mednafen/src/pce/pcecd.h"
#include "mednafen/src/pce/huc.h"
#include "mednafen/src/hw_misc/arcade_card/arcade_card.h"
using namespace MDFN_IEN_PCE;
extern Mednafen::MDFNGI EmulatedPCE;
void SetupMDFNGameInfo()
{
Mednafen::MDFNGameInfo = &EmulatedPCE;
}
static bool IsSgx()
{
return strcmp(EmulatedPCE.LayerNames, "BG0") == 0;
}
// template<auto ReadFunc, auto WriteFunc>
// static void AccessFunc(uint8_t* buffer, int64_t address, int64_t count, bool write)
// {
// if (write)
// {
// while (count--)
// WriteFunc(address++, *buffer++);
// }
// else
// {
// while (count--)
// *buffer++ = ReadFunc(address++);
// }
// }
#define DEFUN(N,R,W)\
static void Access##N(uint8_t* buffer, int64_t address, int64_t count, bool write)\
{\
if (write)\
{\
while (count--)\
W(address++, *buffer++);\
}\
else\
{\
while (count--)\
*buffer++ = R(address++);\
}\
}
#define DEFRG(N,R,W)\
static void Access##N(uint8_t* buffer, int64_t address, int64_t count, bool write)\
{\
if (write)\
{\
W(address, count, buffer);\
}\
else\
{\
R(address, count, buffer);\
}\
}
namespace MDFN_IEN_PCE
{
extern ArcadeCard* arcade_card;
}
DEFUN(ShortBus, HuCPU.PeekLogical, HuCPU.PokeLogical);
DEFUN(LongBus, HuCPU.PeekPhysical, HuCPU.PokePhysical);
DEFUN(MainMemory, PCE_PeekMainRAM, PCE_PokeMainRAM);
DEFUN(BRAM, HuC_PeekBRAM, HuC_PokeBRAM);
DEFRG(ADPCM, ADPCM_PeekRAM, ADPCM_PokeRAM);
DEFRG(Arcade, arcade_card->PeekRAM, arcade_card->PokeRAM);
ECL_EXPORT void GetMemoryAreas(MemoryArea* m)
{
int i = 0;
m[i].Data = (void*)(MemoryFunctionHook)AccessLongBus;
m[i].Name = "System Bus (21 bit)";
m[i].Size = 1 << 21;
m[i].Flags = MEMORYAREA_FLAGS_WRITABLE | MEMORYAREA_FLAGS_WORDSIZE1 | MEMORYAREA_FLAGS_FUNCTIONHOOK;
i++;
m[i].Data = (void*)(MemoryFunctionHook)AccessShortBus;
m[i].Name = "System Bus";
m[i].Size = 1 << 16;
m[i].Flags = MEMORYAREA_FLAGS_WRITABLE | MEMORYAREA_FLAGS_WORDSIZE1 | MEMORYAREA_FLAGS_FUNCTIONHOOK;
i++;
m[i].Data = (void*)(MemoryFunctionHook)AccessMainMemory;
m[i].Name = "Main Memory";
m[i].Size = IsSgx() ? 32768 : 8192;
m[i].Flags = MEMORYAREA_FLAGS_WRITABLE | MEMORYAREA_FLAGS_WORDSIZE1 | MEMORYAREA_FLAGS_FUNCTIONHOOK | MEMORYAREA_FLAGS_PRIMARY;
i++;
// TODO: "ROM"
if (HuC_IsBRAMAvailable())
{
m[i].Data = (void*)(MemoryFunctionHook)AccessBRAM;
m[i].Name = "Battery RAM";
m[i].Size = 2048;
m[i].Flags = MEMORYAREA_FLAGS_WRITABLE | MEMORYAREA_FLAGS_WORDSIZE1 | MEMORYAREA_FLAGS_ONEFILLED | MEMORYAREA_FLAGS_FUNCTIONHOOK | MEMORYAREA_FLAGS_SAVERAMMABLE;
i++;
}
if (PCE_IsCD)
{
// TODO: "TurboCD RAM" (var CDRAM)
m[i].Data = (void*)(MemoryFunctionHook)AccessADPCM;
m[i].Name = "ADPCM RAM";
m[i].Size = 1 << 16;
m[i].Flags = MEMORYAREA_FLAGS_WRITABLE | MEMORYAREA_FLAGS_WORDSIZE1 | MEMORYAREA_FLAGS_FUNCTIONHOOK;
i++;
// TODO: "Super System Card RAM"
// if (HuCPU.ReadMap[0x68] == SysCardRAMRead)
// {}
if (arcade_card)
{
m[i].Data = (void*)(MemoryFunctionHook)AccessArcade;
m[i].Name = "Arcade Card RAM";
m[i].Size = 1 << 16;
m[i].Flags = MEMORYAREA_FLAGS_WRITABLE | MEMORYAREA_FLAGS_WORDSIZE1 | MEMORYAREA_FLAGS_FUNCTIONHOOK;
i++;
}
}
// TODO: "Cart Battery RAM"
// if (IsPopulous)
// {}
}

24
waterbox/nyma/pce.mak Normal file
View File

@ -0,0 +1,24 @@
include common.mak
# $(filter-out %CDAFReader_SF.cpp,$(call cppdir,cdrom))
# $(call cdir,tremor)
# $(call cdir,mpcdec)
# mednafen/src/mthreading/MThreading_POSIX.cpp
SRCS += \
$(filter-out %debug.cpp,$(call cppdir,pce)) \
$(call cppdir,hw_sound/pce_psg) \
$(call cppdir,hw_misc/arcade_card) \
$(call cppdir,hw_video/huc6270) \
mednafen/src/cdrom/CDInterface.cpp \
mednafen/src/cdrom/scsicd.cpp \
mednafen/src/cdrom/CDUtility.cpp \
mednafen/src/cdrom/lec.cpp \
mednafen/src/cdrom/recover-raw.cpp \
mednafen/src/cdrom/l-ec.cpp \
mednafen/src/cdrom/crc32.cpp \
mednafen/src/cdrom/galois.cpp \
cdrom.cpp \
pce.cpp
include ../common.mak

14
waterbox/nyma/pcfx.mak Normal file
View File

@ -0,0 +1,14 @@
include common.mak
# $(filter-out %CDAFReader_SF.cpp,$(call cppdir,cdrom))
# $(call cdir,tremor)
# $(call cdir,mpcdec)
# mednafen/src/mthreading/MThreading_POSIX.cpp
SRCS += \
$(filter-out %debug.cpp,$(call cppdir,pcfx)) \
$(call cppdir,hw_cpu/v810) \
$(call cppdir,hw_video/huc6270) \
$(call cppdir,hw_sound/pce_psg)
include ../common.mak

7
waterbox/nyma/vb.mak Normal file
View File

@ -0,0 +1,7 @@
include common.mak
SRCS += \
$(filter-out %debug.cpp,$(call cppdir,vb)) \
$(call cppdir,hw_cpu/v810)
include ../common.mak

6
waterbox/nyma/wswan.mak Normal file
View File

@ -0,0 +1,6 @@
include common.mak
SRCS += \
$(filter-out %debug.cpp,$(call cppdir,wswan))
include ../common.mak

1515
waterbox/nyma/zlib/ChangeLog Normal file
View File

File diff suppressed because it is too large Load Diff

368
waterbox/nyma/zlib/FAQ Normal file
View File

@ -0,0 +1,368 @@
Frequently Asked Questions about zlib
If your question is not there, please check the zlib home page
http://zlib.net/ which may have more recent information.
The lastest zlib FAQ is at http://zlib.net/zlib_faq.html
1. Is zlib Y2K-compliant?
Yes. zlib doesn't handle dates.
2. Where can I get a Windows DLL version?
The zlib sources can be compiled without change to produce a DLL. See the
file win32/DLL_FAQ.txt in the zlib distribution. Pointers to the
precompiled DLL are found in the zlib web site at http://zlib.net/ .
3. Where can I get a Visual Basic interface to zlib?
See
* http://marknelson.us/1997/01/01/zlib-engine/
* win32/DLL_FAQ.txt in the zlib distribution
4. compress() returns Z_BUF_ERROR.
Make sure that before the call of compress(), the length of the compressed
buffer is equal to the available size of the compressed buffer and not
zero. For Visual Basic, check that this parameter is passed by reference
("as any"), not by value ("as long").
5. deflate() or inflate() returns Z_BUF_ERROR.
Before making the call, make sure that avail_in and avail_out are not zero.
When setting the parameter flush equal to Z_FINISH, also make sure that
avail_out is big enough to allow processing all pending input. Note that a
Z_BUF_ERROR is not fatal--another call to deflate() or inflate() can be
made with more input or output space. A Z_BUF_ERROR may in fact be
unavoidable depending on how the functions are used, since it is not
possible to tell whether or not there is more output pending when
strm.avail_out returns with zero. See http://zlib.net/zlib_how.html for a
heavily annotated example.
6. Where's the zlib documentation (man pages, etc.)?
It's in zlib.h . Examples of zlib usage are in the files test/example.c
and test/minigzip.c, with more in examples/ .
7. Why don't you use GNU autoconf or libtool or ...?
Because we would like to keep zlib as a very small and simple package.
zlib is rather portable and doesn't need much configuration.
8. I found a bug in zlib.
Most of the time, such problems are due to an incorrect usage of zlib.
Please try to reproduce the problem with a small program and send the
corresponding source to us at zlib@gzip.org . Do not send multi-megabyte
data files without prior agreement.
9. Why do I get "undefined reference to gzputc"?
If "make test" produces something like
example.o(.text+0x154): undefined reference to `gzputc'
check that you don't have old files libz.* in /usr/lib, /usr/local/lib or
/usr/X11R6/lib. Remove any old versions, then do "make install".
10. I need a Delphi interface to zlib.
See the contrib/delphi directory in the zlib distribution.
11. Can zlib handle .zip archives?
Not by itself, no. See the directory contrib/minizip in the zlib
distribution.
12. Can zlib handle .Z files?
No, sorry. You have to spawn an uncompress or gunzip subprocess, or adapt
the code of uncompress on your own.
13. How can I make a Unix shared library?
By default a shared (and a static) library is built for Unix. So:
make distclean
./configure
make
14. How do I install a shared zlib library on Unix?
After the above, then:
make install
However, many flavors of Unix come with a shared zlib already installed.
Before going to the trouble of compiling a shared version of zlib and
trying to install it, you may want to check if it's already there! If you
can #include <zlib.h>, it's there. The -lz option will probably link to
it. You can check the version at the top of zlib.h or with the
ZLIB_VERSION symbol defined in zlib.h .
15. I have a question about OttoPDF.
We are not the authors of OttoPDF. The real author is on the OttoPDF web
site: Joel Hainley, jhainley@myndkryme.com.
16. Can zlib decode Flate data in an Adobe PDF file?
Yes. See http://www.pdflib.com/ . To modify PDF forms, see
http://sourceforge.net/projects/acroformtool/ .
17. Why am I getting this "register_frame_info not found" error on Solaris?
After installing zlib 1.1.4 on Solaris 2.6, running applications using zlib
generates an error such as:
ld.so.1: rpm: fatal: relocation error: file /usr/local/lib/libz.so:
symbol __register_frame_info: referenced symbol not found
The symbol __register_frame_info is not part of zlib, it is generated by
the C compiler (cc or gcc). You must recompile applications using zlib
which have this problem. This problem is specific to Solaris. See
http://www.sunfreeware.com for Solaris versions of zlib and applications
using zlib.
18. Why does gzip give an error on a file I make with compress/deflate?
The compress and deflate functions produce data in the zlib format, which
is different and incompatible with the gzip format. The gz* functions in
zlib on the other hand use the gzip format. Both the zlib and gzip formats
use the same compressed data format internally, but have different headers
and trailers around the compressed data.
19. Ok, so why are there two different formats?
The gzip format was designed to retain the directory information about a
single file, such as the name and last modification date. The zlib format
on the other hand was designed for in-memory and communication channel
applications, and has a much more compact header and trailer and uses a
faster integrity check than gzip.
20. Well that's nice, but how do I make a gzip file in memory?
You can request that deflate write the gzip format instead of the zlib
format using deflateInit2(). You can also request that inflate decode the
gzip format using inflateInit2(). Read zlib.h for more details.
21. Is zlib thread-safe?
Yes. However any library routines that zlib uses and any application-
provided memory allocation routines must also be thread-safe. zlib's gz*
functions use stdio library routines, and most of zlib's functions use the
library memory allocation routines by default. zlib's *Init* functions
allow for the application to provide custom memory allocation routines.
Of course, you should only operate on any given zlib or gzip stream from a
single thread at a time.
22. Can I use zlib in my commercial application?
Yes. Please read the license in zlib.h.
23. Is zlib under the GNU license?
No. Please read the license in zlib.h.
24. The license says that altered source versions must be "plainly marked". So
what exactly do I need to do to meet that requirement?
You need to change the ZLIB_VERSION and ZLIB_VERNUM #defines in zlib.h. In
particular, the final version number needs to be changed to "f", and an
identification string should be appended to ZLIB_VERSION. Version numbers
x.x.x.f are reserved for modifications to zlib by others than the zlib
maintainers. For example, if the version of the base zlib you are altering
is "1.2.3.4", then in zlib.h you should change ZLIB_VERNUM to 0x123f, and
ZLIB_VERSION to something like "1.2.3.f-zachary-mods-v3". You can also
update the version strings in deflate.c and inftrees.c.
For altered source distributions, you should also note the origin and
nature of the changes in zlib.h, as well as in ChangeLog and README, along
with the dates of the alterations. The origin should include at least your
name (or your company's name), and an email address to contact for help or
issues with the library.
Note that distributing a compiled zlib library along with zlib.h and
zconf.h is also a source distribution, and so you should change
ZLIB_VERSION and ZLIB_VERNUM and note the origin and nature of the changes
in zlib.h as you would for a full source distribution.
25. Will zlib work on a big-endian or little-endian architecture, and can I
exchange compressed data between them?
Yes and yes.
26. Will zlib work on a 64-bit machine?
Yes. It has been tested on 64-bit machines, and has no dependence on any
data types being limited to 32-bits in length. If you have any
difficulties, please provide a complete problem report to zlib@gzip.org
27. Will zlib decompress data from the PKWare Data Compression Library?
No. The PKWare DCL uses a completely different compressed data format than
does PKZIP and zlib. However, you can look in zlib's contrib/blast
directory for a possible solution to your problem.
28. Can I access data randomly in a compressed stream?
No, not without some preparation. If when compressing you periodically use
Z_FULL_FLUSH, carefully write all the pending data at those points, and
keep an index of those locations, then you can start decompression at those
points. You have to be careful to not use Z_FULL_FLUSH too often, since it
can significantly degrade compression. Alternatively, you can scan a
deflate stream once to generate an index, and then use that index for
random access. See examples/zran.c .
29. Does zlib work on MVS, OS/390, CICS, etc.?
It has in the past, but we have not heard of any recent evidence. There
were working ports of zlib 1.1.4 to MVS, but those links no longer work.
If you know of recent, successful applications of zlib on these operating
systems, please let us know. Thanks.
30. Is there some simpler, easier to read version of inflate I can look at to
understand the deflate format?
First off, you should read RFC 1951. Second, yes. Look in zlib's
contrib/puff directory.
31. Does zlib infringe on any patents?
As far as we know, no. In fact, that was originally the whole point behind
zlib. Look here for some more information:
http://www.gzip.org/#faq11
32. Can zlib work with greater than 4 GB of data?
Yes. inflate() and deflate() will process any amount of data correctly.
Each call of inflate() or deflate() is limited to input and output chunks
of the maximum value that can be stored in the compiler's "unsigned int"
type, but there is no limit to the number of chunks. Note however that the
strm.total_in and strm_total_out counters may be limited to 4 GB. These
counters are provided as a convenience and are not used internally by
inflate() or deflate(). The application can easily set up its own counters
updated after each call of inflate() or deflate() to count beyond 4 GB.
compress() and uncompress() may be limited to 4 GB, since they operate in a
single call. gzseek() and gztell() may be limited to 4 GB depending on how
zlib is compiled. See the zlibCompileFlags() function in zlib.h.
The word "may" appears several times above since there is a 4 GB limit only
if the compiler's "long" type is 32 bits. If the compiler's "long" type is
64 bits, then the limit is 16 exabytes.
33. Does zlib have any security vulnerabilities?
The only one that we are aware of is potentially in gzprintf(). If zlib is
compiled to use sprintf() or vsprintf(), then there is no protection
against a buffer overflow of an 8K string space (or other value as set by
gzbuffer()), other than the caller of gzprintf() assuring that the output
will not exceed 8K. On the other hand, if zlib is compiled to use
snprintf() or vsnprintf(), which should normally be the case, then there is
no vulnerability. The ./configure script will display warnings if an
insecure variation of sprintf() will be used by gzprintf(). Also the
zlibCompileFlags() function will return information on what variant of
sprintf() is used by gzprintf().
If you don't have snprintf() or vsnprintf() and would like one, you can
find a portable implementation here:
http://www.ijs.si/software/snprintf/
Note that you should be using the most recent version of zlib. Versions
1.1.3 and before were subject to a double-free vulnerability, and versions
1.2.1 and 1.2.2 were subject to an access exception when decompressing
invalid compressed data.
34. Is there a Java version of zlib?
Probably what you want is to use zlib in Java. zlib is already included
as part of the Java SDK in the java.util.zip package. If you really want
a version of zlib written in the Java language, look on the zlib home
page for links: http://zlib.net/ .
35. I get this or that compiler or source-code scanner warning when I crank it
up to maximally-pedantic. Can't you guys write proper code?
Many years ago, we gave up attempting to avoid warnings on every compiler
in the universe. It just got to be a waste of time, and some compilers
were downright silly as well as contradicted each other. So now, we simply
make sure that the code always works.
36. Valgrind (or some similar memory access checker) says that deflate is
performing a conditional jump that depends on an uninitialized value.
Isn't that a bug?
No. That is intentional for performance reasons, and the output of deflate
is not affected. This only started showing up recently since zlib 1.2.x
uses malloc() by default for allocations, whereas earlier versions used
calloc(), which zeros out the allocated memory. Even though the code was
correct, versions 1.2.4 and later was changed to not stimulate these
checkers.
37. Will zlib read the (insert any ancient or arcane format here) compressed
data format?
Probably not. Look in the comp.compression FAQ for pointers to various
formats and associated software.
38. How can I encrypt/decrypt zip files with zlib?
zlib doesn't support encryption. The original PKZIP encryption is very
weak and can be broken with freely available programs. To get strong
encryption, use GnuPG, http://www.gnupg.org/ , which already includes zlib
compression. For PKZIP compatible "encryption", look at
http://www.info-zip.org/
39. What's the difference between the "gzip" and "deflate" HTTP 1.1 encodings?
"gzip" is the gzip format, and "deflate" is the zlib format. They should
probably have called the second one "zlib" instead to avoid confusion with
the raw deflate compressed data format. While the HTTP 1.1 RFC 2616
correctly points to the zlib specification in RFC 1950 for the "deflate"
transfer encoding, there have been reports of servers and browsers that
incorrectly produce or expect raw deflate data per the deflate
specification in RFC 1951, most notably Microsoft. So even though the
"deflate" transfer encoding using the zlib format would be the more
efficient approach (and in fact exactly what the zlib format was designed
for), using the "gzip" transfer encoding is probably more reliable due to
an unfortunate choice of name on the part of the HTTP 1.1 authors.
Bottom line: use the gzip format for HTTP 1.1 encoding.
40. Does zlib support the new "Deflate64" format introduced by PKWare?
No. PKWare has apparently decided to keep that format proprietary, since
they have not documented it as they have previous compression formats. In
any case, the compression improvements are so modest compared to other more
modern approaches, that it's not worth the effort to implement.
41. I'm having a problem with the zip functions in zlib, can you help?
There are no zip functions in zlib. You are probably using minizip by
Giles Vollant, which is found in the contrib directory of zlib. It is not
part of zlib. In fact none of the stuff in contrib is part of zlib. The
files in there are not supported by the zlib authors. You need to contact
the authors of the respective contribution for help.
42. The match.asm code in contrib is under the GNU General Public License.
Since it's part of zlib, doesn't that mean that all of zlib falls under the
GNU GPL?
No. The files in contrib are not part of zlib. They were contributed by
other authors and are provided as a convenience to the user within the zlib
distribution. Each item in contrib has its own license.
43. Is zlib subject to export controls? What is its ECCN?
zlib is not subject to export controls, and so is classified as EAR99.
44. Can you please sign these lengthy legal documents and fax them back to us
so that we can use your software in our product?
No. Go away. Shoo.

410
waterbox/nyma/zlib/Makefile.in Normal file
View File

@ -0,0 +1,410 @@
# Makefile for zlib
# Copyright (C) 1995-2017 Jean-loup Gailly, Mark Adler
# For conditions of distribution and use, see copyright notice in zlib.h
# To compile and test, type:
# ./configure; make test
# Normally configure builds both a static and a shared library.
# If you want to build just a static library, use: ./configure --static
# To use the asm code, type:
# cp contrib/asm?86/match.S ./match.S
# make LOC=-DASMV OBJA=match.o
# To install /usr/local/lib/libz.* and /usr/local/include/zlib.h, type:
# make install
# To install in $HOME instead of /usr/local, use:
# make install prefix=$HOME
CC=cc
CFLAGS=-O
#CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7
#CFLAGS=-g -DZLIB_DEBUG
#CFLAGS=-O3 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \
# -Wstrict-prototypes -Wmissing-prototypes
SFLAGS=-O
LDFLAGS=
TEST_LDFLAGS=-L. libz.a
LDSHARED=$(CC)
CPP=$(CC) -E
STATICLIB=libz.a
SHAREDLIB=libz.so
SHAREDLIBV=libz.so.1.2.11
SHAREDLIBM=libz.so.1
LIBS=$(STATICLIB) $(SHAREDLIBV)
AR=ar
ARFLAGS=rc
RANLIB=ranlib
LDCONFIG=ldconfig
LDSHAREDLIBC=-lc
TAR=tar
SHELL=/bin/sh
EXE=
prefix = /usr/local
exec_prefix = ${prefix}
libdir = ${exec_prefix}/lib
sharedlibdir = ${libdir}
includedir = ${prefix}/include
mandir = ${prefix}/share/man
man3dir = ${mandir}/man3
pkgconfigdir = ${libdir}/pkgconfig
SRCDIR=
ZINC=
ZINCOUT=-I.
OBJZ = adler32.o crc32.o deflate.o infback.o inffast.o inflate.o inftrees.o trees.o zutil.o
OBJG = compress.o uncompr.o gzclose.o gzlib.o gzread.o gzwrite.o
OBJC = $(OBJZ) $(OBJG)
PIC_OBJZ = adler32.lo crc32.lo deflate.lo infback.lo inffast.lo inflate.lo inftrees.lo trees.lo zutil.lo
PIC_OBJG = compress.lo uncompr.lo gzclose.lo gzlib.lo gzread.lo gzwrite.lo
PIC_OBJC = $(PIC_OBJZ) $(PIC_OBJG)
# to use the asm code: make OBJA=match.o, PIC_OBJA=match.lo
OBJA =
PIC_OBJA =
OBJS = $(OBJC) $(OBJA)
PIC_OBJS = $(PIC_OBJC) $(PIC_OBJA)
all: static shared
static: example$(EXE) minigzip$(EXE)
shared: examplesh$(EXE) minigzipsh$(EXE)
all64: example64$(EXE) minigzip64$(EXE)
check: test
test: all teststatic testshared
teststatic: static
@TMPST=tmpst_$$; \
if echo hello world | ./minigzip | ./minigzip -d && ./example $$TMPST ; then \
echo ' *** zlib test OK ***'; \
else \
echo ' *** zlib test FAILED ***'; false; \
fi; \
rm -f $$TMPST
testshared: shared
@LD_LIBRARY_PATH=`pwd`:$(LD_LIBRARY_PATH) ; export LD_LIBRARY_PATH; \
LD_LIBRARYN32_PATH=`pwd`:$(LD_LIBRARYN32_PATH) ; export LD_LIBRARYN32_PATH; \
DYLD_LIBRARY_PATH=`pwd`:$(DYLD_LIBRARY_PATH) ; export DYLD_LIBRARY_PATH; \
SHLIB_PATH=`pwd`:$(SHLIB_PATH) ; export SHLIB_PATH; \
TMPSH=tmpsh_$$; \
if echo hello world | ./minigzipsh | ./minigzipsh -d && ./examplesh $$TMPSH; then \
echo ' *** zlib shared test OK ***'; \
else \
echo ' *** zlib shared test FAILED ***'; false; \
fi; \
rm -f $$TMPSH
test64: all64
@TMP64=tmp64_$$; \
if echo hello world | ./minigzip64 | ./minigzip64 -d && ./example64 $$TMP64; then \
echo ' *** zlib 64-bit test OK ***'; \
else \
echo ' *** zlib 64-bit test FAILED ***'; false; \
fi; \
rm -f $$TMP64
infcover.o: $(SRCDIR)test/infcover.c $(SRCDIR)zlib.h zconf.h
$(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/infcover.c
infcover: infcover.o libz.a
$(CC) $(CFLAGS) -o $@ infcover.o libz.a
cover: infcover
rm -f *.gcda
./infcover
gcov inf*.c
libz.a: $(OBJS)
$(AR) $(ARFLAGS) $@ $(OBJS)
-@ ($(RANLIB) $@ || true) >/dev/null 2>&1
match.o: match.S
$(CPP) match.S > _match.s
$(CC) -c _match.s
mv _match.o match.o
rm -f _match.s
match.lo: match.S
$(CPP) match.S > _match.s
$(CC) -c -fPIC _match.s
mv _match.o match.lo
rm -f _match.s
example.o: $(SRCDIR)test/example.c $(SRCDIR)zlib.h zconf.h
$(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/example.c
minigzip.o: $(SRCDIR)test/minigzip.c $(SRCDIR)zlib.h zconf.h
$(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/minigzip.c
example64.o: $(SRCDIR)test/example.c $(SRCDIR)zlib.h zconf.h
$(CC) $(CFLAGS) $(ZINCOUT) -D_FILE_OFFSET_BITS=64 -c -o $@ $(SRCDIR)test/example.c
minigzip64.o: $(SRCDIR)test/minigzip.c $(SRCDIR)zlib.h zconf.h
$(CC) $(CFLAGS) $(ZINCOUT) -D_FILE_OFFSET_BITS=64 -c -o $@ $(SRCDIR)test/minigzip.c
adler32.o: $(SRCDIR)adler32.c
$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)adler32.c
crc32.o: $(SRCDIR)crc32.c
$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)crc32.c
deflate.o: $(SRCDIR)deflate.c
$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)deflate.c
infback.o: $(SRCDIR)infback.c
$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)infback.c
inffast.o: $(SRCDIR)inffast.c
$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)inffast.c
inflate.o: $(SRCDIR)inflate.c
$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)inflate.c
inftrees.o: $(SRCDIR)inftrees.c
$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)inftrees.c
trees.o: $(SRCDIR)trees.c
$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)trees.c
zutil.o: $(SRCDIR)zutil.c
$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)zutil.c
compress.o: $(SRCDIR)compress.c
$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)compress.c
uncompr.o: $(SRCDIR)uncompr.c
$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)uncompr.c
gzclose.o: $(SRCDIR)gzclose.c
$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzclose.c
gzlib.o: $(SRCDIR)gzlib.c
$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzlib.c
gzread.o: $(SRCDIR)gzread.c
$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzread.c
gzwrite.o: $(SRCDIR)gzwrite.c
$(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzwrite.c
adler32.lo: $(SRCDIR)adler32.c
-@mkdir objs 2>/dev/null || test -d objs
$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/adler32.o $(SRCDIR)adler32.c
-@mv objs/adler32.o $@
crc32.lo: $(SRCDIR)crc32.c
-@mkdir objs 2>/dev/null || test -d objs
$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/crc32.o $(SRCDIR)crc32.c
-@mv objs/crc32.o $@
deflate.lo: $(SRCDIR)deflate.c
-@mkdir objs 2>/dev/null || test -d objs
$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/deflate.o $(SRCDIR)deflate.c
-@mv objs/deflate.o $@
infback.lo: $(SRCDIR)infback.c
-@mkdir objs 2>/dev/null || test -d objs
$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/infback.o $(SRCDIR)infback.c
-@mv objs/infback.o $@
inffast.lo: $(SRCDIR)inffast.c
-@mkdir objs 2>/dev/null || test -d objs
$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/inffast.o $(SRCDIR)inffast.c
-@mv objs/inffast.o $@
inflate.lo: $(SRCDIR)inflate.c
-@mkdir objs 2>/dev/null || test -d objs
$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/inflate.o $(SRCDIR)inflate.c
-@mv objs/inflate.o $@
inftrees.lo: $(SRCDIR)inftrees.c
-@mkdir objs 2>/dev/null || test -d objs
$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/inftrees.o $(SRCDIR)inftrees.c
-@mv objs/inftrees.o $@
trees.lo: $(SRCDIR)trees.c
-@mkdir objs 2>/dev/null || test -d objs
$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/trees.o $(SRCDIR)trees.c
-@mv objs/trees.o $@
zutil.lo: $(SRCDIR)zutil.c
-@mkdir objs 2>/dev/null || test -d objs
$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/zutil.o $(SRCDIR)zutil.c
-@mv objs/zutil.o $@
compress.lo: $(SRCDIR)compress.c
-@mkdir objs 2>/dev/null || test -d objs
$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/compress.o $(SRCDIR)compress.c
-@mv objs/compress.o $@
uncompr.lo: $(SRCDIR)uncompr.c
-@mkdir objs 2>/dev/null || test -d objs
$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/uncompr.o $(SRCDIR)uncompr.c
-@mv objs/uncompr.o $@
gzclose.lo: $(SRCDIR)gzclose.c
-@mkdir objs 2>/dev/null || test -d objs
$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzclose.o $(SRCDIR)gzclose.c
-@mv objs/gzclose.o $@
gzlib.lo: $(SRCDIR)gzlib.c
-@mkdir objs 2>/dev/null || test -d objs
$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzlib.o $(SRCDIR)gzlib.c
-@mv objs/gzlib.o $@
gzread.lo: $(SRCDIR)gzread.c
-@mkdir objs 2>/dev/null || test -d objs
$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzread.o $(SRCDIR)gzread.c
-@mv objs/gzread.o $@
gzwrite.lo: $(SRCDIR)gzwrite.c
-@mkdir objs 2>/dev/null || test -d objs
$(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzwrite.o $(SRCDIR)gzwrite.c
-@mv objs/gzwrite.o $@
placebo $(SHAREDLIBV): $(PIC_OBJS) libz.a
$(LDSHARED) $(SFLAGS) -o $@ $(PIC_OBJS) $(LDSHAREDLIBC) $(LDFLAGS)
rm -f $(SHAREDLIB) $(SHAREDLIBM)
ln -s $@ $(SHAREDLIB)
ln -s $@ $(SHAREDLIBM)
-@rmdir objs
example$(EXE): example.o $(STATICLIB)
$(CC) $(CFLAGS) -o $@ example.o $(TEST_LDFLAGS)
minigzip$(EXE): minigzip.o $(STATICLIB)
$(CC) $(CFLAGS) -o $@ minigzip.o $(TEST_LDFLAGS)
examplesh$(EXE): example.o $(SHAREDLIBV)
$(CC) $(CFLAGS) -o $@ example.o -L. $(SHAREDLIBV)
minigzipsh$(EXE): minigzip.o $(SHAREDLIBV)
$(CC) $(CFLAGS) -o $@ minigzip.o -L. $(SHAREDLIBV)
example64$(EXE): example64.o $(STATICLIB)
$(CC) $(CFLAGS) -o $@ example64.o $(TEST_LDFLAGS)
minigzip64$(EXE): minigzip64.o $(STATICLIB)
$(CC) $(CFLAGS) -o $@ minigzip64.o $(TEST_LDFLAGS)
install-libs: $(LIBS)
-@if [ ! -d $(DESTDIR)$(exec_prefix) ]; then mkdir -p $(DESTDIR)$(exec_prefix); fi
-@if [ ! -d $(DESTDIR)$(libdir) ]; then mkdir -p $(DESTDIR)$(libdir); fi
-@if [ ! -d $(DESTDIR)$(sharedlibdir) ]; then mkdir -p $(DESTDIR)$(sharedlibdir); fi
-@if [ ! -d $(DESTDIR)$(man3dir) ]; then mkdir -p $(DESTDIR)$(man3dir); fi
-@if [ ! -d $(DESTDIR)$(pkgconfigdir) ]; then mkdir -p $(DESTDIR)$(pkgconfigdir); fi
rm -f $(DESTDIR)$(libdir)/$(STATICLIB)
cp $(STATICLIB) $(DESTDIR)$(libdir)
chmod 644 $(DESTDIR)$(libdir)/$(STATICLIB)
-@($(RANLIB) $(DESTDIR)$(libdir)/libz.a || true) >/dev/null 2>&1
-@if test -n "$(SHAREDLIBV)"; then \
rm -f $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBV); \
cp $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir); \
echo "cp $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)"; \
chmod 755 $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBV); \
echo "chmod 755 $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBV)"; \
rm -f $(DESTDIR)$(sharedlibdir)/$(SHAREDLIB) $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBM); \
ln -s $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)/$(SHAREDLIB); \
ln -s $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBM); \
($(LDCONFIG) || true) >/dev/null 2>&1; \
fi
rm -f $(DESTDIR)$(man3dir)/zlib.3
cp $(SRCDIR)zlib.3 $(DESTDIR)$(man3dir)
chmod 644 $(DESTDIR)$(man3dir)/zlib.3
rm -f $(DESTDIR)$(pkgconfigdir)/zlib.pc
cp zlib.pc $(DESTDIR)$(pkgconfigdir)
chmod 644 $(DESTDIR)$(pkgconfigdir)/zlib.pc
# The ranlib in install is needed on NeXTSTEP which checks file times
# ldconfig is for Linux
install: install-libs
-@if [ ! -d $(DESTDIR)$(includedir) ]; then mkdir -p $(DESTDIR)$(includedir); fi
rm -f $(DESTDIR)$(includedir)/zlib.h $(DESTDIR)$(includedir)/zconf.h
cp $(SRCDIR)zlib.h zconf.h $(DESTDIR)$(includedir)
chmod 644 $(DESTDIR)$(includedir)/zlib.h $(DESTDIR)$(includedir)/zconf.h
uninstall:
cd $(DESTDIR)$(includedir) && rm -f zlib.h zconf.h
cd $(DESTDIR)$(libdir) && rm -f libz.a; \
if test -n "$(SHAREDLIBV)" -a -f $(SHAREDLIBV); then \
rm -f $(SHAREDLIBV) $(SHAREDLIB) $(SHAREDLIBM); \
fi
cd $(DESTDIR)$(man3dir) && rm -f zlib.3
cd $(DESTDIR)$(pkgconfigdir) && rm -f zlib.pc
docs: zlib.3.pdf
zlib.3.pdf: $(SRCDIR)zlib.3
groff -mandoc -f H -T ps $(SRCDIR)zlib.3 | ps2pdf - $@
zconf.h.cmakein: $(SRCDIR)zconf.h.in
-@ TEMPFILE=zconfh_$$; \
echo "/#define ZCONF_H/ a\\\\\n#cmakedefine Z_PREFIX\\\\\n#cmakedefine Z_HAVE_UNISTD_H\n" >> $$TEMPFILE &&\
sed -f $$TEMPFILE $(SRCDIR)zconf.h.in > $@ &&\
touch -r $(SRCDIR)zconf.h.in $@ &&\
rm $$TEMPFILE
zconf: $(SRCDIR)zconf.h.in
cp -p $(SRCDIR)zconf.h.in zconf.h
mostlyclean: clean
clean:
rm -f *.o *.lo *~ \
example$(EXE) minigzip$(EXE) examplesh$(EXE) minigzipsh$(EXE) \
example64$(EXE) minigzip64$(EXE) \
infcover \
libz.* foo.gz so_locations \
_match.s maketree contrib/infback9/*.o
rm -rf objs
rm -f *.gcda *.gcno *.gcov
rm -f contrib/infback9/*.gcda contrib/infback9/*.gcno contrib/infback9/*.gcov
maintainer-clean: distclean
distclean: clean zconf zconf.h.cmakein docs
rm -f Makefile zlib.pc configure.log
-@rm -f .DS_Store
@if [ -f Makefile.in ]; then \
printf 'all:\n\t-@echo "Please use ./configure first. Thank you."\n' > Makefile ; \
printf '\ndistclean:\n\tmake -f Makefile.in distclean\n' >> Makefile ; \
touch -r $(SRCDIR)Makefile.in Makefile ; fi
@if [ ! -f zconf.h.in ]; then rm -f zconf.h zconf.h.cmakein ; fi
@if [ ! -f zlib.3 ]; then rm -f zlib.3.pdf ; fi
tags:
etags $(SRCDIR)*.[ch]
adler32.o zutil.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
gzclose.o gzlib.o gzread.o gzwrite.o: $(SRCDIR)zlib.h zconf.h $(SRCDIR)gzguts.h
compress.o example.o minigzip.o uncompr.o: $(SRCDIR)zlib.h zconf.h
crc32.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)crc32.h
deflate.o: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
infback.o inflate.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h $(SRCDIR)inffixed.h
inffast.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h
inftrees.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h
trees.o: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)trees.h
adler32.lo zutil.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
gzclose.lo gzlib.lo gzread.lo gzwrite.lo: $(SRCDIR)zlib.h zconf.h $(SRCDIR)gzguts.h
compress.lo example.lo minigzip.lo uncompr.lo: $(SRCDIR)zlib.h zconf.h
crc32.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)crc32.h
deflate.lo: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
infback.lo inflate.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h $(SRCDIR)inffixed.h
inffast.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h
inftrees.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h
trees.lo: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)trees.h

115
waterbox/nyma/zlib/README Normal file
View File

@ -0,0 +1,115 @@
ZLIB DATA COMPRESSION LIBRARY
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
rfc1952 (gzip format).
All functions of the compression library are documented in the file zlib.h
(volunteer to write man pages welcome, contact zlib@gzip.org). A usage example
of the library is given in the file test/example.c which also tests that
the library is working correctly. Another example is given in the file
test/minigzip.c. The compression library itself is composed of all source
files in the root directory.
To compile all files and run the test program, follow the instructions given at
the top of Makefile.in. In short "./configure; make test", and if that goes
well, "make install" should work for most flavors of Unix. For Windows, use
one of the special makefiles in win32/ or contrib/vstudio/ . For VMS, use
make_vms.com.
Questions about zlib should be sent to <zlib@gzip.org>, or to Gilles Vollant
<info@winimage.com> for the Windows DLL version. The zlib home page is
http://zlib.net/ . Before reporting a problem, please check this site to
verify that you have the latest version of zlib; otherwise get the latest
version and check whether the problem still exists or not.
PLEASE read the zlib FAQ http://zlib.net/zlib_faq.html before asking for help.
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.11 are documented in the file ChangeLog.
Unsupported third party contributions are provided in directory contrib/ .
zlib is available in Java using the java.util.zip package, documented at
http://java.sun.com/developer/technicalArticles/Programming/compression/ .
A Perl interface to zlib written by Paul Marquess <pmqs@cpan.org> is available
at CPAN (Comprehensive Perl Archive Network) sites, including
http://search.cpan.org/~pmqs/IO-Compress-Zlib/ .
A Python interface to zlib written by A.M. Kuchling <amk@amk.ca> is
available in Python 1.5 and later versions, see
http://docs.python.org/library/zlib.html .
zlib is built into tcl: http://wiki.tcl.tk/4610 .
An experimental package to read and write files in .zip format, written on top
of zlib by Gilles Vollant <info@winimage.com>, is available in the
contrib/minizip directory of zlib.
Notes for some targets:
- For Windows DLL versions, please see win32/DLL_FAQ.txt
- For 64-bit Irix, deflate.c must be compiled without any optimization. With
-O, one libpng test fails. The test works in 32 bit mode (with the -n32
compiler flag). The compiler bug has been reported to SGI.
- zlib doesn't work with gcc 2.6.3 on a DEC 3000/300LX under OSF/1 2.1 it works
when compiled with cc.
- On Digital Unix 4.0D (formely OSF/1) on AlphaServer, the cc option -std1 is
necessary to get gzprintf working correctly. This is done by configure.
- zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works with
other compilers. Use "make test" to check your compiler.
- gzdopen is not supported on RISCOS or BEOS.
- For PalmOs, see http://palmzlib.sourceforge.net/
Acknowledgments:
The deflate format used by zlib was defined by Phil Katz. The deflate and
zlib specifications were written by L. Peter Deutsch. Thanks to all the
people who reported problems and suggested various improvements in zlib; they
are too numerous to cite here.
Copyright notice:
(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
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
Jean-loup Gailly Mark Adler
jloup@gzip.org madler@alumni.caltech.edu
If you use the zlib library in a product, we would appreciate *not* receiving
lengthy legal documents to sign. The sources are provided for free but without
warranty of any kind. The library has been entirely written by Jean-loup
Gailly and Mark Adler; it does not include third-party code.
If you redistribute modified sources, we would appreciate that you include in
the file ChangeLog history information documenting your changes. Please read
the FAQ for more information on the distribution of modified source versions.

186
waterbox/nyma/zlib/adler32.c Normal file
View File

@ -0,0 +1,186 @@
/* adler32.c -- compute the Adler-32 checksum of a data stream
* Copyright (C) 1995-2011, 2016 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* @(#) $Id$ */
#include "zutil.h"
local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
#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 */
#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;}
#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1);
#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2);
#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4);
#define DO16(buf) DO8(buf,0); DO8(buf,8);
/* use NO_DIVIDE if your processor does not do division in hardware --
try it both ways to see which is faster */
#ifdef NO_DIVIDE
/* note that this assumes BASE is 65521, where 65536 % 65521 == 15
(thank you to John Reiser for pointing this out) */
# define CHOP(a) \
do { \
unsigned long tmp = a >> 16; \
a &= 0xffffUL; \
a += (tmp << 4) - tmp; \
} while (0)
# define MOD28(a) \
do { \
CHOP(a); \
if (a >= BASE) a -= BASE; \
} while (0)
# define MOD(a) \
do { \
CHOP(a); \
MOD28(a); \
} while (0)
# define MOD63(a) \
do { /* this assumes a is not negative */ \
z_off64_t tmp = a >> 32; \
a &= 0xffffffffL; \
a += (tmp << 8) - (tmp << 5) + tmp; \
tmp = a >> 16; \
a &= 0xffffL; \
a += (tmp << 4) - tmp; \
tmp = a >> 16; \
a &= 0xffffL; \
a += (tmp << 4) - tmp; \
if (a >= BASE) a -= BASE; \
} while (0)
#else
# define MOD(a) a %= BASE
# define MOD28(a) a %= BASE
# define MOD63(a) a %= BASE
#endif
/* ========================================================================= */
uLong ZEXPORT adler32_z(adler, buf, len)
uLong adler;
const Bytef *buf;
z_size_t len;
{
unsigned long sum2;
unsigned n;
/* split Adler-32 into component sums */
sum2 = (adler >> 16) & 0xffff;
adler &= 0xffff;
/* in case user likes doing a byte at a time, keep it fast */
if (len == 1) {
adler += buf[0];
if (adler >= BASE)
adler -= BASE;
sum2 += adler;
if (sum2 >= BASE)
sum2 -= BASE;
return adler | (sum2 << 16);
}
/* initial Adler-32 value (deferred check for len == 1 speed) */
if (buf == Z_NULL)
return 1L;
/* in case short lengths are provided, keep it somewhat fast */
if (len < 16) {
while (len--) {
adler += *buf++;
sum2 += adler;
}
if (adler >= BASE)
adler -= BASE;
MOD28(sum2); /* only added so many BASE's */
return adler | (sum2 << 16);
}
/* do length NMAX blocks -- requires just one modulo operation */
while (len >= NMAX) {
len -= NMAX;
n = NMAX / 16; /* NMAX is divisible by 16 */
do {
DO16(buf); /* 16 sums unrolled */
buf += 16;
} while (--n);
MOD(adler);
MOD(sum2);
}
/* do remaining bytes (less than NMAX, still just one modulo) */
if (len) { /* avoid modulos if none remaining */
while (len >= 16) {
len -= 16;
DO16(buf);
buf += 16;
}
while (len--) {
adler += *buf++;
sum2 += adler;
}
MOD(adler);
MOD(sum2);
}
/* return recombined sums */
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;
uLong adler2;
z_off64_t len2;
{
unsigned long sum1;
unsigned long sum2;
unsigned rem;
/* for negative len, return invalid adler32 as a clue for debugging */
if (len2 < 0)
return 0xffffffffUL;
/* the derivation of this formula is left as an exercise for the reader */
MOD63(len2); /* assumes len2 >= 0 */
rem = (unsigned)len2;
sum1 = adler1 & 0xffff;
sum2 = rem * sum1;
MOD(sum2);
sum1 += (adler2 & 0xffff) + BASE - 1;
sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
if (sum1 >= BASE) sum1 -= BASE;
if (sum1 >= BASE) sum1 -= BASE;
if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);
if (sum2 >= BASE) sum2 -= BASE;
return sum1 | (sum2 << 16);
}
/* ========================================================================= */
uLong ZEXPORT adler32_combine(adler1, adler2, len2)
uLong adler1;
uLong adler2;
z_off_t len2;
{
return adler32_combine_(adler1, adler2, len2);
}
uLong ZEXPORT adler32_combine64(adler1, adler2, len2)
uLong adler1;
uLong adler2;
z_off64_t len2;
{
return adler32_combine_(adler1, adler2, len2);
}

86
waterbox/nyma/zlib/compress.c Normal file
View File

@ -0,0 +1,86 @@
/* compress.c -- compress a memory buffer
* Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* @(#) $Id$ */
#define ZLIB_INTERNAL
#include "zlib.h"
/* ===========================================================================
Compresses the source buffer into the destination buffer. The level
parameter has the same meaning as in deflateInit. sourceLen is the byte
length of the source buffer. Upon entry, destLen is the total size of the
destination buffer, which must be at least 0.1% larger than sourceLen plus
12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
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,
Z_STREAM_ERROR if the level parameter is invalid.
*/
int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
Bytef *dest;
uLongf *destLen;
const Bytef *source;
uLong sourceLen;
int level;
{
z_stream stream;
int err;
const uInt max = (uInt)-1;
uLong left;
left = *destLen;
*destLen = 0;
stream.zalloc = (alloc_func)0;
stream.zfree = (free_func)0;
stream.opaque = (voidpf)0;
err = deflateInit(&stream, level);
if (err != Z_OK) return err;
stream.next_out = dest;
stream.avail_out = 0;
stream.next_in = (z_const Bytef *)source;
stream.avail_in = 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 = 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;
}
/* ===========================================================================
*/
int ZEXPORT compress (dest, destLen, source, sourceLen)
Bytef *dest;
uLongf *destLen;
const Bytef *source;
uLong sourceLen;
{
return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
}
/* ===========================================================================
If the default memLevel or windowBits for deflateInit() is changed, then
this function needs to be updated.
*/
uLong ZEXPORT compressBound (sourceLen)
uLong sourceLen;
{
return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
(sourceLen >> 25) + 13;
}

921
waterbox/nyma/zlib/configure vendored Normal file
View File

@ -0,0 +1,921 @@
#!/bin/sh
# configure script for zlib.
#
# Normally configure builds both a static and a shared library.
# If you want to build just a static library, use: ./configure --static
#
# To impose specific compiler or flags or install directory, use for example:
# prefix=$HOME CC=cc CFLAGS="-O4" ./configure
# or for csh/tcsh users:
# (setenv prefix $HOME; setenv CC cc; setenv CFLAGS "-O4"; ./configure)
# Incorrect settings of CC or CFLAGS may prevent creating a shared library.
# If you have problems, try without defining CC and CFLAGS before reporting
# an error.
# start off configure.log
echo -------------------- >> configure.log
echo $0 $* >> configure.log
date >> configure.log
# get source directory
SRCDIR=`dirname $0`
if test $SRCDIR = "."; then
ZINC=""
ZINCOUT="-I."
SRCDIR=""
else
ZINC='-include zconf.h'
ZINCOUT='-I. -I$(SRCDIR)'
SRCDIR="$SRCDIR/"
fi
# set command prefix for cross-compilation
if [ -n "${CHOST}" ]; then
uname="`echo "${CHOST}" | sed -e 's/^[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)-.*$/\1/'`"
CROSS_PREFIX="${CHOST}-"
fi
# destination name for static library
STATICLIB=libz.a
# extract zlib version numbers from zlib.h
VER=`sed -n -e '/VERSION "/s/.*"\(.*\)".*/\1/p' < ${SRCDIR}zlib.h`
VER3=`sed -n -e '/VERSION "/s/.*"\([0-9]*\\.[0-9]*\\.[0-9]*\).*/\1/p' < ${SRCDIR}zlib.h`
VER2=`sed -n -e '/VERSION "/s/.*"\([0-9]*\\.[0-9]*\)\\..*/\1/p' < ${SRCDIR}zlib.h`
VER1=`sed -n -e '/VERSION "/s/.*"\([0-9]*\)\\..*/\1/p' < ${SRCDIR}zlib.h`
# establish commands for library building
if "${CROSS_PREFIX}ar" --version >/dev/null 2>/dev/null || test $? -lt 126; then
AR=${AR-"${CROSS_PREFIX}ar"}
test -n "${CROSS_PREFIX}" && echo Using ${AR} | tee -a configure.log
else
AR=${AR-"ar"}
test -n "${CROSS_PREFIX}" && echo Using ${AR} | tee -a configure.log
fi
ARFLAGS=${ARFLAGS-"rc"}
if "${CROSS_PREFIX}ranlib" --version >/dev/null 2>/dev/null || test $? -lt 126; then
RANLIB=${RANLIB-"${CROSS_PREFIX}ranlib"}
test -n "${CROSS_PREFIX}" && echo Using ${RANLIB} | tee -a configure.log
else
RANLIB=${RANLIB-"ranlib"}
fi
if "${CROSS_PREFIX}nm" --version >/dev/null 2>/dev/null || test $? -lt 126; then
NM=${NM-"${CROSS_PREFIX}nm"}
test -n "${CROSS_PREFIX}" && echo Using ${NM} | tee -a configure.log
else
NM=${NM-"nm"}
fi
# set defaults before processing command line options
LDCONFIG=${LDCONFIG-"ldconfig"}
LDSHAREDLIBC="${LDSHAREDLIBC--lc}"
ARCHS=
prefix=${prefix-/usr/local}
exec_prefix=${exec_prefix-'${prefix}'}
libdir=${libdir-'${exec_prefix}/lib'}
sharedlibdir=${sharedlibdir-'${libdir}'}
includedir=${includedir-'${prefix}/include'}
mandir=${mandir-'${prefix}/share/man'}
shared_ext='.so'
shared=1
solo=0
cover=0
zprefix=0
zconst=0
build64=0
gcc=0
warn=0
debug=0
old_cc="$CC"
old_cflags="$CFLAGS"
OBJC='$(OBJZ) $(OBJG)'
PIC_OBJC='$(PIC_OBJZ) $(PIC_OBJG)'
# leave this script, optionally in a bad way
leave()
{
if test "$*" != "0"; then
echo "** $0 aborting." | tee -a configure.log
fi
rm -f $test.[co] $test $test$shared_ext $test.gcno ./--version
echo -------------------- >> configure.log
echo >> configure.log
echo >> configure.log
exit $1
}
# process command line options
while test $# -ge 1
do
case "$1" in
-h* | --help)
echo 'usage:' | tee -a configure.log
echo ' configure [--const] [--zprefix] [--prefix=PREFIX] [--eprefix=EXPREFIX]' | tee -a configure.log
echo ' [--static] [--64] [--libdir=LIBDIR] [--sharedlibdir=LIBDIR]' | tee -a configure.log
echo ' [--includedir=INCLUDEDIR] [--archs="-arch i386 -arch x86_64"]' | tee -a configure.log
exit 0 ;;
-p*=* | --prefix=*) prefix=`echo $1 | sed 's/.*=//'`; shift ;;
-e*=* | --eprefix=*) exec_prefix=`echo $1 | sed 's/.*=//'`; shift ;;
-l*=* | --libdir=*) libdir=`echo $1 | sed 's/.*=//'`; shift ;;
--sharedlibdir=*) sharedlibdir=`echo $1 | sed 's/.*=//'`; shift ;;
-i*=* | --includedir=*) includedir=`echo $1 | sed 's/.*=//'`;shift ;;
-u*=* | --uname=*) uname=`echo $1 | sed 's/.*=//'`;shift ;;
-p* | --prefix) prefix="$2"; shift; shift ;;
-e* | --eprefix) exec_prefix="$2"; shift; shift ;;
-l* | --libdir) libdir="$2"; shift; shift ;;
-i* | --includedir) includedir="$2"; shift; shift ;;
-s* | --shared | --enable-shared) shared=1; shift ;;
-t | --static) shared=0; shift ;;
--solo) solo=1; shift ;;
--cover) cover=1; shift ;;
-z* | --zprefix) zprefix=1; shift ;;
-6* | --64) build64=1; shift ;;
-a*=* | --archs=*) ARCHS=`echo $1 | sed 's/.*=//'`; shift ;;
--sysconfdir=*) echo "ignored option: --sysconfdir" | tee -a configure.log; shift ;;
--localstatedir=*) echo "ignored option: --localstatedir" | tee -a configure.log; shift ;;
-c* | --const) zconst=1; shift ;;
-w* | --warn) warn=1; shift ;;
-d* | --debug) debug=1; shift ;;
*)
echo "unknown option: $1" | tee -a configure.log
echo "$0 --help for help" | tee -a configure.log
leave 1;;
esac
done
# temporary file name
test=ztest$$
# put arguments in log, also put test file in log if used in arguments
show()
{
case "$*" in
*$test.c*)
echo === $test.c === >> configure.log
cat $test.c >> configure.log
echo === >> configure.log;;
esac
echo $* >> configure.log
}
# check for gcc vs. cc and set compile and link flags based on the system identified by uname
cat > $test.c <<EOF
extern int getchar();
int hello() {return getchar();}
EOF
test -z "$CC" && echo Checking for ${CROSS_PREFIX}gcc... | tee -a configure.log
cc=${CC-${CROSS_PREFIX}gcc}
cflags=${CFLAGS-"-O3"}
# to force the asm version use: CFLAGS="-O3 -DASMV" ./configure
case "$cc" in
*gcc*) gcc=1 ;;
*clang*) gcc=1 ;;
esac
case `$cc -v 2>&1` in
*gcc*) gcc=1 ;;
*clang*) gcc=1 ;;
esac
show $cc -c $test.c
if test "$gcc" -eq 1 && ($cc -c $test.c) >> configure.log 2>&1; then
echo ... using gcc >> configure.log
CC="$cc"
CFLAGS="${CFLAGS--O3}"
SFLAGS="${CFLAGS--O3} -fPIC"
if test "$ARCHS"; then
CFLAGS="${CFLAGS} ${ARCHS}"
LDFLAGS="${LDFLAGS} ${ARCHS}"
fi
if test $build64 -eq 1; then
CFLAGS="${CFLAGS} -m64"
SFLAGS="${SFLAGS} -m64"
fi
if test "$warn" -eq 1; then
if test "$zconst" -eq 1; then
CFLAGS="${CFLAGS} -Wall -Wextra -Wcast-qual -pedantic -DZLIB_CONST"
else
CFLAGS="${CFLAGS} -Wall -Wextra -pedantic"
fi
fi
if test $debug -eq 1; then
CFLAGS="${CFLAGS} -DZLIB_DEBUG"
SFLAGS="${SFLAGS} -DZLIB_DEBUG"
fi
if test -z "$uname"; then
uname=`(uname -s || echo unknown) 2>/dev/null`
fi
case "$uname" in
Linux* | linux* | GNU | GNU/* | solaris*)
LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,${SRCDIR}zlib.map"} ;;
*BSD | *bsd* | DragonFly)
LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,${SRCDIR}zlib.map"}
LDCONFIG="ldconfig -m" ;;
CYGWIN* | Cygwin* | cygwin* | OS/2*)
EXE='.exe' ;;
MINGW* | mingw*)
# temporary bypass
rm -f $test.[co] $test $test$shared_ext
echo "Please use win32/Makefile.gcc instead." | tee -a configure.log
leave 1
LDSHARED=${LDSHARED-"$cc -shared"}
LDSHAREDLIBC=""
EXE='.exe' ;;
QNX*) # This is for QNX6. I suppose that the QNX rule below is for QNX2,QNX4
# (alain.bonnefoy@icbt.com)
LDSHARED=${LDSHARED-"$cc -shared -Wl,-hlibz.so.1"} ;;
HP-UX*)
LDSHARED=${LDSHARED-"$cc -shared $SFLAGS"}
case `(uname -m || echo unknown) 2>/dev/null` in
ia64)
shared_ext='.so'
SHAREDLIB='libz.so' ;;
*)
shared_ext='.sl'
SHAREDLIB='libz.sl' ;;
esac ;;
Darwin* | darwin*)
shared_ext='.dylib'
SHAREDLIB=libz$shared_ext
SHAREDLIBV=libz.$VER$shared_ext
SHAREDLIBM=libz.$VER1$shared_ext
LDSHARED=${LDSHARED-"$cc -dynamiclib -install_name $libdir/$SHAREDLIBM -compatibility_version $VER1 -current_version $VER3"}
if libtool -V 2>&1 | grep Apple > /dev/null; then
AR="libtool"
else
AR="/usr/bin/libtool"
fi
ARFLAGS="-o" ;;
*) LDSHARED=${LDSHARED-"$cc -shared"} ;;
esac
else
# find system name and corresponding cc options
CC=${CC-cc}
gcc=0
echo ... using $CC >> configure.log
if test -z "$uname"; then
uname=`(uname -sr || echo unknown) 2>/dev/null`
fi
case "$uname" in
HP-UX*) SFLAGS=${CFLAGS-"-O +z"}
CFLAGS=${CFLAGS-"-O"}
# LDSHARED=${LDSHARED-"ld -b +vnocompatwarnings"}
LDSHARED=${LDSHARED-"ld -b"}
case `(uname -m || echo unknown) 2>/dev/null` in
ia64)
shared_ext='.so'
SHAREDLIB='libz.so' ;;
*)
shared_ext='.sl'
SHAREDLIB='libz.sl' ;;
esac ;;
IRIX*) SFLAGS=${CFLAGS-"-ansi -O2 -rpath ."}
CFLAGS=${CFLAGS-"-ansi -O2"}
LDSHARED=${LDSHARED-"cc -shared -Wl,-soname,libz.so.1"} ;;
OSF1\ V4*) SFLAGS=${CFLAGS-"-O -std1"}
CFLAGS=${CFLAGS-"-O -std1"}
LDFLAGS="${LDFLAGS} -Wl,-rpath,."
LDSHARED=${LDSHARED-"cc -shared -Wl,-soname,libz.so -Wl,-msym -Wl,-rpath,$(libdir) -Wl,-set_version,${VER}:1.0"} ;;
OSF1*) SFLAGS=${CFLAGS-"-O -std1"}
CFLAGS=${CFLAGS-"-O -std1"}
LDSHARED=${LDSHARED-"cc -shared -Wl,-soname,libz.so.1"} ;;
QNX*) SFLAGS=${CFLAGS-"-4 -O"}
CFLAGS=${CFLAGS-"-4 -O"}
LDSHARED=${LDSHARED-"cc"}
RANLIB=${RANLIB-"true"}
AR="cc"
ARFLAGS="-A" ;;
SCO_SV\ 3.2*) SFLAGS=${CFLAGS-"-O3 -dy -KPIC "}
CFLAGS=${CFLAGS-"-O3"}
LDSHARED=${LDSHARED-"cc -dy -KPIC -G"} ;;
SunOS\ 5* | solaris*)
LDSHARED=${LDSHARED-"cc -G -h libz$shared_ext.$VER1"}
SFLAGS=${CFLAGS-"-fast -KPIC"}
CFLAGS=${CFLAGS-"-fast"}
if test $build64 -eq 1; then
# old versions of SunPRO/Workshop/Studio don't support -m64,
# but newer ones do. Check for it.
flag64=`$CC -flags | egrep -- '^-m64'`
if test x"$flag64" != x"" ; then
CFLAGS="${CFLAGS} -m64"
SFLAGS="${SFLAGS} -m64"
else
case `(uname -m || echo unknown) 2>/dev/null` in
i86*)
SFLAGS="$SFLAGS -xarch=amd64"
CFLAGS="$CFLAGS -xarch=amd64" ;;
*)
SFLAGS="$SFLAGS -xarch=v9"
CFLAGS="$CFLAGS -xarch=v9" ;;
esac
fi
fi
if test -n "$ZINC"; then
ZINC='-I- -I. -I$(SRCDIR)'
fi
;;
SunOS\ 4*) SFLAGS=${CFLAGS-"-O2 -PIC"}
CFLAGS=${CFLAGS-"-O2"}
LDSHARED=${LDSHARED-"ld"} ;;
SunStudio\ 9*) SFLAGS=${CFLAGS-"-fast -xcode=pic32 -xtarget=ultra3 -xarch=v9b"}
CFLAGS=${CFLAGS-"-fast -xtarget=ultra3 -xarch=v9b"}
LDSHARED=${LDSHARED-"cc -xarch=v9b"} ;;
UNIX_System_V\ 4.2.0)
SFLAGS=${CFLAGS-"-KPIC -O"}
CFLAGS=${CFLAGS-"-O"}
LDSHARED=${LDSHARED-"cc -G"} ;;
UNIX_SV\ 4.2MP)
SFLAGS=${CFLAGS-"-Kconform_pic -O"}
CFLAGS=${CFLAGS-"-O"}
LDSHARED=${LDSHARED-"cc -G"} ;;
OpenUNIX\ 5)
SFLAGS=${CFLAGS-"-KPIC -O"}
CFLAGS=${CFLAGS-"-O"}
LDSHARED=${LDSHARED-"cc -G"} ;;
AIX*) # Courtesy of dbakker@arrayasolutions.com
SFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
CFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
LDSHARED=${LDSHARED-"xlc -G"} ;;
# send working options for other systems to zlib@gzip.org
*) SFLAGS=${CFLAGS-"-O"}
CFLAGS=${CFLAGS-"-O"}
LDSHARED=${LDSHARED-"cc -shared"} ;;
esac
fi
# destination names for shared library if not defined above
SHAREDLIB=${SHAREDLIB-"libz$shared_ext"}
SHAREDLIBV=${SHAREDLIBV-"libz$shared_ext.$VER"}
SHAREDLIBM=${SHAREDLIBM-"libz$shared_ext.$VER1"}
echo >> configure.log
# define functions for testing compiler and library characteristics and logging the results
cat > $test.c <<EOF
#error error
EOF
if ($CC -c $CFLAGS $test.c) 2>/dev/null; then
try()
{
show $*
test "`( $* ) 2>&1 | tee -a configure.log`" = ""
}
echo - using any output from compiler to indicate an error >> configure.log
else
try()
{
show $*
( $* ) >> configure.log 2>&1
ret=$?
if test $ret -ne 0; then
echo "(exit code "$ret")" >> configure.log
fi
return $ret
}
fi
tryboth()
{
show $*
got=`( $* ) 2>&1`
ret=$?
printf %s "$got" >> configure.log
if test $ret -ne 0; then
return $ret
fi
test "$got" = ""
}
cat > $test.c << EOF
int foo() { return 0; }
EOF
echo "Checking for obsessive-compulsive compiler options..." >> configure.log
if try $CC -c $CFLAGS $test.c; then
:
else
echo "Compiler error reporting is too harsh for $0 (perhaps remove -Werror)." | tee -a configure.log
leave 1
fi
echo >> configure.log
# see if shared library build supported
cat > $test.c <<EOF
extern int getchar();
int hello() {return getchar();}
EOF
if test $shared -eq 1; then
echo Checking for shared library support... | tee -a configure.log
# we must test in two steps (cc then ld), required at least on SunOS 4.x
if try $CC -w -c $SFLAGS $test.c &&
try $LDSHARED $SFLAGS -o $test$shared_ext $test.o; then
echo Building shared library $SHAREDLIBV with $CC. | tee -a configure.log
elif test -z "$old_cc" -a -z "$old_cflags"; then
echo No shared library support. | tee -a configure.log
shared=0;
else
echo 'No shared library support; try without defining CC and CFLAGS' | tee -a configure.log
shared=0;
fi
fi
if test $shared -eq 0; then
LDSHARED="$CC"
ALL="static"
TEST="all teststatic"
SHAREDLIB=""
SHAREDLIBV=""
SHAREDLIBM=""
echo Building static library $STATICLIB version $VER with $CC. | tee -a configure.log
else
ALL="static shared"
TEST="all teststatic testshared"
fi
# check for underscores in external names for use by assembler code
CPP=${CPP-"$CC -E"}
case $CFLAGS in
*ASMV*)
echo >> configure.log
show "$NM $test.o | grep _hello"
if test "`$NM $test.o | grep _hello | tee -a configure.log`" = ""; then
CPP="$CPP -DNO_UNDERLINE"
echo Checking for underline in external names... No. | tee -a configure.log
else
echo Checking for underline in external names... Yes. | tee -a configure.log
fi ;;
esac
echo >> configure.log
# check for size_t
cat > $test.c <<EOF
#include <stdio.h>
#include <stdlib.h>
size_t dummy = 0;
EOF
if try $CC -c $CFLAGS $test.c; then
echo "Checking for size_t... Yes." | tee -a configure.log
need_sizet=0
else
echo "Checking for size_t... No." | tee -a configure.log
need_sizet=1
fi
echo >> configure.log
# find the size_t integer type, if needed
if test $need_sizet -eq 1; then
cat > $test.c <<EOF
long long dummy = 0;
EOF
if try $CC -c $CFLAGS $test.c; then
echo "Checking for long long... Yes." | tee -a configure.log
cat > $test.c <<EOF
#include <stdio.h>
int main(void) {
if (sizeof(void *) <= sizeof(int)) puts("int");
else if (sizeof(void *) <= sizeof(long)) puts("long");
else puts("z_longlong");
return 0;
}
EOF
else
echo "Checking for long long... No." | tee -a configure.log
cat > $test.c <<EOF
#include <stdio.h>
int main(void) {
if (sizeof(void *) <= sizeof(int)) puts("int");
else puts("long");
return 0;
}
EOF
fi
if try $CC $CFLAGS -o $test $test.c; then
sizet=`./$test`
echo "Checking for a pointer-size integer type..." $sizet"." | tee -a configure.log
else
echo "Failed to find a pointer-size integer type." | tee -a configure.log
leave 1
fi
fi
if test $need_sizet -eq 1; then
CFLAGS="${CFLAGS} -DNO_SIZE_T=${sizet}"
SFLAGS="${SFLAGS} -DNO_SIZE_T=${sizet}"
fi
echo >> configure.log
# check for large file support, and if none, check for fseeko()
cat > $test.c <<EOF
#include <sys/types.h>
off64_t dummy = 0;
EOF
if try $CC -c $CFLAGS -D_LARGEFILE64_SOURCE=1 $test.c; then
CFLAGS="${CFLAGS} -D_LARGEFILE64_SOURCE=1"
SFLAGS="${SFLAGS} -D_LARGEFILE64_SOURCE=1"
ALL="${ALL} all64"
TEST="${TEST} test64"
echo "Checking for off64_t... Yes." | tee -a configure.log
echo "Checking for fseeko... Yes." | tee -a configure.log
else
echo "Checking for off64_t... No." | tee -a configure.log
echo >> configure.log
cat > $test.c <<EOF
#include <stdio.h>
int main(void) {
fseeko(NULL, 0, 0);
return 0;
}
EOF
if try $CC $CFLAGS -o $test $test.c; then
echo "Checking for fseeko... Yes." | tee -a configure.log
else
CFLAGS="${CFLAGS} -DNO_FSEEKO"
SFLAGS="${SFLAGS} -DNO_FSEEKO"
echo "Checking for fseeko... No." | tee -a configure.log
fi
fi
echo >> configure.log
# check for strerror() for use by gz* functions
cat > $test.c <<EOF
#include <string.h>
#include <errno.h>
int main() { return strlen(strerror(errno)); }
EOF
if try $CC $CFLAGS -o $test $test.c; then
echo "Checking for strerror... Yes." | tee -a configure.log
else
CFLAGS="${CFLAGS} -DNO_STRERROR"
SFLAGS="${SFLAGS} -DNO_STRERROR"
echo "Checking for strerror... No." | tee -a configure.log
fi
# copy clean zconf.h for subsequent edits
cp -p ${SRCDIR}zconf.h.in zconf.h
echo >> configure.log
# check for unistd.h and save result in zconf.h
cat > $test.c <<EOF
#include <unistd.h>
int main() { return 0; }
EOF
if try $CC -c $CFLAGS $test.c; then
sed < zconf.h "/^#ifdef HAVE_UNISTD_H.* may be/s/def HAVE_UNISTD_H\(.*\) may be/ 1\1 was/" > zconf.temp.h
mv zconf.temp.h zconf.h
echo "Checking for unistd.h... Yes." | tee -a configure.log
else
echo "Checking for unistd.h... No." | tee -a configure.log
fi
echo >> configure.log
# check for stdarg.h and save result in zconf.h
cat > $test.c <<EOF
#include <stdarg.h>
int main() { return 0; }
EOF
if try $CC -c $CFLAGS $test.c; then
sed < zconf.h "/^#ifdef HAVE_STDARG_H.* may be/s/def HAVE_STDARG_H\(.*\) may be/ 1\1 was/" > zconf.temp.h
mv zconf.temp.h zconf.h
echo "Checking for stdarg.h... Yes." | tee -a configure.log
else
echo "Checking for stdarg.h... No." | tee -a configure.log
fi
# if the z_ prefix was requested, save that in zconf.h
if test $zprefix -eq 1; then
sed < zconf.h "/#ifdef Z_PREFIX.* may be/s/def Z_PREFIX\(.*\) may be/ 1\1 was/" > zconf.temp.h
mv zconf.temp.h zconf.h
echo >> configure.log
echo "Using z_ prefix on all symbols." | tee -a configure.log
fi
# if --solo compilation was requested, save that in zconf.h and remove gz stuff from object lists
if test $solo -eq 1; then
sed '/#define ZCONF_H/a\
#define Z_SOLO
' < zconf.h > zconf.temp.h
mv zconf.temp.h zconf.h
OBJC='$(OBJZ)'
PIC_OBJC='$(PIC_OBJZ)'
fi
# if code coverage testing was requested, use older gcc if defined, e.g. "gcc-4.2" on Mac OS X
if test $cover -eq 1; then
CFLAGS="${CFLAGS} -fprofile-arcs -ftest-coverage"
if test -n "$GCC_CLASSIC"; then
CC=$GCC_CLASSIC
fi
fi
echo >> configure.log
# conduct a series of tests to resolve eight possible cases of using "vs" or "s" printf functions
# (using stdarg or not), with or without "n" (proving size of buffer), and with or without a
# return value. The most secure result is vsnprintf() with a return value. snprintf() with a
# return value is secure as well, but then gzprintf() will be limited to 20 arguments.
cat > $test.c <<EOF
#include <stdio.h>
#include <stdarg.h>
#include "zconf.h"
int main()
{
#ifndef STDC
choke me
#endif
return 0;
}
EOF
if try $CC -c $CFLAGS $test.c; then
echo "Checking whether to use vs[n]printf() or s[n]printf()... using vs[n]printf()." | tee -a configure.log
echo >> configure.log
cat > $test.c <<EOF
#include <stdio.h>
#include <stdarg.h>
int mytest(const char *fmt, ...)
{
char buf[20];
va_list ap;
va_start(ap, fmt);
vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
return 0;
}
int main()
{
return (mytest("Hello%d\n", 1));
}
EOF
if try $CC $CFLAGS -o $test $test.c; then
echo "Checking for vsnprintf() in stdio.h... Yes." | tee -a configure.log
echo >> configure.log
cat >$test.c <<EOF
#include <stdio.h>
#include <stdarg.h>
int mytest(const char *fmt, ...)
{
int n;
char buf[20];
va_list ap;
va_start(ap, fmt);
n = vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
return n;
}
int main()
{
return (mytest("Hello%d\n", 1));
}
EOF
if try $CC -c $CFLAGS $test.c; then
echo "Checking for return value of vsnprintf()... Yes." | tee -a configure.log
else
CFLAGS="$CFLAGS -DHAS_vsnprintf_void"
SFLAGS="$SFLAGS -DHAS_vsnprintf_void"
echo "Checking for return value of vsnprintf()... No." | tee -a configure.log
echo " WARNING: apparently vsnprintf() does not return a value. zlib" | tee -a configure.log
echo " can build but will be open to possible string-format security" | tee -a configure.log
echo " vulnerabilities." | tee -a configure.log
fi
else
CFLAGS="$CFLAGS -DNO_vsnprintf"
SFLAGS="$SFLAGS -DNO_vsnprintf"
echo "Checking for vsnprintf() in stdio.h... No." | tee -a configure.log
echo " WARNING: vsnprintf() not found, falling back to vsprintf(). zlib" | tee -a configure.log
echo " can build but will be open to possible buffer-overflow security" | tee -a configure.log
echo " vulnerabilities." | tee -a configure.log
echo >> configure.log
cat >$test.c <<EOF
#include <stdio.h>
#include <stdarg.h>
int mytest(const char *fmt, ...)
{
int n;
char buf[20];
va_list ap;
va_start(ap, fmt);
n = vsprintf(buf, fmt, ap);
va_end(ap);
return n;
}
int main()
{
return (mytest("Hello%d\n", 1));
}
EOF
if try $CC -c $CFLAGS $test.c; then
echo "Checking for return value of vsprintf()... Yes." | tee -a configure.log
else
CFLAGS="$CFLAGS -DHAS_vsprintf_void"
SFLAGS="$SFLAGS -DHAS_vsprintf_void"
echo "Checking for return value of vsprintf()... No." | tee -a configure.log
echo " WARNING: apparently vsprintf() does not return a value. zlib" | tee -a configure.log
echo " can build but will be open to possible string-format security" | tee -a configure.log
echo " vulnerabilities." | tee -a configure.log
fi
fi
else
echo "Checking whether to use vs[n]printf() or s[n]printf()... using s[n]printf()." | tee -a configure.log
echo >> configure.log
cat >$test.c <<EOF
#include <stdio.h>
int mytest()
{
char buf[20];
snprintf(buf, sizeof(buf), "%s", "foo");
return 0;
}
int main()
{
return (mytest());
}
EOF
if try $CC $CFLAGS -o $test $test.c; then
echo "Checking for snprintf() in stdio.h... Yes." | tee -a configure.log
echo >> configure.log
cat >$test.c <<EOF
#include <stdio.h>
int mytest()
{
char buf[20];
return snprintf(buf, sizeof(buf), "%s", "foo");
}
int main()
{
return (mytest());
}
EOF
if try $CC -c $CFLAGS $test.c; then
echo "Checking for return value of snprintf()... Yes." | tee -a configure.log
else
CFLAGS="$CFLAGS -DHAS_snprintf_void"
SFLAGS="$SFLAGS -DHAS_snprintf_void"
echo "Checking for return value of snprintf()... No." | tee -a configure.log
echo " WARNING: apparently snprintf() does not return a value. zlib" | tee -a configure.log
echo " can build but will be open to possible string-format security" | tee -a configure.log
echo " vulnerabilities." | tee -a configure.log
fi
else
CFLAGS="$CFLAGS -DNO_snprintf"
SFLAGS="$SFLAGS -DNO_snprintf"
echo "Checking for snprintf() in stdio.h... No." | tee -a configure.log
echo " WARNING: snprintf() not found, falling back to sprintf(). zlib" | tee -a configure.log
echo " can build but will be open to possible buffer-overflow security" | tee -a configure.log
echo " vulnerabilities." | tee -a configure.log
echo >> configure.log
cat >$test.c <<EOF
#include <stdio.h>
int mytest()
{
char buf[20];
return sprintf(buf, "%s", "foo");
}
int main()
{
return (mytest());
}
EOF
if try $CC -c $CFLAGS $test.c; then
echo "Checking for return value of sprintf()... Yes." | tee -a configure.log
else
CFLAGS="$CFLAGS -DHAS_sprintf_void"
SFLAGS="$SFLAGS -DHAS_sprintf_void"
echo "Checking for return value of sprintf()... No." | tee -a configure.log
echo " WARNING: apparently sprintf() does not return a value. zlib" | tee -a configure.log
echo " can build but will be open to possible string-format security" | tee -a configure.log
echo " vulnerabilities." | tee -a configure.log
fi
fi
fi
# see if we can hide zlib internal symbols that are linked between separate source files
if test "$gcc" -eq 1; then
echo >> configure.log
cat > $test.c <<EOF
#define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
int ZLIB_INTERNAL foo;
int main()
{
return 0;
}
EOF
if tryboth $CC -c $CFLAGS $test.c; then
CFLAGS="$CFLAGS -DHAVE_HIDDEN"
SFLAGS="$SFLAGS -DHAVE_HIDDEN"
echo "Checking for attribute(visibility) support... Yes." | tee -a configure.log
else
echo "Checking for attribute(visibility) support... No." | tee -a configure.log
fi
fi
# show the results in the log
echo >> configure.log
echo ALL = $ALL >> configure.log
echo AR = $AR >> configure.log
echo ARFLAGS = $ARFLAGS >> configure.log
echo CC = $CC >> configure.log
echo CFLAGS = $CFLAGS >> configure.log
echo CPP = $CPP >> configure.log
echo EXE = $EXE >> configure.log
echo LDCONFIG = $LDCONFIG >> configure.log
echo LDFLAGS = $LDFLAGS >> configure.log
echo LDSHARED = $LDSHARED >> configure.log
echo LDSHAREDLIBC = $LDSHAREDLIBC >> configure.log
echo OBJC = $OBJC >> configure.log
echo PIC_OBJC = $PIC_OBJC >> configure.log
echo RANLIB = $RANLIB >> configure.log
echo SFLAGS = $SFLAGS >> configure.log
echo SHAREDLIB = $SHAREDLIB >> configure.log
echo SHAREDLIBM = $SHAREDLIBM >> configure.log
echo SHAREDLIBV = $SHAREDLIBV >> configure.log
echo STATICLIB = $STATICLIB >> configure.log
echo TEST = $TEST >> configure.log
echo VER = $VER >> configure.log
echo Z_U4 = $Z_U4 >> configure.log
echo SRCDIR = $SRCDIR >> configure.log
echo exec_prefix = $exec_prefix >> configure.log
echo includedir = $includedir >> configure.log
echo libdir = $libdir >> configure.log
echo mandir = $mandir >> configure.log
echo prefix = $prefix >> configure.log
echo sharedlibdir = $sharedlibdir >> configure.log
echo uname = $uname >> configure.log
# udpate Makefile with the configure results
sed < ${SRCDIR}Makefile.in "
/^CC *=/s#=.*#=$CC#
/^CFLAGS *=/s#=.*#=$CFLAGS#
/^SFLAGS *=/s#=.*#=$SFLAGS#
/^LDFLAGS *=/s#=.*#=$LDFLAGS#
/^LDSHARED *=/s#=.*#=$LDSHARED#
/^CPP *=/s#=.*#=$CPP#
/^STATICLIB *=/s#=.*#=$STATICLIB#
/^SHAREDLIB *=/s#=.*#=$SHAREDLIB#
/^SHAREDLIBV *=/s#=.*#=$SHAREDLIBV#
/^SHAREDLIBM *=/s#=.*#=$SHAREDLIBM#
/^AR *=/s#=.*#=$AR#
/^ARFLAGS *=/s#=.*#=$ARFLAGS#
/^RANLIB *=/s#=.*#=$RANLIB#
/^LDCONFIG *=/s#=.*#=$LDCONFIG#
/^LDSHAREDLIBC *=/s#=.*#=$LDSHAREDLIBC#
/^EXE *=/s#=.*#=$EXE#
/^SRCDIR *=/s#=.*#=$SRCDIR#
/^ZINC *=/s#=.*#=$ZINC#
/^ZINCOUT *=/s#=.*#=$ZINCOUT#
/^prefix *=/s#=.*#=$prefix#
/^exec_prefix *=/s#=.*#=$exec_prefix#
/^libdir *=/s#=.*#=$libdir#
/^sharedlibdir *=/s#=.*#=$sharedlibdir#
/^includedir *=/s#=.*#=$includedir#
/^mandir *=/s#=.*#=$mandir#
/^OBJC *=/s#=.*#= $OBJC#
/^PIC_OBJC *=/s#=.*#= $PIC_OBJC#
/^all: */s#:.*#: $ALL#
/^test: */s#:.*#: $TEST#
" > Makefile
# create zlib.pc with the configure results
sed < ${SRCDIR}zlib.pc.in "
/^CC *=/s#=.*#=$CC#
/^CFLAGS *=/s#=.*#=$CFLAGS#
/^CPP *=/s#=.*#=$CPP#
/^LDSHARED *=/s#=.*#=$LDSHARED#
/^STATICLIB *=/s#=.*#=$STATICLIB#
/^SHAREDLIB *=/s#=.*#=$SHAREDLIB#
/^SHAREDLIBV *=/s#=.*#=$SHAREDLIBV#
/^SHAREDLIBM *=/s#=.*#=$SHAREDLIBM#
/^AR *=/s#=.*#=$AR#
/^ARFLAGS *=/s#=.*#=$ARFLAGS#
/^RANLIB *=/s#=.*#=$RANLIB#
/^EXE *=/s#=.*#=$EXE#
/^prefix *=/s#=.*#=$prefix#
/^exec_prefix *=/s#=.*#=$exec_prefix#
/^libdir *=/s#=.*#=$libdir#
/^sharedlibdir *=/s#=.*#=$sharedlibdir#
/^includedir *=/s#=.*#=$includedir#
/^mandir *=/s#=.*#=$mandir#
/^LDFLAGS *=/s#=.*#=$LDFLAGS#
" | sed -e "
s/\@VERSION\@/$VER/g;
" > zlib.pc
# done
leave 0

6
waterbox/nyma/zlib/configure-for-waterbox Normal file
View File

@ -0,0 +1,6 @@
#!/bin/sh
MYPATH="`dirname \"$0\"`"
SYSROOT="`realpath \"$MYPATH/../../sysroot\"`"
export CC=$SYSROOT/bin/musl-gcc
export CFLAGS="-O3 -mabi=ms -mcmodel=large -mstack-protector-guard=global -no-pie -fno-pic -fno-pie"
./configure --static --prefix=$SYSROOT

442
waterbox/nyma/zlib/crc32.c Normal file
View File

@ -0,0 +1,442 @@
/* crc32.c -- compute the CRC-32 of a data stream
* 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
* CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing
* tables for updating the shift register in one step with three exclusive-ors
* instead of four steps with four exclusive-ors. This results in about a
* factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.
*/
/* @(#) $Id$ */
/*
Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
protection on the static variables used to control the first-use generation
of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should
first call get_crc_table() to initialize the tables before allowing more than
one thread to use crc32().
DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h.
*/
#ifdef MAKECRCH
# include <stdio.h>
# ifndef DYNAMIC_CRC_TABLE
# define DYNAMIC_CRC_TABLE
# endif /* !DYNAMIC_CRC_TABLE */
#endif /* MAKECRCH */
#include "zutil.h" /* for STDC and FAR definitions */
/* 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 *, z_size_t));
local unsigned long crc32_big OF((unsigned long,
const unsigned char FAR *, z_size_t));
# define TBLS 8
#else
# define TBLS 1
#endif /* BYFOUR */
/* Local functions for crc concatenation */
local unsigned long gf2_matrix_times OF((unsigned long *mat,
unsigned long vec));
local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2));
#ifdef DYNAMIC_CRC_TABLE
local volatile int crc_table_empty = 1;
local z_crc_t FAR crc_table[TBLS][256];
local void make_crc_table OF((void));
#ifdef MAKECRCH
local void write_table OF((FILE *, const z_crc_t FAR *));
#endif /* MAKECRCH */
/*
Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
Polynomials over GF(2) are represented in binary, one bit per coefficient,
with the lowest powers in the most significant bit. Then adding polynomials
is just exclusive-or, and multiplying a polynomial by x is a right shift by
one. If we call the above polynomial p, and represent a byte as the
polynomial q, also with the lowest power in the most significant bit (so the
byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
where a mod b means the remainder after dividing a by b.
This calculation is done using the shift-register method of multiplying and
taking the remainder. The register is initialized to zero, and for each
incoming bit, x^32 is added mod p to the register if the bit is a one (where
x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
x (which is shifting right by one and adding x^32 mod p if the bit shifted
out is a one). We start with the highest power (least significant bit) of
q and repeat for all eight bits of q.
The first table is simply the CRC of all possible eight bit values. This is
all the information needed to generate CRCs on data a byte at a time for all
combinations of CRC register values and incoming bytes. The remaining tables
allow for word-at-a-time CRC calculation for both big-endian and little-
endian machines, where a word is four bytes.
*/
local void make_crc_table()
{
z_crc_t c;
int n, k;
z_crc_t poly; /* polynomial exclusive-or pattern */
/* terms of polynomial defining this crc (except x^32): */
static volatile int first = 1; /* flag to limit concurrent making */
static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
/* See if another task is already doing this (not thread-safe, but better
than nothing -- significantly reduces duration of vulnerability in
case the advice about DYNAMIC_CRC_TABLE is ignored) */
if (first) {
first = 0;
/* make exclusive-or pattern from polynomial (0xedb88320UL) */
poly = 0;
for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++)
poly |= (z_crc_t)1 << (31 - p[n]);
/* generate a crc for every 8-bit value */
for (n = 0; n < 256; n++) {
c = (z_crc_t)n;
for (k = 0; k < 8; k++)
c = c & 1 ? poly ^ (c >> 1) : c >> 1;
crc_table[0][n] = c;
}
#ifdef BYFOUR
/* generate crc for each value followed by one, two, and three zeros,
and then the byte reversal of those as well as the first table */
for (n = 0; n < 256; n++) {
c = crc_table[0][n];
crc_table[4][n] = ZSWAP32(c);
for (k = 1; k < 4; k++) {
c = crc_table[0][c & 0xff] ^ (c >> 8);
crc_table[k][n] = c;
crc_table[k + 4][n] = ZSWAP32(c);
}
}
#endif /* BYFOUR */
crc_table_empty = 0;
}
else { /* not first */
/* wait for the other guy to finish (not efficient, but rare) */
while (crc_table_empty)
;
}
#ifdef MAKECRCH
/* write out CRC tables to crc32.h */
{
FILE *out;
out = fopen("crc32.h", "w");
if (out == NULL) return;
fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
fprintf(out, "local const z_crc_t FAR ");
fprintf(out, "crc_table[TBLS][256] =\n{\n {\n");
write_table(out, crc_table[0]);
# ifdef BYFOUR
fprintf(out, "#ifdef BYFOUR\n");
for (k = 1; k < 8; k++) {
fprintf(out, " },\n {\n");
write_table(out, crc_table[k]);
}
fprintf(out, "#endif\n");
# endif /* BYFOUR */
fprintf(out, " }\n};\n");
fclose(out);
}
#endif /* MAKECRCH */
}
#ifdef MAKECRCH
local void write_table(out, table)
FILE *out;
const z_crc_t FAR *table;
{
int n;
for (n = 0; n < 256; n++)
fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ",
(unsigned long)(table[n]),
n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));
}
#endif /* MAKECRCH */
#else /* !DYNAMIC_CRC_TABLE */
/* ========================================================================
* Tables of CRC-32s of all single-byte values, made by make_crc_table().
*/
#include "crc32.h"
#endif /* DYNAMIC_CRC_TABLE */
/* =========================================================================
* This function can be used by asm versions of crc32()
*/
const z_crc_t FAR * ZEXPORT get_crc_table()
{
#ifdef DYNAMIC_CRC_TABLE
if (crc_table_empty)
make_crc_table();
#endif /* DYNAMIC_CRC_TABLE */
return (const z_crc_t FAR *)crc_table;
}
/* ========================================================================= */
#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)
#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
/* ========================================================================= */
unsigned long ZEXPORT crc32_z(crc, buf, len)
unsigned long crc;
const unsigned char FAR *buf;
z_size_t len;
{
if (buf == Z_NULL) return 0UL;
#ifdef DYNAMIC_CRC_TABLE
if (crc_table_empty)
make_crc_table();
#endif /* DYNAMIC_CRC_TABLE */
#ifdef BYFOUR
if (sizeof(void *) == sizeof(ptrdiff_t)) {
z_crc_t endian;
endian = 1;
if (*((unsigned char *)(&endian)))
return crc32_little(crc, buf, len);
else
return crc32_big(crc, buf, len);
}
#endif /* BYFOUR */
crc = crc ^ 0xffffffffUL;
while (len >= 8) {
DO8;
len -= 8;
}
if (len) do {
DO1;
} while (--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] ^ \
crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]
#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
/* ========================================================================= */
local unsigned long crc32_little(crc, buf, len)
unsigned long crc;
const unsigned char FAR *buf;
z_size_t len;
{
register z_crc_t c;
register const z_crc_t FAR *buf4;
c = (z_crc_t)crc;
c = ~c;
while (len && ((ptrdiff_t)buf & 3)) {
c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
len--;
}
buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
while (len >= 32) {
DOLIT32;
len -= 32;
}
while (len >= 4) {
DOLIT4;
len -= 4;
}
buf = (const unsigned char FAR *)buf4;
if (len) do {
c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
} while (--len);
c = ~c;
return (unsigned long)c;
}
/* ========================================================================= */
#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
/* ========================================================================= */
local unsigned long crc32_big(crc, buf, len)
unsigned long crc;
const unsigned char FAR *buf;
z_size_t len;
{
register z_crc_t c;
register const z_crc_t FAR *buf4;
c = ZSWAP32((z_crc_t)crc);
c = ~c;
while (len && ((ptrdiff_t)buf & 3)) {
c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
len--;
}
buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
while (len >= 32) {
DOBIG32;
len -= 32;
}
while (len >= 4) {
DOBIG4;
len -= 4;
}
buf = (const unsigned char FAR *)buf4;
if (len) do {
c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
} while (--len);
c = ~c;
return (unsigned long)(ZSWAP32(c));
}
#endif /* BYFOUR */
#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */
/* ========================================================================= */
local unsigned long gf2_matrix_times(mat, vec)
unsigned long *mat;
unsigned long vec;
{
unsigned long sum;
sum = 0;
while (vec) {
if (vec & 1)
sum ^= *mat;
vec >>= 1;
mat++;
}
return sum;
}
/* ========================================================================= */
local void gf2_matrix_square(square, mat)
unsigned long *square;
unsigned long *mat;
{
int n;
for (n = 0; n < GF2_DIM; n++)
square[n] = gf2_matrix_times(mat, mat[n]);
}
/* ========================================================================= */
local uLong crc32_combine_(crc1, crc2, len2)
uLong crc1;
uLong crc2;
z_off64_t len2;
{
int n;
unsigned long row;
unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */
unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */
/* degenerate case (also disallow negative lengths) */
if (len2 <= 0)
return crc1;
/* put operator for one zero bit in odd */
odd[0] = 0xedb88320UL; /* CRC-32 polynomial */
row = 1;
for (n = 1; n < GF2_DIM; n++) {
odd[n] = row;
row <<= 1;
}
/* put operator for two zero bits in even */
gf2_matrix_square(even, odd);
/* put operator for four zero bits in odd */
gf2_matrix_square(odd, even);
/* apply len2 zeros to crc1 (first square will put the operator for one
zero byte, eight zero bits, in even) */
do {
/* apply zeros operator for this bit of len2 */
gf2_matrix_square(even, odd);
if (len2 & 1)
crc1 = gf2_matrix_times(even, crc1);
len2 >>= 1;
/* if no more bits set, then done */
if (len2 == 0)
break;
/* another iteration of the loop with odd and even swapped */
gf2_matrix_square(odd, even);
if (len2 & 1)
crc1 = gf2_matrix_times(odd, crc1);
len2 >>= 1;
/* if no more bits set, then done */
} while (len2 != 0);
/* return combined crc */
crc1 ^= crc2;
return crc1;
}
/* ========================================================================= */
uLong ZEXPORT crc32_combine(crc1, crc2, len2)
uLong crc1;
uLong crc2;
z_off_t len2;
{
return crc32_combine_(crc1, crc2, len2);
}
uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
uLong crc1;
uLong crc2;
z_off64_t len2;
{
return crc32_combine_(crc1, crc2, len2);
}

441
waterbox/nyma/zlib/crc32.h Normal file
View File

@ -0,0 +1,441 @@
/* crc32.h -- tables for rapid CRC calculation
* Generated automatically by crc32.c
*/
local const z_crc_t FAR crc_table[TBLS][256] =
{
{
0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
0x2d02ef8dUL
#ifdef BYFOUR
},
{
0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL,
0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL,
0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL,
0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL,
0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL,
0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL,
0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL,
0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL,
0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL,
0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL,
0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL,
0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL,
0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL,
0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL,
0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL,
0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL,
0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL,
0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL,
0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL,
0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL,
0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL,
0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL,
0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL,
0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL,
0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL,
0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL,
0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL,
0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL,
0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL,
0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL,
0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL,
0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL,
0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL,
0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL,
0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL,
0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL,
0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL,
0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL,
0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL,
0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL,
0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL,
0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL,
0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL,
0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL,
0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL,
0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL,
0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL,
0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL,
0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL,
0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL,
0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL,
0x9324fd72UL
},
{
0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL,
0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL,
0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL,
0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL,
0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL,
0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL,
0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL,
0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL,
0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL,
0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL,
0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL,
0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL,
0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL,
0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL,
0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL,
0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL,
0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL,
0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL,
0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL,
0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL,
0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL,
0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL,
0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL,
0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL,
0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL,
0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL,
0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL,
0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL,
0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL,
0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL,
0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL,
0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL,
0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL,
0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL,
0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL,
0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL,
0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL,
0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL,
0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL,
0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL,
0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL,
0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL,
0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL,
0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL,
0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL,
0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL,
0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL,
0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL,
0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL,
0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL,
0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL,
0xbe9834edUL
},
{
0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL,
0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL,
0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL,
0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL,
0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL,
0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL,
0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL,
0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL,
0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL,
0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL,
0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL,
0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL,
0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL,
0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL,
0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL,
0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL,
0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL,
0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL,
0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL,
0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL,
0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL,
0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL,
0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL,
0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL,
0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL,
0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL,
0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL,
0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL,
0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL,
0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL,
0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL,
0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL,
0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL,
0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL,
0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL,
0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL,
0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL,
0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL,
0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL,
0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL,
0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL,
0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL,
0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL,
0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL,
0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL,
0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL,
0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL,
0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL,
0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL,
0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL,
0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL,
0xde0506f1UL
},
{
0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL,
0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL,
0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL,
0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL,
0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL,
0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL,
0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL,
0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL,
0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL,
0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL,
0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL,
0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL,
0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL,
0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL,
0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL,
0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL,
0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL,
0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL,
0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL,
0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL,
0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL,
0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL,
0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL,
0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL,
0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL,
0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL,
0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL,
0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL,
0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL,
0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL,
0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL,
0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL,
0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL,
0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL,
0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL,
0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL,
0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL,
0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL,
0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL,
0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL,
0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL,
0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL,
0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL,
0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL,
0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL,
0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL,
0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL,
0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL,
0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL,
0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL,
0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL,
0x8def022dUL
},
{
0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL,
0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL,
0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL,
0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL,
0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL,
0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL,
0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL,
0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL,
0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL,
0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL,
0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL,
0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL,
0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL,
0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL,
0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL,
0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL,
0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL,
0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL,
0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL,
0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL,
0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL,
0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL,
0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL,
0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL,
0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL,
0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL,
0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL,
0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL,
0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL,
0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL,
0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL,
0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL,
0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL,
0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL,
0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL,
0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL,
0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL,
0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL,
0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL,
0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL,
0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL,
0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL,
0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL,
0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL,
0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL,
0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL,
0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL,
0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL,
0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL,
0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL,
0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL,
0x72fd2493UL
},
{
0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL,
0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL,
0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL,
0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL,
0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL,
0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL,
0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL,
0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL,
0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL,
0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL,
0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL,
0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL,
0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL,
0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL,
0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL,
0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL,
0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL,
0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL,
0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL,
0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL,
0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL,
0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL,
0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL,
0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL,
0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL,
0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL,
0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL,
0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL,
0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL,
0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL,
0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL,
0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL,
0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL,
0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL,
0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL,
0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL,
0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL,
0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL,
0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL,
0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL,
0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL,
0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL,
0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL,
0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL,
0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL,
0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL,
0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL,
0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL,
0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL,
0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL,
0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL,
0xed3498beUL
},
{
0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL,
0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL,
0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL,
0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL,
0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL,
0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL,
0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL,
0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL,
0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL,
0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL,
0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL,
0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL,
0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL,
0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL,
0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL,
0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL,
0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL,
0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL,
0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL,
0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL,
0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL,
0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL,
0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL,
0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL,
0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL,
0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL,
0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL,
0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL,
0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL,
0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL,
0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL,
0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL,
0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL,
0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL,
0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL,
0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL,
0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL,
0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL,
0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL,
0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL,
0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL,
0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL,
0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL,
0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL,
0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL,
0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL,
0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL,
0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL,
0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL,
0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL,
0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL,
0xf10605deUL
#endif
}
};

2163
waterbox/nyma/zlib/deflate.c Normal file
View File

File diff suppressed because it is too large Load Diff

349
waterbox/nyma/zlib/deflate.h Normal file
View File

@ -0,0 +1,349 @@
/* deflate.h -- internal compression state
* Copyright (C) 1995-2016 Jean-loup Gailly
* For conditions of distribution and use, see copyright notice in zlib.h
*/
/* WARNING: this file should *not* be used by applications. It is
part of the implementation of the compression library and is
subject to change. Applications should only use zlib.h.
*/
/* @(#) $Id$ */
#ifndef DEFLATE_H
#define DEFLATE_H
#include "zutil.h"
/* define NO_GZIP when compiling if you want to disable gzip header and
trailer creation by deflate(). NO_GZIP would be used to avoid linking in
the crc code when it is not needed. For shared libraries, gzip encoding
should be left enabled. */
#ifndef NO_GZIP
# define GZIP
#endif
/* ===========================================================================
* Internal compression state.
*/
#define LENGTH_CODES 29
/* number of length codes, not counting the special END_BLOCK code */
#define LITERALS 256
/* number of literal bytes 0..255 */
#define L_CODES (LITERALS+1+LENGTH_CODES)
/* number of Literal or Length codes, including the END_BLOCK code */
#define D_CODES 30
/* number of distance codes */
#define BL_CODES 19
/* number of codes used to transfer the bit lengths */
#define HEAP_SIZE (2*L_CODES+1)
/* maximum heap size */
#define MAX_BITS 15
/* All codes must not exceed MAX_BITS bits */
#define Buf_size 16
/* size of bit buffer in bi_buf */
#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 */
/* Data structure describing a single value and its code string. */
typedef struct ct_data_s {
union {
ush freq; /* frequency count */
ush code; /* bit string */
} fc;
union {
ush dad; /* father node in Huffman tree */
ush len; /* length of bit string */
} dl;
} FAR ct_data;
#define Freq fc.freq
#define Code fc.code
#define Dad dl.dad
#define Len dl.len
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 */
const static_tree_desc *stat_desc; /* the corresponding static tree */
} FAR tree_desc;
typedef ush Pos;
typedef Pos FAR Posf;
typedef unsigned IPos;
/* A Pos is an index in the character window. We use short instead of int to
* save space in the various tables. IPos is used only for parameter passing.
*/
typedef struct internal_state {
z_streamp strm; /* pointer back to this zlib stream */
int status; /* as the name implies */
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 */
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 */
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 */
/* used by deflate.c: */
uInt w_size; /* LZ77 window size (32K by default) */
uInt w_bits; /* log2(w_size) (8..16) */
uInt w_mask; /* w_size - 1 */
Bytef *window;
/* Sliding window. Input bytes are read into the second half of the window,
* and move to the first half later to keep a dictionary of at least wSize
* bytes. With this organization, matches are limited to a distance of
* wSize-MAX_MATCH bytes, but this ensures that IO is always
* performed with a length multiple of the block size. Also, it limits
* the window size to 64K, which is quite useful on MSDOS.
* To do: use the user input buffer as sliding window.
*/
ulg window_size;
/* Actual size of window: 2*wSize, except when the user input buffer
* is directly used as sliding window.
*/
Posf *prev;
/* Link to older string with same hash index. To limit the size of this
* array to 64K, this link is maintained only for the last 32K strings.
* An index in this array is thus a window index modulo 32K.
*/
Posf *head; /* Heads of the hash chains or NIL. */
uInt ins_h; /* hash index of string to be inserted */
uInt hash_size; /* number of elements in hash table */
uInt hash_bits; /* log2(hash_size) */
uInt hash_mask; /* hash_size-1 */
uInt hash_shift;
/* Number of bits by which ins_h must be shifted at each input
* step. It must be such that after MIN_MATCH steps, the oldest
* byte no longer takes part in the hash key, that is:
* hash_shift * MIN_MATCH >= hash_bits
*/
long block_start;
/* Window position at the beginning of the current output block. Gets
* negative when the window is moved backwards.
*/
uInt match_length; /* length of best match */
IPos prev_match; /* previous match */
int match_available; /* set if previous match exists */
uInt strstart; /* start of string to insert */
uInt match_start; /* start of matching string */
uInt lookahead; /* number of valid bytes ahead in window */
uInt prev_length;
/* Length of the best match at previous step. Matches not greater than this
* are discarded. This is used in the lazy match evaluation.
*/
uInt max_chain_length;
/* To speed up deflation, hash chains are never searched beyond this
* length. A higher limit improves compression ratio but degrades the
* speed.
*/
uInt max_lazy_match;
/* Attempt to find a better match only when the current match is strictly
* smaller than this value. This mechanism is used only for compression
* levels >= 4.
*/
# define max_insert_length max_lazy_match
/* Insert new strings in the hash table only if the match length is not
* greater than this length. This saves time but degrades compression.
* max_insert_length is used only for compression levels <= 3.
*/
int level; /* compression level (1..9) */
int strategy; /* favor or force Huffman coding*/
uInt good_match;
/* Use a faster search when the previous match is longer than this */
int nice_match; /* Stop searching when current match exceeds this */
/* used by trees.c: */
/* Didn't use ct_data typedef below to suppress compiler warning */
struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */
struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */
struct tree_desc_s l_desc; /* desc. for literal tree */
struct tree_desc_s d_desc; /* desc. for distance tree */
struct tree_desc_s bl_desc; /* desc. for bit length tree */
ush bl_count[MAX_BITS+1];
/* number of codes at each bit length for an optimal tree */
int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */
int heap_len; /* number of elements in the heap */
int heap_max; /* element of largest frequency */
/* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
* The same heap array is used to build all trees.
*/
uch depth[2*L_CODES+1];
/* Depth of each subtree used as tie breaker for trees of equal frequency
*/
uchf *l_buf; /* buffer for literals or lengths */
uInt lit_bufsize;
/* Size of match buffer for literals/lengths. There are 4 reasons for
* limiting lit_bufsize to 64K:
* - frequencies can be kept in 16 bit counters
* - if compression is not successful for the first block, all input
* data is still in the window so we can still emit a stored block even
* when input comes from standard input. (This can also be done for
* all blocks if lit_bufsize is not greater than 32K.)
* - if compression is not successful for a file smaller than 64K, we can
* even emit a stored file instead of a stored block (saving 5 bytes).
* This is applicable only for zip (not gzip or zlib).
* - creating new Huffman trees less frequently may not provide fast
* adaptation to changes in the input data statistics. (Take for
* example a binary file with poorly compressible code followed by
* a highly compressible string table.) Smaller buffer sizes give
* fast adaptation but have of course the overhead of transmitting
* trees more frequently.
* - I can't count above 4
*/
uInt last_lit; /* running index in l_buf */
ushf *d_buf;
/* Buffer for distances. To simplify the code, d_buf and l_buf have
* the same number of elements. To use different lengths, an extra flag
* array would be necessary.
*/
ulg opt_len; /* bit length of current block with optimal trees */
ulg static_len; /* bit length of current block with static trees */
uInt matches; /* number of string matches in current block */
uInt insert; /* bytes at end of window left to insert */
#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
ush bi_buf;
/* Output buffer. bits are inserted starting at the bottom (least
* significant bits).
*/
int bi_valid;
/* Number of valid bits in bi_buf. All bits above the last valid bit
* are always zero.
*/
ulg high_water;
/* High water mark offset in window for initialized bytes -- bytes above
* this are set to zero in order to avoid memory check warnings when
* longest match routines access bytes past the input. This is then
* updated to the new high water mark.
*/
} FAR deflate_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++] = (Bytef)(c);}
#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
/* Minimum amount of lookahead, except at the end of the input file.
* See deflate.c for comments about the MIN_MATCH+1.
*/
#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD)
/* In order to simplify the code, particularly on 16 bit machines, match
* distances are limited to MAX_DIST instead of WSIZE.
*/
#define WIN_INIT MAX_MATCH
/* Number of bytes after end of data in window to initialize in order to avoid
memory checker errors from longest match routines */
/* in trees.c */
void ZLIB_INTERNAL _tr_init OF((deflate_state *s));
int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf,
ulg stored_len, int last));
void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s));
void ZLIB_INTERNAL _tr_align OF((deflate_state *s));
void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
ulg stored_len, int last));
#define d_code(dist) \
((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
/* Mapping from a distance to a distance code. dist is the distance - 1 and
* must not have side effects. _dist_code[256] and _dist_code[257] are never
* used.
*/
#ifndef ZLIB_DEBUG
/* Inline versions of _tr_tally for speed: */
#if defined(GEN_TREES_H) || !defined(STDC)
extern uch ZLIB_INTERNAL _length_code[];
extern uch ZLIB_INTERNAL _dist_code[];
#else
extern const uch ZLIB_INTERNAL _length_code[];
extern const uch ZLIB_INTERNAL _dist_code[];
#endif
# define _tr_tally_lit(s, c, flush) \
{ uch cc = (c); \
s->d_buf[s->last_lit] = 0; \
s->l_buf[s->last_lit++] = cc; \
s->dyn_ltree[cc].Freq++; \
flush = (s->last_lit == s->lit_bufsize-1); \
}
# define _tr_tally_dist(s, distance, length, flush) \
{ uch len = (uch)(length); \
ush dist = (ush)(distance); \
s->d_buf[s->last_lit] = dist; \
s->l_buf[s->last_lit++] = len; \
dist--; \
s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
s->dyn_dtree[d_code(dist)].Freq++; \
flush = (s->last_lit == s->lit_bufsize-1); \
}
#else
# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
# define _tr_tally_dist(s, distance, length, flush) \
flush = _tr_tally(s, distance, length)
#endif
#endif /* DEFLATE_H */

25
waterbox/nyma/zlib/gzclose.c Normal file
View File

@ -0,0 +1,25 @@
/* gzclose.c -- zlib gzclose() function
* Copyright (C) 2004, 2010 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#include "gzguts.h"
/* gzclose() is in a separate file so that it is linked in only if it is used.
That way the other gzclose functions can be used instead to avoid linking in
unneeded compression or decompression routines. */
int ZEXPORT gzclose(file)
gzFile file;
{
#ifndef NO_GZCOMPRESS
gz_statep state;
if (file == NULL)
return Z_STREAM_ERROR;
state = (gz_statep)file;
return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file);
#else
return gzclose_r(file);
#endif
}

218
waterbox/nyma/zlib/gzguts.h Normal file
View File

@ -0,0 +1,218 @@
/* gzguts.h -- zlib internal header definitions for gz* operations
* Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h
*/
#ifdef _LARGEFILE64_SOURCE
# ifndef _LARGEFILE_SOURCE
# define _LARGEFILE_SOURCE 1
# endif
# ifdef _FILE_OFFSET_BITS
# undef _FILE_OFFSET_BITS
# endif
#endif
#ifdef HAVE_HIDDEN
# define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
#else
# define ZLIB_INTERNAL
#endif
#include <stdio.h>
#include "zlib.h"
#ifdef STDC
# include <string.h>
# include <stdlib.h>
# include <limits.h>
#endif
#ifndef _POSIX_SOURCE
# define _POSIX_SOURCE
#endif
#include <fcntl.h>
#ifdef _WIN32
# include <stddef.h>
#endif
#if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32)
# include <io.h>
#endif
#if defined(_WIN32) || defined(__CYGWIN__)
# define WIDECHAR
#endif
#ifdef WINAPI_FAMILY
# define open _open
# define read _read
# define write _write
# define close _close
#endif
#ifdef NO_DEFLATE /* for compatibility with old definition */
# define NO_GZCOMPRESS
#endif
#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)
# ifndef HAVE_VSNPRINTF
# define HAVE_VSNPRINTF
# endif
#endif
#if defined(__CYGWIN__)
# ifndef HAVE_VSNPRINTF
# define HAVE_VSNPRINTF
# endif
#endif
#if defined(MSDOS) && defined(__BORLANDC__) && (BORLANDC > 0x410)
# ifndef HAVE_VSNPRINTF
# define HAVE_VSNPRINTF
# endif
#endif
#ifndef HAVE_VSNPRINTF
# ifdef MSDOS
/* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
but for now we just assume it doesn't. */
# define NO_vsnprintf
# endif
# ifdef __TURBOC__
# define NO_vsnprintf
# endif
# ifdef WIN32
/* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
# if !defined(vsnprintf) && !defined(NO_vsnprintf)
# if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 )
# define vsnprintf _vsnprintf
# endif
# endif
# endif
# ifdef __SASC
# define NO_vsnprintf
# endif
# ifdef VMS
# define NO_vsnprintf
# endif
# ifdef __OS400__
# define NO_vsnprintf
# endif
# ifdef __MVS__
# define NO_vsnprintf
# endif
#endif
/* 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 */
#if defined(_MSC_VER) && _MSC_VER < 1900
# define snprintf _snprintf
#endif
#ifndef local
# define local static
#endif
/* 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
extern voidp malloc OF((uInt size));
extern void free OF((voidpf ptr));
#endif
/* get errno and strerror definition */
#if defined UNDER_CE
# include <windows.h>
# define zstrerror() gz_strwinerror((DWORD)GetLastError())
#else
# ifndef NO_STRERROR
# include <errno.h>
# define zstrerror() strerror(errno)
# else
# define zstrerror() "stdio error (consult errno)"
# endif
#endif
/* provide prototypes for these when building zlib without LFS */
#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0
ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
#endif
/* default memLevel */
#if MAX_MEM_LEVEL >= 8
# define DEF_MEM_LEVEL 8
#else
# define DEF_MEM_LEVEL MAX_MEM_LEVEL
#endif
/* default i/o buffer size -- double this for output when reading (this and
twice this must be able to fit in an unsigned type) */
#define GZBUFSIZE 8192
/* gzip modes, also provide a little integrity check on the passed structure */
#define GZ_NONE 0
#define GZ_READ 7247
#define GZ_WRITE 31153
#define GZ_APPEND 1 /* mode set to GZ_WRITE after the file is opened */
/* values for gz_state how */
#define LOOK 0 /* look for a gzip header */
#define COPY 1 /* copy input directly */
#define GZIP 2 /* decompress a gzip stream */
/* internal gzip file state data structure */
typedef struct {
/* exposed contents for gzgetc() macro */
struct gzFile_s x; /* "x" for exposed */
/* x.have: number of bytes available at x.next */
/* x.next: next output data to deliver or write */
/* x.pos: current position in uncompressed data */
/* used for both reading and writing */
int mode; /* see gzip modes above */
int fd; /* file descriptor */
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 (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 */
int how; /* 0: get header, 1: copy, 2: decompress */
z_off64_t start; /* where the gzip data started, for rewinding */
int eof; /* true if end of input file reached */
int past; /* true if read requested past end */
/* just for writing */
int level; /* compression level */
int strategy; /* compression strategy */
/* seek request */
z_off64_t skip; /* amount to skip (already rewound if backwards) */
int seek; /* true if seek request pending */
/* error information */
int err; /* error code */
char *msg; /* error message */
/* zlib inflate or deflate stream */
z_stream strm; /* stream structure in-place (not a pointer) */
} gz_state;
typedef gz_state FAR *gz_statep;
/* shared functions */
void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *));
#if defined UNDER_CE
char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error));
#endif
/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t
value -- needed when comparing unsigned to z_off64_t, which is signed
(possible z_off64_t types off_t, off64_t, and long are all signed) */
#ifdef INT_MAX
# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX)
#else
unsigned ZLIB_INTERNAL gz_intmax OF((void));
# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax())
#endif

Some files were not shown because too many files have changed in this diff Show More