pax_global_header00006660000000000000000000000064140510215500014503gustar00rootroot0000000000000052 comment=3ddb45a909101ed265e02c0c5f1767a75792ad1e openMSX-RELEASE_17_0/000077500000000000000000000000001405102155000142045ustar00rootroot00000000000000openMSX-RELEASE_17_0/.github/000077500000000000000000000000001405102155000155445ustar00rootroot00000000000000openMSX-RELEASE_17_0/.github/workflows/000077500000000000000000000000001405102155000176015ustar00rootroot00000000000000openMSX-RELEASE_17_0/.github/workflows/linuxbuild-aarch64.yml000066400000000000000000000030371405102155000237340ustar00rootroot00000000000000name: Build Linux aarch64 Distributable on: push: branches: [ master ] pull_request: branches: [ master ] env: target_cpu: aarch64 target_os: linux target_flavour: opt jobs: build: runs-on: ubuntu-20.04 steps: - uses: actions/checkout@v2 - name: Fetch entire repository run: git fetch --prune --unshallow - name: Install prerequisites run: sudo apt-get install libgl1-mesa-dev - name: Make run: make OPENMSX_TARGET_CPU=${{ env.target_cpu }} OPENMSX_TARGET_OS=${{ env.target_os }} OPENMSX_FLAVOUR=${{ env.target_flavour }} staticbindist - name: Determine version id: get_version run: | OPENMSX_VERSION=`python3 build/version.py` echo ::set-output name=OPENMSX_VERSION::$OPENMSX_VERSION - name: Prepare redistributable directory run: | cd derived/${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd/bindist mv install openmsx-${{ steps.get_version.outputs.OPENMSX_VERSION }}-${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd - name: Upload redistributable zip uses: actions/upload-artifact@v1 with: name: openmsx-${{ steps.get_version.outputs.OPENMSX_VERSION }}-${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd.zip path: derived/${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd/bindist/openmsx-${{ steps.get_version.outputs.OPENMSX_VERSION }}-${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd openMSX-RELEASE_17_0/.github/workflows/linuxbuild-x86_64.yml000066400000000000000000000030351405102155000234400ustar00rootroot00000000000000name: Build Linux x86_64 Distributable on: push: branches: [ master ] pull_request: branches: [ master ] env: target_cpu: x86_64 target_os: linux target_flavour: opt jobs: build: runs-on: ubuntu-20.04 steps: - uses: actions/checkout@v2 - name: Fetch entire repository run: git fetch --prune --unshallow - name: Install prerequisites run: sudo apt-get install libgl1-mesa-dev - name: Make run: make OPENMSX_TARGET_CPU=${{ env.target_cpu }} OPENMSX_TARGET_OS=${{ env.target_os }} OPENMSX_FLAVOUR=${{ env.target_flavour }} staticbindist - name: Determine version id: get_version run: | OPENMSX_VERSION=`python3 build/version.py` echo ::set-output name=OPENMSX_VERSION::$OPENMSX_VERSION - name: Prepare redistributable directory run: | cd derived/${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd/bindist mv install openmsx-${{ steps.get_version.outputs.OPENMSX_VERSION }}-${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd - name: Upload redistributable zip uses: actions/upload-artifact@v1 with: name: openmsx-${{ steps.get_version.outputs.OPENMSX_VERSION }}-${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd.zip path: derived/${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd/bindist/openmsx-${{ steps.get_version.outputs.OPENMSX_VERSION }}-${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd openMSX-RELEASE_17_0/.github/workflows/macosbuild-aarch64.yml000066400000000000000000000030201405102155000236670ustar00rootroot00000000000000name: Build macOS aarch64 Distributable on: push: branches: [ master ] pull_request: branches: [ master ] env: target_cpu: aarch64 target_os: darwin target_flavour: opt jobs: build: runs-on: macos-11.0 steps: - uses: actions/checkout@v2 - name: Fetch entire repository run: git fetch --prune --unshallow - name: Make run: make OPENMSX_TARGET_CPU=${{ env.target_cpu }} OPENMSX_TARGET_OS=${{ env.target_os }} OPENMSX_FLAVOUR=${{ env.target_flavour }} staticbindist - name: Determine version id: get_version run: | OPENMSX_VERSION=`python3 build/version.py` echo ::set-output name=OPENMSX_VERSION::$OPENMSX_VERSION - name: Rename redistributable dmg run: | cd derived/${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd mv openmsx-${{ steps.get_version.outputs.OPENMSX_VERSION }}-mac-${{ env.target_cpu }}-bin.dmg openmsx-${{ steps.get_version.outputs.OPENMSX_VERSION }}-${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd.dmg - name: Upload redistributable dmg uses: actions/upload-artifact@v1 with: name: openmsx-${{ steps.get_version.outputs.OPENMSX_VERSION }}-${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd.dmg path: derived/${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd/openmsx-${{ steps.get_version.outputs.OPENMSX_VERSION }}-${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd.dmg openMSX-RELEASE_17_0/.github/workflows/macosbuild-x86_64.yml000066400000000000000000000030161405102155000234020ustar00rootroot00000000000000name: Build macOS x86_64 Distributable on: push: branches: [ master ] pull_request: branches: [ master ] env: target_cpu: x86_64 target_os: darwin target_flavour: opt jobs: build: runs-on: macos-11.0 steps: - uses: actions/checkout@v2 - name: Fetch entire repository run: git fetch --prune --unshallow - name: Make run: make OPENMSX_TARGET_CPU=${{ env.target_cpu }} OPENMSX_TARGET_OS=${{ env.target_os }} OPENMSX_FLAVOUR=${{ env.target_flavour }} staticbindist - name: Determine version id: get_version run: | OPENMSX_VERSION=`python3 build/version.py` echo ::set-output name=OPENMSX_VERSION::$OPENMSX_VERSION - name: Rename redistributable dmg run: | cd derived/${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd mv openmsx-${{ steps.get_version.outputs.OPENMSX_VERSION }}-mac-${{ env.target_cpu }}-bin.dmg openmsx-${{ steps.get_version.outputs.OPENMSX_VERSION }}-${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd.dmg - name: Upload redistributable dmg uses: actions/upload-artifact@v1 with: name: openmsx-${{ steps.get_version.outputs.OPENMSX_VERSION }}-${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd.dmg path: derived/${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd/openmsx-${{ steps.get_version.outputs.OPENMSX_VERSION }}-${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd.dmg openMSX-RELEASE_17_0/.github/workflows/windowsbuild-x86_64.yml000066400000000000000000000037471405102155000240050ustar00rootroot00000000000000name: Build Windows x86_64 Distributable on: push: branches: [ master ] pull_request: branches: [ master ] env: target_cpu: x86_64 target_os: mingw-w64 target_flavour: opt jobs: build: runs-on: ubuntu-20.04 steps: - uses: actions/checkout@v2 - name: Fetch entire repository run: git fetch --prune --unshallow - name: Install prerequisites run: sudo apt-get install mingw-w64 gcc make tcl - name: Configure MinGW to use Posix threads run: | sudo update-alternatives --set i686-w64-mingw32-gcc /usr/bin/i686-w64-mingw32-gcc-posix sudo update-alternatives --set i686-w64-mingw32-g++ /usr/bin/i686-w64-mingw32-g++-posix sudo update-alternatives --set x86_64-w64-mingw32-gcc /usr/bin/x86_64-w64-mingw32-gcc-posix sudo update-alternatives --set x86_64-w64-mingw32-g++ /usr/bin/x86_64-w64-mingw32-g++-posix - name: Make run: make OPENMSX_TARGET_CPU=${{ env.target_cpu }} OPENMSX_TARGET_OS=${{ env.target_os }} OPENMSX_FLAVOUR=${{ env.target_flavour }} staticbindist - name: Determine version id: get_version run: | OPENMSX_VERSION=`python3 build/version.py` echo ::set-output name=OPENMSX_VERSION::$OPENMSX_VERSION - name: Prepare redistributable directory run: | cd derived/${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd/bindist mv install openmsx-${{ steps.get_version.outputs.OPENMSX_VERSION }}-${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }} - name: Upload redistributable zip uses: actions/upload-artifact@v1 with: name: openmsx-${{ steps.get_version.outputs.OPENMSX_VERSION }}-${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}.zip path: derived/${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }}-3rd/bindist/openmsx-${{ steps.get_version.outputs.OPENMSX_VERSION }}-${{ env.target_cpu }}-${{ env.target_os }}-${{ env.target_flavour }} openMSX-RELEASE_17_0/.gitignore000066400000000000000000000002031405102155000161670ustar00rootroot00000000000000/derived /*.diff /*.log *.swp *~ *.suo *.sdf *.opensdf core.* core .cproject .project *.VC.db *.VC.VC.opendb .vscode/ __pycache__/ openMSX-RELEASE_17_0/Contrib/000077500000000000000000000000001405102155000156045ustar00rootroot00000000000000openMSX-RELEASE_17_0/Contrib/README000066400000000000000000000006421405102155000164660ustar00rootroot00000000000000About Contrib ============= This directory contains third-party software that is distributed together with openMSX. These packages are not part of openMSX: they are maintained and licensed separately. Please read the README. file and the documentation files of the contributed packages for details. We would like to thank the contributors for the software they created and for allowing us to distribute it. openMSX-RELEASE_17_0/Contrib/README.catch2000066400000000000000000000001351405102155000176260ustar00rootroot00000000000000Catch2 ====== Catch2 is a unit test framework for C++. https://github.com/catchorg/Catch2/ openMSX-RELEASE_17_0/Contrib/README.cbios000066400000000000000000000242141405102155000175650ustar00rootroot00000000000000C-BIOS 0.29 =========== This software is a substitute BIOS which is can be used for running MSX emulators. It currently supports only execution of cartridge image ("ROMs"). Before you use it, you should read and accept the license (see below). On the C-BIOS web site, you can download newer versions, download the source code, and report bugs. http://cbios.sourceforge.net/ License ------- Copyright (c) 2002-2005 BouKiCHi. All rights reserved. Copyright (c) 2003 Reikan. All rights reserved. Copyright (c) 2004-2006,2008-2010 Maarten ter Huurne. All rights reserved. Copyright (c) 2004-2006,2008-2011 Albert Beevendorp. All rights reserved. Copyright (c) 2004-2005 Patrick van Arkel. All rights reserved. Copyright (c) 2004,2010-2011 Manuel Bilderbeek. All rights reserved. Copyright (c) 2004-2006 Joost Yervante Damad. All rights reserved. Copyright (c) 2004-2006 Jussi Pitkänen. All rights reserved. Copyright (c) 2004-2007 Eric Boon. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. History ------- ver 0.01 Initial ver 0.02 2002-08-15(JST) * Added original font and drawing screen. * Added dump-mode. * Changed recognition method of cartridges to recognize cartridges taking priority. ver 0.03 2002-08-19(JST) * Based on a suggestion from Ms.Okei, wrote 20h of BIOS(compare HL and DE). In the result, shooting game of a certain company became runnable more correctly. Thank Ms.Okei!! ver 0.04 2002-08-20(JST) * Added initialize of FCC2h-FCC4h. * Added function of GTSTCK and GTTRIG temporarily. * Divided msxb.bin to halfs. doing combining/copying with setb.bat now. ver 0.05 2002-08-27(JST) * Added INITGRP(only screen2), CHGMOD(graphic mode change routine), a routine calls H.STKE. * Rewrite memory recognition routine. * Some bug fixes. * Added sound test function. ver 0.06 2002-09-01(JST) * Fixed around of color. ver 0.07 2002-09-09(JST) * Added some sorts of keyboard routines. * Added joystich function to GTSTCK and GTTRIG. ver 0.08 2002-09-12(JST) * Restructured memory initialize routine. * Added error display routine. * Fixed routine of finding kinds of cartridges. * Fixed using method of EXPTBL. * Added initialize of from RG8SAV to RG23SA. * Now return within disabled interrupt from ENASLT routine. ver 0.09 2002-09-19(JST) * Made the rest half of font. * Improved key input routine. * Added CHPUT. With it, rewrote display routine. * Fixed init_grp. * Changed filenames to CBIOS.ROM, CBIOS_SUB.ROM. ver 0.10 2002-09-20(JST) * Fixed indent. * and so on... ver 0.10a 2002-09-22(JST) * Fixed license. * Added support of ROMs in page3. ver 0.11 2002-09-22(JST) * Small fix in init_sc5. ver 0.12beta 2002-09-25(JST) * Added test routine for disk access. need DISK.ROM. * Added init_sc7. * Improved ENASLT. now finding cartridge uses ENASLT. * Improved RAM detection. ver 0.12 2002-09-27(JST) * Changed finding cartridge again. * Changed screen mode of cartridge running time. * Fixed keyboard routine. * Fixed stick routine against to interrupt. ver 0.13 2002-10-02(JST) * Based on info from Mr.Maarten (a member of openMSX developers), fixed around of SCREEN 5. For detail, switching line numbers, temporary treatment for a bug of reading from VDP status register, and so on. ver 0.14 2002-10-10(JST) * Rewrote comments in source within Japanese. ver 0.15 2003-02-26(JST) * Rewrote some of comments back to English again. * Fixed non-assemblable condition becauseof lack of font file. * Changed filename, some of label name, strings and so on. ver 0.16 2003-04-16(JST) * Separated sound test from source. (Disabled) ver 0.16a 2003-06-01(JST) * CHGMOD: When screen0/1, now load font to VRAM. * CHPUT: Now support also screen1 not only screen0. ver 0.16b 2003-08-10(JST) * Added entry: INITXT, INIT32. These were exist only as internal routine of CHGMOD. * INITXT, INIT32: Fixed screen clear failure. * CHPUT: Fixed scroll failure. ver 0.17 2003-08-10(JST) * Changed LICENSE. New LICENSE will be suitable in various situations. e.g. use as a firmware for hand-made hardware. ver 0.18 2004-12-18(CET) * First release since moving to SourceForge. * Much improved support for MSX2 games. * Graphical boot logo. * Included machine config files for several MSX emulators. * Various bug fixes. ver 0.19 2004-12-24(CET) * Added support for SCREEN4 and SCREEN8. * Added support for clock chip. * Added support for palette. This fixes a lot of wrong colours. * Stubbed many calls: non-implemented calls print their name on the openMSX debugdevice (if present). * Various bug fixes. ver 0.20 2005-02-09(CET) * Added an MSX2+ configuration, which includes V9958 and MSX MUSIC. * Separate main ROMs for MSX1/MSX2/MSX2+. * Implemented several MSX2 specific routines, including BLT*. * Display is disabled when switching to a different screen mode. * Improved CHPUT a lot; implemented control and escape codes. * Rewrote key buffering; fixes bug of keys being repeated. * New boot logo, even cooler than the previous one. * New font, placed at a fixed address so all games can find it. * Started work on a disk ROM, but it is not functional yet, so it is not enabled in the configurations. * Stubbed all non-implemented calls. * Various bug fixes. ver 0.21 2005-06-07(CET) * Fixed RuMSX configuration files, thanks to Rudolf Lechleitner. * Rewrote ROM search code; now all ROMs are recognized. Also a clear error message is printed for BASIC ROMs. * New boot logo for MSX2 and MSX2+. * Changed boot sequence: Show logo, switch to SCREEN 1 and search for ROMs. * Improved video code; fixes several games. * Various bug fixes. ver 0.22 2008-12-27(CET) * Use separate logo ROM to save space in the main ROM. * Set lower bits of PSG reg 15 before reading joystick trigger status. * Improved RAM search. * Many new routines implemented and existing implementations made more complete, especially character I/O and bitmap graphics. * Added lots of documentation to system variables. * Added support for GNU assembler. * Various bug fixes. ver 0.23 2009-01-04(CET) * Updated blueMSX configuration files, thanks to Benoît Delvaux. * Fixed version reported by MSX1 logo ROM. * Fixed several video routines so they work on MSX1 VDPs (TMS99xx). * A couple of other bug fixes. ver 0.24 2010-05-24(CET) * VRAM size is now properly checked, fixing R-Type's V9938 detection. * C-BIOS doesn't lie anymore about the interrupt frequency. * Don't di; halt when no ROM is found, the warning in openMSX may be confusing * A few minor bug fixes and tweaks. ver 0.25 2011-02-01(CET) * C-BIOS now offers localized versions in the flavours INT (default), JP and BR. * Bug fixes for compatibility with Mirai, Family Billiards. * A couple of other bug fixes. * This version only compiles with Pasmo 0.5.3, due to lack of standards in assembler directives... ver 0.26 2014-11-02(CET) * Restored support to compile with tniASM (v1.0 Beta 17 or higher) * Moved to git, which means a.o.: archived changelog.txt, use git log from now on * Fixed VDP VRAM access timing for MSX1 VDP's * Update openMSX configurations to the new structure * Fixed bug blueMSX configurations * Fixed build on Mac OS X and add support for "make dist" ver 0.27 2014-11-05(CET) * Fixed bug (regression) in filvrm on non-MSX1-VDP's * Fixed some small bugs in openMSX configs * Fixed line endings of this file ver 0.28 2017-07-30(CEST) * Fixed bug that prevented brackets and a few other keys from generating characters when pressed ver 0.29 2018-02-18(CET) * Removed NLMSX configs. We don't think anyone is interested anymore * Made generic international ROM config 60Hz and added an EU variant at 50Hz default interrupt frequency Special Thanks -------------- People uploading MSX information to the internet. People developing any kind of emulators. All users. Font edit tool: Gameboy Tile Designer version 2.2 Copyright H. Mulder 1999 openMSX-RELEASE_17_0/Contrib/README.omsxctl000066400000000000000000000017231405102155000201570ustar00rootroot00000000000000omsxctl -- execute openMSX commands from within an MSX program This is a combination of a Tcl script and a MSX-DOS utility. It allows to execute arbitrary openMSX console commands from within the MSX. Files: omsxctl.tcl The Tcl script. omsxctl.com The MSX-DOS utility. omsxctl.z80 The source code for the above utility (Z80 assembly code). The use this, pass the script on the openMSX command line: openmsx -script /omsxctl.tcl And then in MSX-DOS execute something like: omsxctl set save-settings_on_exit false omsxctl set throttle off omsxctl after time 10 "exit 1" ... omsxctl exit Check the script and utility source code more (technical) details. You can use this script/utility as-is. But as always, feel free to extend it for your specific needs. E.g. you might want to integrate this directly in your MSX program instead of using the omsxctl.com utility. Original idea by 'immetoo': https://github.com/openMSX/openMSX/issues/1133 openMSX-RELEASE_17_0/Contrib/README.openmsx-control000066400000000000000000000010561405102155000216340ustar00rootroot00000000000000openMSX Control Example ======================= Using the "-control" command line parameter, the openMSX process can be controlled from another process. The control protocol XML-based. In openmsx-control.cc you'll find an example client application which communicates with openMSX using the control protocol. Note: We try to keep the control protocol stable, but there is no hard guarantee it won't change in the next release. author: Wouter Vermaelen openmsx-control.cc is public domain, use it as you see fit. There is no warranty of any kind. openMSX-RELEASE_17_0/Contrib/base64.cc000066400000000000000000000043001405102155000171740ustar00rootroot00000000000000// compile with: // g++ -Wall -Os base64.cc -I ../src/utils/ ../src/utils/Base64.cc -lz -o encode-gz-base64 // g++ -Wall -Os base64.cc -I ../src/utils/ ../src/utils/Base64.cc -lz -o decode-gz-base64 #include "Base64.hh" #include #include #include #include #include #include #include using namespace std; string encode(const void* data, unsigned len) { uLongf dstLen = len + len / 1000 + 12 + 1; // worst-case vector buf(dstLen); if (compress2(buf.data(), &dstLen, reinterpret_cast(data), len, 9) != Z_OK) { cerr << "Error while compressing blob." << endl; exit(1); } return Base64::encode(buf.data(), dstLen); } string decode(const char* data, unsigned len) { static const unsigned MAX_SIZE = 1024 * 1024; // 1MB string tmp = Base64::decode(string(data, len)); vector buf(MAX_SIZE); uLongf dstLen = MAX_SIZE; if (uncompress(reinterpret_cast(buf.data()), &dstLen, reinterpret_cast(tmp.data()), uLong(tmp.size())) != Z_OK) { cerr << "Error while decompressing blob." << endl; exit(1); } return string(buf.data(), dstLen); } int main(int argc, char** argv) { if (argc != 3) { cerr << "Usage: " << argv[0] << " \n"; exit(1); } FILE* inf = fopen(argv[1], "rb"); if (!inf) { cerr << "Error while opening " << argv[1] << endl; exit(1); } struct stat st; fstat(fileno(inf), &st); size_t size = st.st_size; vector inBuf(size); if (fread(inBuf.data(), size, 1, inf) != 1) { cerr << "Error whle reading " << argv[1] << endl; exit(1); } string result; if (strstr(argv[0], "encode-gz-base64")) { result = encode(inBuf.data(), inBuf.size()); } else if (strstr(argv[0], "decode-gz-base64")) { result = decode(inBuf.data(), inBuf.size()); } else { cerr << "This executable should be named 'encode-gz-base64' or " "'decode-gz-base64'." << endl; exit(1); } FILE* outf = fopen(argv[2], "wb+"); if (!outf) { cerr << "Error while opening " << argv[2] << endl; exit(1); } if (fwrite(result.data(), result.size(), 1, outf) != 1) { cerr << "Error whle writing " << argv[2] << endl; exit(1); } } openMSX-RELEASE_17_0/Contrib/basictorom.tcl000066400000000000000000000041411405102155000204520ustar00rootroot00000000000000### basictorom.tcl ### # # This script was developed together with Daniel Vik to have an automated tool # to convert BASIC programs to ROM files. See this forum thread for more # details: # # http://www.msx.org/forumtopic9249.html # # To use it, put a file 'prog.bas' in the current directory (can be either in # ascii format or an already tokenized basic file). Then execute this script by # using the openMSX commandline. And after a few seconds the ROM image # 'prog.rom' will be generated. # # input: prog.bas # output prog.rom # start with: openmsx -script basictorom.tcl # # Note: This script only works on MSX machines that have a disk drive and have # MSX-BASIC built-in. So for example it won't work on the default C-bios # based machines. So either select a different MSX machine as your # default machine, or pass the '-machine ' as extra # option when starting openMSX. # proc do_stuff1 {} { # insert openMSX ramdisk in the MSX disk drive diska ramdsk # import host file to ramdisk diskmanipulator import diska "prog.bas" # change basic start address poke16 0xf676 0x8011 # add rom header poke 0x8000 0x41 poke 0x8001 0x42 poke16 0x8002 0x0000 poke16 0x8004 0x0000 poke16 0x8006 0x0000 poke16 0x8008 0x8010 poke16 0x800a 0x0000 poke16 0x800c 0x0000 poke16 0x800e 0x0000 poke 0x8010 0x00 # instruct MSX to load the BASIC program type "load\"prog.bas\"\r" # give MSX some time to process this # wait long enough so that even very long BASIC programs can be loaded after time 100 do_stuff2 } proc do_stuff2 {} { # save rom file set data [debug read_block "memory" 0x8000 0x4000] set file [open "prog.rom" "WRONLY CREAT TRUNC"] fconfigure $file -translation binary puts -nonewline $file $data close $file # exit emulator exit } # don't store the settings below for future openmsx sessions set save_settings_on_exit false # don't show MSX screen (remove if you want to see what's going on) set renderer none # go as fast as possible set throttle off # give emulated MSX some time to boot after time 20 do_stuff1 openMSX-RELEASE_17_0/Contrib/catch2/000077500000000000000000000000001405102155000167505ustar00rootroot00000000000000openMSX-RELEASE_17_0/Contrib/catch2/catch.LICENSE_1_0.txt000066400000000000000000000024721405102155000223200ustar00rootroot00000000000000Boost Software License - Version 1.0 - August 17th, 2003 Permission is hereby granted, free of charge, to any person or organization obtaining a copy of the software and accompanying documentation covered by this license (the "Software") to use, reproduce, display, distribute, execute, and transmit the Software, and to prepare derivative works of the Software, and to permit third-parties to whom the Software is furnished to do so, all subject to the following: The copyright notices in the Software and this entire statement, including the above license grant, this restriction and the following disclaimer, must be included in all copies of the Software, in whole or in part, and all derivative works of the Software, unless such copies or derivative works are solely in the form of machine-executable object code generated by a source language processor. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. openMSX-RELEASE_17_0/Contrib/catch2/catch.hpp000066400000000000000000022711361405102155000205570ustar00rootroot00000000000000/* * Catch v2.9.2 * Generated: 2019-08-08 13:35:12.279703 * ---------------------------------------------------------- * This file has been merged from multiple headers. Please don't edit it directly * Copyright (c) 2019 Two Blue Cubes Ltd. All rights reserved. * * Distributed under the Boost Software License, Version 1.0. (See accompanying * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) */ #ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED #define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED // start catch.hpp #define CATCH_VERSION_MAJOR 2 #define CATCH_VERSION_MINOR 9 #define CATCH_VERSION_PATCH 2 #ifdef __clang__ # pragma clang system_header #elif defined __GNUC__ # pragma GCC system_header #endif // start catch_suppress_warnings.h #ifdef __clang__ # ifdef __ICC // icpc defines the __clang__ macro # pragma warning(push) # pragma warning(disable: 161 1682) # else // __ICC # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wpadded" # pragma clang diagnostic ignored "-Wswitch-enum" # pragma clang diagnostic ignored "-Wcovered-switch-default" # endif #elif defined __GNUC__ // Because REQUIREs trigger GCC's -Wparentheses, and because still // supported version of g++ have only buggy support for _Pragmas, // Wparentheses have to be suppressed globally. # pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wunused-variable" # pragma GCC diagnostic ignored "-Wpadded" #endif // end catch_suppress_warnings.h #if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER) # define CATCH_IMPL # define CATCH_CONFIG_ALL_PARTS #endif // In the impl file, we want to have access to all parts of the headers // Can also be used to sanely support PCHs #if defined(CATCH_CONFIG_ALL_PARTS) # define CATCH_CONFIG_EXTERNAL_INTERFACES # if defined(CATCH_CONFIG_DISABLE_MATCHERS) # undef CATCH_CONFIG_DISABLE_MATCHERS # endif # if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER) # define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER # endif #endif #if !defined(CATCH_CONFIG_IMPL_ONLY) // start catch_platform.h #ifdef __APPLE__ # include # if TARGET_OS_OSX == 1 # define CATCH_PLATFORM_MAC # elif TARGET_OS_IPHONE == 1 # define CATCH_PLATFORM_IPHONE # endif #elif defined(linux) || defined(__linux) || defined(__linux__) # define CATCH_PLATFORM_LINUX #elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__) # define CATCH_PLATFORM_WINDOWS #endif // end catch_platform.h #ifdef CATCH_IMPL # ifndef CLARA_CONFIG_MAIN # define CLARA_CONFIG_MAIN_NOT_DEFINED # define CLARA_CONFIG_MAIN # endif #endif // start catch_user_interfaces.h namespace Catch { unsigned int rngSeed(); } // end catch_user_interfaces.h // start catch_tag_alias_autoregistrar.h // start catch_common.h // start catch_compiler_capabilities.h // Detect a number of compiler features - by compiler // The following features are defined: // // CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported? // CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported? // CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported? // CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled? // **************** // Note to maintainers: if new toggles are added please document them // in configuration.md, too // **************** // In general each macro has a _NO_ form // (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature. // Many features, at point of detection, define an _INTERNAL_ macro, so they // can be combined, en-mass, with the _NO_ forms later. #ifdef __cplusplus # if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L) # define CATCH_CPP14_OR_GREATER # endif # if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) # define CATCH_CPP17_OR_GREATER # endif #endif #if defined(CATCH_CPP17_OR_GREATER) # define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS #endif #ifdef __clang__ # define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ _Pragma( "clang diagnostic push" ) \ _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \ _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"") # define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \ _Pragma( "clang diagnostic pop" ) # define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \ _Pragma( "clang diagnostic push" ) \ _Pragma( "clang diagnostic ignored \"-Wparentheses\"" ) # define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \ _Pragma( "clang diagnostic pop" ) # define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \ _Pragma( "clang diagnostic push" ) \ _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" ) # define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS \ _Pragma( "clang diagnostic pop" ) # define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \ _Pragma( "clang diagnostic push" ) \ _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" ) # define CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS \ _Pragma( "clang diagnostic pop" ) #endif // __clang__ //////////////////////////////////////////////////////////////////////////////// // Assume that non-Windows platforms support posix signals by default #if !defined(CATCH_PLATFORM_WINDOWS) #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS #endif //////////////////////////////////////////////////////////////////////////////// // We know some environments not to support full POSIX signals #if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__) #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS #endif #ifdef __OS400__ # define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS # define CATCH_CONFIG_COLOUR_NONE #endif //////////////////////////////////////////////////////////////////////////////// // Android somehow still does not support std::to_string #if defined(__ANDROID__) # define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING #endif //////////////////////////////////////////////////////////////////////////////// // Not all Windows environments support SEH properly #if defined(__MINGW32__) # define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH #endif //////////////////////////////////////////////////////////////////////////////// // PS4 #if defined(__ORBIS__) # define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE #endif //////////////////////////////////////////////////////////////////////////////// // Cygwin #ifdef __CYGWIN__ // Required for some versions of Cygwin to declare gettimeofday // see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin # define _BSD_SOURCE // some versions of cygwin (most) do not support std::to_string. Use the libstd check. // https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813 # if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \ && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF)) # define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING # endif #endif // __CYGWIN__ //////////////////////////////////////////////////////////////////////////////// // Visual C++ #ifdef _MSC_VER # if _MSC_VER >= 1900 // Visual Studio 2015 or newer # define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS # endif // Universal Windows platform does not support SEH // Or console colours (or console at all...) # if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP) # define CATCH_CONFIG_COLOUR_NONE # else # define CATCH_INTERNAL_CONFIG_WINDOWS_SEH # endif // MSVC traditional preprocessor needs some workaround for __VA_ARGS__ // _MSVC_TRADITIONAL == 0 means new conformant preprocessor // _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor # if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL) # define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR # endif #endif // _MSC_VER #if defined(_REENTRANT) || defined(_MSC_VER) // Enable async processing, as -pthread is specified or no additional linking is required # define CATCH_INTERNAL_CONFIG_USE_ASYNC #endif // _MSC_VER //////////////////////////////////////////////////////////////////////////////// // Check if we are compiled with -fno-exceptions or equivalent #if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND) # define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED #endif //////////////////////////////////////////////////////////////////////////////// // DJGPP #ifdef __DJGPP__ # define CATCH_INTERNAL_CONFIG_NO_WCHAR #endif // __DJGPP__ //////////////////////////////////////////////////////////////////////////////// // Embarcadero C++Build #if defined(__BORLANDC__) #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN #endif //////////////////////////////////////////////////////////////////////////////// // Use of __COUNTER__ is suppressed during code analysis in // CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly // handled by it. // Otherwise all supported compilers support COUNTER macro, // but user still might want to turn it off #if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L ) #define CATCH_INTERNAL_CONFIG_COUNTER #endif //////////////////////////////////////////////////////////////////////////////// // RTX is a special version of Windows that is real time. // This means that it is detected as Windows, but does not provide // the same set of capabilities as real Windows does. #if defined(UNDER_RTSS) || defined(RTX64_BUILD) #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH #define CATCH_INTERNAL_CONFIG_NO_ASYNC #define CATCH_CONFIG_COLOUR_NONE #endif //////////////////////////////////////////////////////////////////////////////// // Check if string_view is available and usable // The check is split apart to work around v140 (VS2015) preprocessor issue... #if defined(__has_include) #if __has_include() && defined(CATCH_CPP17_OR_GREATER) # define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW #endif #endif //////////////////////////////////////////////////////////////////////////////// // Check if optional is available and usable #if defined(__has_include) # if __has_include() && defined(CATCH_CPP17_OR_GREATER) # define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) #endif // __has_include //////////////////////////////////////////////////////////////////////////////// // Check if byte is available and usable #if defined(__has_include) # if __has_include() && defined(CATCH_CPP17_OR_GREATER) # define CATCH_INTERNAL_CONFIG_CPP17_BYTE # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) #endif // __has_include //////////////////////////////////////////////////////////////////////////////// // Check if variant is available and usable #if defined(__has_include) # if __has_include() && defined(CATCH_CPP17_OR_GREATER) # if defined(__clang__) && (__clang_major__ < 8) // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852 // fix should be in clang 8, workaround in libstdc++ 8.2 # include # if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9) # define CATCH_CONFIG_NO_CPP17_VARIANT # else # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT # endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9) # else # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT # endif // defined(__clang__) && (__clang_major__ < 8) # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) #endif // __has_include #if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER) # define CATCH_CONFIG_COUNTER #endif #if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH) # define CATCH_CONFIG_WINDOWS_SEH #endif // This is set by default, because we assume that unix compilers are posix-signal-compatible by default. #if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS) # define CATCH_CONFIG_POSIX_SIGNALS #endif // This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions. #if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR) # define CATCH_CONFIG_WCHAR #endif #if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING) # define CATCH_CONFIG_CPP11_TO_STRING #endif #if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL) # define CATCH_CONFIG_CPP17_OPTIONAL #endif #if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) # define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS #endif #if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW) # define CATCH_CONFIG_CPP17_STRING_VIEW #endif #if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT) # define CATCH_CONFIG_CPP17_VARIANT #endif #if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE) # define CATCH_CONFIG_CPP17_BYTE #endif #if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT) # define CATCH_INTERNAL_CONFIG_NEW_CAPTURE #endif #if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE) # define CATCH_CONFIG_NEW_CAPTURE #endif #if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) # define CATCH_CONFIG_DISABLE_EXCEPTIONS #endif #if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN) # define CATCH_CONFIG_POLYFILL_ISNAN #endif #if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC) && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC) # define CATCH_CONFIG_USE_ASYNC #endif #if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) # define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS # define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS #endif #if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS) # define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS # define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS #endif #if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS) # define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS # define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS #endif #if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS) # define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS # define CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS #endif #if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) #define CATCH_TRY if ((true)) #define CATCH_CATCH_ALL if ((false)) #define CATCH_CATCH_ANON(type) if ((false)) #else #define CATCH_TRY try #define CATCH_CATCH_ALL catch (...) #define CATCH_CATCH_ANON(type) catch (type) #endif #if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) #define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR #endif // end catch_compiler_capabilities.h #define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line #define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) #ifdef CATCH_CONFIG_COUNTER # define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ ) #else # define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ ) #endif #include #include #include // We need a dummy global operator<< so we can bring it into Catch namespace later struct Catch_global_namespace_dummy {}; std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy); namespace Catch { struct CaseSensitive { enum Choice { Yes, No }; }; class NonCopyable { NonCopyable( NonCopyable const& ) = delete; NonCopyable( NonCopyable && ) = delete; NonCopyable& operator = ( NonCopyable const& ) = delete; NonCopyable& operator = ( NonCopyable && ) = delete; protected: NonCopyable(); virtual ~NonCopyable(); }; struct SourceLineInfo { SourceLineInfo() = delete; SourceLineInfo( char const* _file, std::size_t _line ) noexcept : file( _file ), line( _line ) {} SourceLineInfo( SourceLineInfo const& other ) = default; SourceLineInfo& operator = ( SourceLineInfo const& ) = default; SourceLineInfo( SourceLineInfo&& ) noexcept = default; SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default; bool empty() const noexcept; bool operator == ( SourceLineInfo const& other ) const noexcept; bool operator < ( SourceLineInfo const& other ) const noexcept; char const* file; std::size_t line; }; std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ); // Bring in operator<< from global namespace into Catch namespace // This is necessary because the overload of operator<< above makes // lookup stop at namespace Catch using ::operator<<; // Use this in variadic streaming macros to allow // >> +StreamEndStop // as well as // >> stuff +StreamEndStop struct StreamEndStop { std::string operator+() const; }; template T const& operator + ( T const& value, StreamEndStop ) { return value; } } #define CATCH_INTERNAL_LINEINFO \ ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) ) // end catch_common.h namespace Catch { struct RegistrarForTagAliases { RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ); }; } // end namespace Catch #define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \ CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS // end catch_tag_alias_autoregistrar.h // start catch_test_registry.h // start catch_interfaces_testcase.h #include namespace Catch { class TestSpec; struct ITestInvoker { virtual void invoke () const = 0; virtual ~ITestInvoker(); }; class TestCase; struct IConfig; struct ITestCaseRegistry { virtual ~ITestCaseRegistry(); virtual std::vector const& getAllTests() const = 0; virtual std::vector const& getAllTestsSorted( IConfig const& config ) const = 0; }; bool isThrowSafe( TestCase const& testCase, IConfig const& config ); bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ); std::vector filterTests( std::vector const& testCases, TestSpec const& testSpec, IConfig const& config ); std::vector const& getAllTestCasesSorted( IConfig const& config ); } // end catch_interfaces_testcase.h // start catch_stringref.h #include #include #include namespace Catch { /// A non-owning string class (similar to the forthcoming std::string_view) /// Note that, because a StringRef may be a substring of another string, /// it may not be null terminated. c_str() must return a null terminated /// string, however, and so the StringRef will internally take ownership /// (taking a copy), if necessary. In theory this ownership is not externally /// visible - but it does mean (substring) StringRefs should not be shared between /// threads. class StringRef { public: using size_type = std::size_t; private: friend struct StringRefTestAccess; char const* m_start; size_type m_size; char* m_data = nullptr; void takeOwnership(); static constexpr char const* const s_empty = ""; public: // construction/ assignment StringRef() noexcept : StringRef( s_empty, 0 ) {} StringRef( StringRef const& other ) noexcept : m_start( other.m_start ), m_size( other.m_size ) {} StringRef( StringRef&& other ) noexcept : m_start( other.m_start ), m_size( other.m_size ), m_data( other.m_data ) { other.m_data = nullptr; } StringRef( char const* rawChars ) noexcept; StringRef( char const* rawChars, size_type size ) noexcept : m_start( rawChars ), m_size( size ) {} StringRef( std::string const& stdString ) noexcept : m_start( stdString.c_str() ), m_size( stdString.size() ) {} ~StringRef() noexcept { delete[] m_data; } auto operator = ( StringRef const &other ) noexcept -> StringRef& { delete[] m_data; m_data = nullptr; m_start = other.m_start; m_size = other.m_size; return *this; } operator std::string() const; void swap( StringRef& other ) noexcept; public: // operators auto operator == ( StringRef const& other ) const noexcept -> bool; auto operator != ( StringRef const& other ) const noexcept -> bool; auto operator[] ( size_type index ) const noexcept -> char; public: // named queries auto empty() const noexcept -> bool { return m_size == 0; } auto size() const noexcept -> size_type { return m_size; } auto numberOfCharacters() const noexcept -> size_type; auto c_str() const -> char const*; public: // substrings and searches auto substr( size_type start, size_type size ) const noexcept -> StringRef; // Returns the current start pointer. // Note that the pointer can change when if the StringRef is a substring auto currentData() const noexcept -> char const*; private: // ownership queries - may not be consistent between calls auto isOwned() const noexcept -> bool; auto isSubstring() const noexcept -> bool; }; auto operator + ( StringRef const& lhs, StringRef const& rhs ) -> std::string; auto operator + ( StringRef const& lhs, char const* rhs ) -> std::string; auto operator + ( char const* lhs, StringRef const& rhs ) -> std::string; auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&; auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&; inline auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef { return StringRef( rawChars, size ); } } // namespace Catch inline auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef { return Catch::StringRef( rawChars, size ); } // end catch_stringref.h // start catch_type_traits.hpp #include namespace Catch{ #ifdef CATCH_CPP17_OR_GREATER template inline constexpr auto is_unique = std::true_type{}; template inline constexpr auto is_unique = std::bool_constant< (!std::is_same_v && ...) && is_unique >{}; #else template struct is_unique : std::true_type{}; template struct is_unique : std::integral_constant ::value && is_unique::value && is_unique::value >{}; #endif } // end catch_type_traits.hpp // start catch_preprocessor.hpp #define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__ #define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__))) #define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__))) #define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__))) #define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__))) #define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__))) #ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR #define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__ // MSVC needs more evaluations #define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__))) #define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__)) #else #define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL5(__VA_ARGS__) #endif #define CATCH_REC_END(...) #define CATCH_REC_OUT #define CATCH_EMPTY() #define CATCH_DEFER(id) id CATCH_EMPTY() #define CATCH_REC_GET_END2() 0, CATCH_REC_END #define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2 #define CATCH_REC_GET_END(...) CATCH_REC_GET_END1 #define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT #define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0) #define CATCH_REC_NEXT(test, next) CATCH_REC_NEXT1(CATCH_REC_GET_END test, next) #define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ ) #define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ ) #define CATCH_REC_LIST2(f, x, peek, ...) f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ ) #define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ ) #define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ ) #define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...) f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ ) // Applies the function macro `f` to each of the remaining parameters, inserts commas between the results, // and passes userdata as the first parameter to each invocation, // e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c) #define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0)) #define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0)) #define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param) #define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__ #define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__ #define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF #define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__) #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR #define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__ #define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) #else // MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF #define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__) #define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__ #define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1) #endif #define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__ #define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name) #define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__) #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR #define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper()) #define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)) #else #define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper())) #define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))) #endif #define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\ CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__) #define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0) #define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1) #define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2) #define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3) #define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4) #define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5) #define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _4, _5, _6) #define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7) #define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8) #define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9) #define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) #define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N #define INTERNAL_CATCH_TYPE_GEN\ template struct TypeList {};\ template\ constexpr auto get_wrapper() noexcept -> TypeList { return {}; }\ \ template class L1, typename...E1, template class L2, typename...E2> \ constexpr auto append(L1, L2) noexcept -> L1 { return {}; }\ template< template class L1, typename...E1, template class L2, typename...E2, typename...Rest>\ constexpr auto append(L1, L2, Rest...) noexcept -> decltype(append(L1{}, Rest{}...)) { return {}; }\ template< template class L1, typename...E1, typename...Rest>\ constexpr auto append(L1, TypeList, Rest...) noexcept -> L1 { return {}; }\ \ template< template class Container, template class List, typename...elems>\ constexpr auto rewrap(List) noexcept -> TypeList> { return {}; }\ template< template class Container, template class List, class...Elems, typename...Elements>\ constexpr auto rewrap(List,Elements...) noexcept -> decltype(append(TypeList>{}, rewrap(Elements{}...))) { return {}; }\ \ template