pax_global_header 0000666 0000000 0000000 00000000064 15231600053 0014505 g ustar 00root root 0000000 0000000 52 comment=8305b6066a2305693806709f87139e1277ef1f63
atari800-7.1.2/ 0000775 0000000 0000000 00000000000 15231600053 0013044 5 ustar 00root root 0000000 0000000 atari800-7.1.2/.github/ 0000775 0000000 0000000 00000000000 15231600053 0014404 5 ustar 00root root 0000000 0000000 atari800-7.1.2/.github/workflows/ 0000775 0000000 0000000 00000000000 15231600053 0016441 5 ustar 00root root 0000000 0000000 atari800-7.1.2/.github/workflows/build.yml 0000664 0000000 0000000 00000052200 15231600053 0020262 0 ustar 00root root 0000000 0000000 name: Build CI
on:
workflow_dispatch:
inputs:
version:
description: 'Version for installer (e.g. 6.1.0). Empty = skip.'
required: false
type: string
push:
branches: [ "master" ]
tags:
- 'ATARI800_*_*_*'
pull_request:
jobs:
build-amd64:
name: Build on Linux amd64
runs-on: ubuntu-24.04
container:
image: debian:trixie
steps:
- uses: actions/checkout@v7
- name: install depends
run: |
apt-get update
apt-get install -y build-essential autoconf automake libtool pkg-config \
libsdl2-dev libmp3lame-dev libreadline-dev libgl1-mesa-dev libpng-dev libcurl4-openssl-dev curl ca-certificates git gh
- name: autogen
run: ./autogen.sh
- name: configure
run: ./configure --with-opengl --with-readline --with-mp3=lame --with-video=sdl2 --with-sound=sdl2
- name: building
run: make -j4
- name: Archive Atari800 binary
uses: actions/upload-artifact@v7
with:
name: atari800-linux-amd64
path: src/atari800
- name: Build AppImage
if: startsWith(github.ref, 'refs/tags/ATARI800_') || inputs.version != ''
run: |
if [ -n "${{ inputs.version }}" ]; then
V=${{ inputs.version }}
else
V=${GITHUB_REF_NAME#ATARI800_}
V=$(echo "$V" | sed 's/_/./g')
fi
echo "VERSION=$V" >> $GITHUB_ENV
APPDIR="/tmp/Atari800-${V}.AppDir"
mkdir -p "$APPDIR/usr/bin" \
"$APPDIR/usr/share/applications" \
"$APPDIR/usr/share/icons/hicolor/128x128/apps" \
"$APPDIR/usr/share/icons/hicolor/scalable/apps"
cp src/atari800 "$APPDIR/usr/bin/"
cp debian/atari800.desktop "$APPDIR/usr/share/applications/"
cp data/atari1.png "$APPDIR/usr/share/icons/hicolor/128x128/apps/atari800.png"
cp data/atari2.svg "$APPDIR/usr/share/icons/hicolor/scalable/apps/atari800.svg"
ln -s usr/share/applications/atari800.desktop "$APPDIR/"
ln -s usr/share/icons/hicolor/128x128/apps/atari800.png "$APPDIR/atari800.png"
echo '#!/bin/sh' > "$APPDIR/AppRun"
echo 'HERE="$(dirname "$(readlink -f "$0")")"' >> "$APPDIR/AppRun"
echo 'export LD_LIBRARY_PATH="$HERE/usr/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"' >> "$APPDIR/AppRun"
echo 'exec "$HERE/usr/bin/atari800" "$@"' >> "$APPDIR/AppRun"
chmod +x "$APPDIR/AppRun"
curl -sL "https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage" \
-o /tmp/linuxdeploy
chmod +x /tmp/linuxdeploy
APPIMAGE_EXTRACT_AND_RUN=1 /tmp/linuxdeploy --appdir "$APPDIR"
# Find and bundle any missing transitive dependencies
for f in "$APPDIR/usr/bin/atari800" $(find "$APPDIR/usr/lib" -name '*.so*' -type f 2>/dev/null); do
ldd "$f" 2>/dev/null | grep -E '=> /' | awk '{print $3}' | while read -r dep; do
depname=$(basename "$dep")
if [ ! -f "$APPDIR/usr/lib/$depname" ] && [ ! -L "$APPDIR/usr/lib/$depname" ]; then
case "$depname" in
libc.so.*|libdl.so.*|libm.so.*|libpthread.so.*|librt.so.*|libresolv.so.*|libutil.so.*|libnss*|libnsl.so.*|libcrypt.so.*|ld-linux*)
;;
*)
cp -L "$dep" "$APPDIR/usr/lib/"
echo "Bundled missing dep: $depname"
;;
esac
fi
done
done
# Remove GPU driver libraries to avoid version conflicts with host system Mesa/libdrm
rm -f "$APPDIR"/usr/lib/libdrm*.so.* "$APPDIR"/usr/lib/libgbm*.so.* "$APPDIR"/usr/lib/libgallium*.so.* \
"$APPDIR"/usr/lib/libGL.so.* "$APPDIR"/usr/lib/libGLX.so.* "$APPDIR"/usr/lib/libEGL.so.* "$APPDIR"/usr/lib/libGLdispatch.so.* 2>/dev/null || true
curl -sL "https://github.com/AppImage/type2-runtime/releases/download/continuous/runtime-x86_64" \
-o /tmp/runtime-x86_64
curl -sL "https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage" \
-o /tmp/appimagetool
chmod +x /tmp/appimagetool
APPIMAGE_EXTRACT_AND_RUN=1 /tmp/appimagetool --runtime-file /tmp/runtime-x86_64 "$APPDIR" "Atari800-${V}-x86_64.AppImage"
- name: Upload AppImage
if: startsWith(github.ref, 'refs/tags/ATARI800_') || inputs.version != ''
uses: actions/upload-artifact@v7
with:
name: atari800-linux-appimage
path: Atari800-*.AppImage
- name: Attach to release
if: startsWith(github.ref, 'refs/tags/ATARI800_')
env:
GH_TOKEN: ${{ github.token }}
run: |
gh release create "$GITHUB_REF_NAME" --repo ${{ github.repository }} 2>/dev/null || true
gh release upload "$GITHUB_REF_NAME" Atari800-*-x86_64.AppImage --clobber --repo ${{ github.repository }}
build-linux-i386:
if: startsWith(github.ref, 'refs/tags/ATARI800_') || inputs.version != ''
name: Build on Linux i386
runs-on: ubuntu-24.04
steps:
- uses: actions/checkout@v7
- name: Build and package in 32-bit Debian container
run: |
if [ -n "${{ inputs.version }}" ]; then
V=${{ inputs.version }}
else
V=${GITHUB_REF_NAME#ATARI800_}
V=$(echo "$V" | sed 's/_/./g')
fi
docker run --platform=linux/386 --rm \
-v ${{ github.workspace }}:/workspace \
-w /workspace \
-e V="$V" \
debian:trixie \
bash -c "
set -e
apt-get update
apt-get install -y build-essential autoconf automake libtool pkg-config \
libsdl2-dev libmp3lame-dev libreadline-dev libpng-dev libcurl4-openssl-dev curl ca-certificates
./autogen.sh
./configure --with-video=sdl2 --with-sound=sdl2 --with-mp3=lame
make -j\$(nproc)
APPDIR=\"/tmp/Atari800-\${V}.AppDir\"
mkdir -p \"\$APPDIR/usr/bin\" \
\"\$APPDIR/usr/share/applications\" \
\"\$APPDIR/usr/share/icons/hicolor/128x128/apps\" \
\"\$APPDIR/usr/share/icons/hicolor/scalable/apps\"
cp src/atari800 \"\$APPDIR/usr/bin/\"
cp debian/atari800.desktop \"\$APPDIR/usr/share/applications/\"
cp data/atari1.png \"\$APPDIR/usr/share/icons/hicolor/128x128/apps/atari800.png\"
cp data/atari2.svg \"\$APPDIR/usr/share/icons/hicolor/scalable/apps/atari800.svg\"
ln -s usr/share/applications/atari800.desktop \"\$APPDIR/\"
ln -s usr/share/icons/hicolor/128x128/apps/atari800.png \"\$APPDIR/atari800.png\"
echo '#!/bin/sh' > \"\$APPDIR/AppRun\"
echo 'HERE=\"\$(dirname \"\$(readlink -f \"\$0\")\")\"' >> \"\$APPDIR/AppRun\"
echo 'export LD_LIBRARY_PATH=\"\$HERE/usr/lib\${LD_LIBRARY_PATH:+:\$LD_LIBRARY_PATH}\"' >> \"\$APPDIR/AppRun\"
echo 'exec \"\$HERE/usr/bin/atari800\" \"\$@\"' >> \"\$APPDIR/AppRun\"
chmod +x \"\$APPDIR/AppRun\"
curl -sL \"https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-i386.AppImage\" \
-o /tmp/linuxdeploy
chmod +x /tmp/linuxdeploy
APPIMAGE_EXTRACT_AND_RUN=1 /tmp/linuxdeploy --appdir \"\$APPDIR\"
# Find and bundle any missing transitive dependencies
for f in \"\$APPDIR/usr/bin/atari800\" \$(find \"\$APPDIR/usr/lib\" -name '*.so*' -type f 2>/dev/null); do
ldd \"\$f\" 2>/dev/null | grep -E '=> /' | awk '{print \$3}' | while read -r dep; do
depname=\$(basename \"\$dep\")
if [ ! -f \"\$APPDIR/usr/lib/\$depname\" ] && [ ! -L \"\$APPDIR/usr/lib/\$depname\" ]; then
case \"\$depname\" in
libc.so.*|libdl.so.*|libm.so.*|libpthread.so.*|librt.so.*|libresolv.so.*|libutil.so.*|libnss*|libnsl.so.*|libcrypt.so.*|ld-linux*)
;;
*)
cp -L \"\$dep\" \"\$APPDIR/usr/lib/\"
echo \"Bundled missing dep: \$depname\"
;;
esac
fi
done
done
# Remove GPU driver libraries to avoid version conflicts with host system Mesa/libdrm
rm -f \"\$APPDIR\"/usr/lib/libdrm*.so.* \"\$APPDIR\"/usr/lib/libgbm*.so.* \"\$APPDIR\"/usr/lib/libgallium*.so.* \
\"\$APPDIR\"/usr/lib/libGL.so.* \"\$APPDIR\"/usr/lib/libGLX.so.* \"\$APPDIR\"/usr/lib/libEGL.so.* \"\$APPDIR\"/usr/lib/libGLdispatch.so.* 2>/dev/null || true
curl -sL \"https://github.com/AppImage/type2-runtime/releases/download/continuous/runtime-i686\" \
-o /tmp/runtime-i686
curl -sL \"https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-i686.AppImage\" \
-o /tmp/appimagetool
chmod +x /tmp/appimagetool
APPIMAGE_EXTRACT_AND_RUN=1 /tmp/appimagetool --runtime-file /tmp/runtime-i686 \"\$APPDIR\" \"Atari800-\${V}-i386.AppImage\"
"
- name: Upload AppImage
uses: actions/upload-artifact@v7
with:
name: atari800-linux-i386-appimage
path: Atari800-*.AppImage
- name: Attach to release
if: startsWith(github.ref, 'refs/tags/ATARI800_')
env:
GH_TOKEN: ${{ github.token }}
run: |
gh release create "$GITHUB_REF_NAME" 2>/dev/null || true
gh release upload "$GITHUB_REF_NAME" Atari800-*-i386.AppImage --clobber
build-macos:
name: Build on MacOS (arm64)
runs-on: macos-14
steps:
- uses: actions/checkout@v7
- name: install depends
env:
HOMEBREW_REQUIRE_TAP_TRUST: 0
run: brew install sdl2 automake readline dylibbundler
- name: autogen
run: ./autogen.sh
- name: configure
run: ./configure --with-opengl --with-video=sdl2 --with-sound=sdl2
- name: building
run: make -j4
- name: Package .dmg
if: startsWith(github.ref, 'refs/tags/ATARI800_') || inputs.version != ''
run: |
if [ -n "${{ inputs.version }}" ]; then
V=${{ inputs.version }}
else
V=${GITHUB_REF_NAME#ATARI800_}
V=$(echo "$V" | sed 's/_/./g')
fi
echo "VERSION=$V" >> $GITHUB_ENV
APP="Atari800.app"
mkdir -p "$APP/Contents/MacOS" "$APP/Contents/Resources" "$APP/Contents/lib"
cp src/atari800 "$APP/Contents/MacOS/"
dylibbundler -od -b -x "$APP/Contents/MacOS/atari800" \
-d "$APP/Contents/lib/" -p @executable_path/../lib/
cp README.TXT "$APP/Contents/Resources/"
cp COPYING "$APP/Contents/Resources/"
cp DOC/USAGE "$APP/Contents/Resources/"
cp DOC/INSTALL "$APP/Contents/Resources/"
cp DOC/NEWS "$APP/Contents/Resources/"
mkdir -p "$APP/Contents/Resources/act"
cp act/*.act "$APP/Contents/Resources/act/"
mkdir -p Atari800.iconset
for size in 16 32 48 128 256 512; do
sips -z $size $size data/atari1.png \
--out "Atari800.iconset/icon_${size}x${size}.png" >/dev/null 2>&1
done
sips -z 32 32 data/atari1.png \
--out Atari800.iconset/icon_16x16@2x.png >/dev/null 2>&1
sips -z 64 64 data/atari1.png \
--out Atari800.iconset/icon_32x32@2x.png >/dev/null 2>&1
sips -z 256 256 data/atari1.png \
--out Atari800.iconset/icon_128x128@2x.png >/dev/null 2>&1
sips -z 512 512 data/atari1.png \
--out Atari800.iconset/icon_256x256@2x.png >/dev/null 2>&1
iconutil -c icns Atari800.iconset
cp Atari800.icns "$APP/Contents/Resources/"
{
echo ''
echo ''
echo ''
echo ''
echo ' CFBundleDevelopmentRegion'
echo ' English'
echo ' CFBundleExecutable'
echo ' atari800'
echo ' CFBundleIconFile'
echo ' Atari800'
echo ' CFBundleIdentifier'
echo ' org.atari800.atari800'
echo ' CFBundleInfoDictionaryVersion'
echo ' 6.0'
echo ' CFBundleName'
echo ' Atari800'
echo ' CFBundlePackageType'
echo ' APPL'
echo ' CFBundleShortVersionString'
echo " ${V}"
echo ' CFBundleVersion'
echo " ${V}"
echo ' NSHighResolutionCapable'
echo ' '
echo ''
echo ''
} > "$APP/Contents/Info.plist"
codesign --deep --force --verify=strict --sign - "$APP" 2>/dev/null || true
hdiutil create -volname "Atari800 ${V}" -srcfolder "$APP" \
-ov -format UDZO "Atari800-${V}-macos-arm64.dmg"
- name: Upload DMG
if: startsWith(github.ref, 'refs/tags/ATARI800_') || inputs.version != ''
uses: actions/upload-artifact@v7
with:
name: atari800-macos-arm64-dmg
path: Atari800-*.dmg
- name: Attach to release
if: startsWith(github.ref, 'refs/tags/ATARI800_')
env:
GH_TOKEN: ${{ github.token }}
run: |
gh release create "$GITHUB_REF_NAME" 2>/dev/null || true
gh release upload "$GITHUB_REF_NAME" Atari800-*-macos-arm64.dmg --clobber
- name: Archive Atari800 binary
uses: actions/upload-artifact@v7
with:
name: atari800-macos-arm64
path: src/atari800
build-windows-msys2:
name: Build on Windows MSYS2
runs-on: windows-latest
defaults:
run:
shell: msys2 {0}
steps:
- name: Checkout repository
uses: actions/checkout@v7
- name: Setup MSYS2
uses: msys2/setup-msys2@v2
with:
msystem: MINGW64
update: true
install: >-
git
base-devel
mingw-w64-x86_64-toolchain
autoconf
automake
libtool
mingw-w64-x86_64-SDL2
mingw-w64-x86_64-readline
mingw-w64-x86_64-libpng
mingw-w64-x86_64-nsis
mingw-w64-x86_64-lame
mingw-w64-x86_64-curl-winssl
zip
- name: Run autoreconf
run: autoreconf -fiv
- name: Configure project
run: ./configure --with-video=sdl2 --with-sound=sdl2 --with-mp3=lame
- name: Build project
run: make -j$(nproc)
- name: Verify build
run: |
if [ ! -f src/atari800.exe ]; then
echo "Build failed"
exit 1
fi
echo "Build succeeded"
- name: Embed app icon
if: startsWith(github.ref, 'refs/tags/ATARI800_') || inputs.version != ''
run: |
cd src
windres --include-dir .. -i atari800_res.rc -o atari800_res_icon.o
rm -f atari800.exe
make atari800.exe atari800_LDADD="atari800_res_icon.o"
- name: Archive plain binary
uses: actions/upload-artifact@v7
with:
name: atari800-windows-msys2
path: src/atari800.exe
- name: Stage files and build installer
if: startsWith(github.ref, 'refs/tags/ATARI800_') || inputs.version != ''
shell: msys2 {0}
run: |
if [ -n "${{ inputs.version }}" ]; then
V=${{ inputs.version }}
else
V=${GITHUB_REF_NAME#ATARI800_}
V=$(echo "$V" | sed 's/_/./g')
fi
echo "VERSION=$V" >> $GITHUB_ENV
mkdir -p pkg/act pkg/doc
cp src/atari800.exe pkg/
ldd src/atari800.exe | grep '\/mingw64\/bin\/' | \
awk '{print $3}' | xargs -I{} cp {} pkg/
cp README.TXT pkg/
cp act/*.act pkg/act/
cp data/atari800.ico pkg/
cp COPYING pkg/doc/COPYING.txt
cp DOC/INSTALL pkg/doc/INSTALL.txt
cp DOC/NEWS pkg/doc/NEWS.txt
cp DOC/USAGE pkg/doc/USAGE.txt
makensis -DVERSION=$V -DPLATFORM=win64 atari800.nsi
(cd pkg && zip -r "../atari800-${V}-win64.zip" .)
- name: Verify installer
if: startsWith(github.ref, 'refs/tags/ATARI800_') || inputs.version != ''
shell: msys2 {0}
run: |
if [ -n "${{ inputs.version }}" ]; then
V=${{ inputs.version }}
else
V=${GITHUB_REF_NAME#ATARI800_}
V=$(echo "$V" | sed 's/_/./g')
fi
test -f atari800-$V-win64.zip && echo "Installer OK: atari800-$V-win64.zip"
- name: Archive portable zip
if: startsWith(github.ref, 'refs/tags/ATARI800_') || inputs.version != ''
uses: actions/upload-artifact@v7
with:
name: atari800-${{ env.VERSION }}-win64-portable
path: atari800-*-win64.zip
- name: Archive installer exe
if: startsWith(github.ref, 'refs/tags/ATARI800_') || inputs.version != ''
uses: actions/upload-artifact@v7
with:
name: atari800-${{ env.VERSION }}-win64-installer
path: atari800-*-win64.exe
- name: Attach to release
if: startsWith(github.ref, 'refs/tags/ATARI800_')
shell: bash
env:
GH_TOKEN: ${{ github.token }}
run: |
gh release create "$GITHUB_REF_NAME" 2>/dev/null || true
gh release upload "$GITHUB_REF_NAME" atari800-*-win64.exe atari800-*-win64.zip --clobber
build-windows-msys2-32:
if: startsWith(github.ref, 'refs/tags/ATARI800_') || inputs.version != ''
name: Build on Windows MSYS2 (32-bit)
runs-on: windows-latest
defaults:
run:
shell: msys2 {0}
steps:
- uses: actions/checkout@v7
- name: Setup MSYS2
uses: msys2/setup-msys2@v2
with:
msystem: MINGW32
update: true
install: >-
git
base-devel
mingw-w64-i686-toolchain
autoconf automake libtool
mingw-w64-i686-SDL2
mingw-w64-i686-readline
mingw-w64-i686-libpng
mingw-w64-i686-nsis
mingw-w64-i686-lame
zip
- name: Run autoreconf
run: autoreconf -fiv
- name: Configure project
run: ./configure --with-video=sdl2 --with-sound=sdl2 --with-mp3=lame --disable-download
- name: Build project
run: make -j$(nproc)
- name: Verify build
run: |
test -f src/atari800.exe && echo "Build succeeded"
- name: Embed app icon
run: |
cd src
windres --include-dir .. -i atari800_res.rc -o atari800_res_icon.o
rm -f atari800.exe
make atari800.exe atari800_LDADD="atari800_res_icon.o"
- name: Archive plain binary
uses: actions/upload-artifact@v7
with:
name: atari800-windows-msys2-32
path: src/atari800.exe
- name: Stage files and build installer
run: |
if [ -n "${{ inputs.version }}" ]; then
V=${{ inputs.version }}
else
V=${GITHUB_REF_NAME#ATARI800_}
V=$(echo "$V" | sed 's/_/./g')
fi
echo "VERSION=$V" >> $GITHUB_ENV
mkdir -p pkg/act pkg/doc
cp src/atari800.exe pkg/
for dll in SDL2.dll libmp3lame-0.dll libpng16-16.dll libreadline8.dll libtermcap-0.dll libwinpthread-1.dll zlib1.dll; do
find /mingw32/bin -name "$dll" -exec cp {} pkg/ \; 2>/dev/null || true
done
find /mingw32/bin -name "libgcc_s_dw2-1.dll" -exec cp {} pkg/ \; 2>/dev/null || true
cp README.TXT pkg/
cp act/*.act pkg/act/
cp data/atari800.ico pkg/
cp COPYING pkg/doc/COPYING.txt
cp DOC/INSTALL pkg/doc/INSTALL.txt
cp DOC/NEWS pkg/doc/NEWS.txt
cp DOC/USAGE pkg/doc/USAGE.txt
makensis -DVERSION=$V -DPLATFORM=win32-no-network atari800.nsi
(cd pkg && zip -r "../atari800-${V}-win32-no-network.zip" .)
- name: Verify installer
run: |
if [ -n "${{ inputs.version }}" ]; then
V=${{ inputs.version }}
else
V=${GITHUB_REF_NAME#ATARI800_}
V=$(echo "$V" | sed 's/_/./g')
fi
test -f atari800-$V-win32-no-network.zip && echo "Installer OK: atari800-$V-win32-no-network.zip"
- name: Archive portable zip
uses: actions/upload-artifact@v7
with:
name: atari800-${{ env.VERSION }}-win32-no-network-portable
path: atari800-*-win32-no-network.zip
- name: Archive installer exe
uses: actions/upload-artifact@v7
with:
name: atari800-${{ env.VERSION }}-win32-no-network-installer
path: atari800-*-win32-no-network.exe
- name: Attach to release
if: startsWith(github.ref, 'refs/tags/ATARI800_')
shell: bash
env:
GH_TOKEN: ${{ github.token }}
run: |
gh release create "$GITHUB_REF_NAME" 2>/dev/null || true
gh release upload "$GITHUB_REF_NAME" atari800-*-win32-no-network.exe atari800-*-win32-no-network.zip --clobber
atari800-7.1.2/.gitignore 0000664 0000000 0000000 00000001321 15231600053 0015031 0 ustar 00root root 0000000 0000000 *~
*.o
.deps
.dirstamp
/aclocal.m4
/autom4te.cache
/compile
/config.log
/config.status
/configure
/depcomp
/DOC/Makefile
/DOC/Makefile.in
/emuos/build
/install-sh
/Makefile
/Makefile.in
/missing
/src/android/bin
/src/android/gen
/src/android/jni/Android.mk
/src/android/libs
/src/android/local.properties
/src/android/build
/src/android/.gradle
/src/android/.idea
/src/android/obj
/src/android/proguard-project.txt
/src/android/.cxx
/src/atari800
/src/config.h
/src/config.h.in
/src/guess_settings
/src/libatari800.a
/src/libatari800_test
/src/Makefile
/src/Makefile.in
/src/stamp-h1
/src/autom4te.cache
/tools/cart
/tools/Makefile
/tools/Makefile.in
# Qt Creator
/atari800.creator.user
/.qtc_clangd
# VS Code
/.vscode
atari800-7.1.2/.travis.yml 0000664 0000000 0000000 00000000612 15231600053 0015154 0 ustar 00root root 0000000 0000000 matrix:
include:
- os: linux
language: c
dist: trusty
sudo: required
branches:
only:
- master
compiler:
- gcc
env:
global:
- MAKEFLAGS="-j 2"
before_install:
- .travis/install_prerequisities.sh
before_script:
- . ./.travis/setup_env.sh
script:
- . ./.travis/build.sh
deploy:
skip_cleanup: true
provider: script
script: .travis/deploy.sh
atari800-7.1.2/.travis/ 0000775 0000000 0000000 00000000000 15231600053 0014432 5 ustar 00root root 0000000 0000000 atari800-7.1.2/.travis/build.sh 0000775 0000000 0000000 00000005621 15231600053 0016074 0 ustar 00root root 0000000 0000000 #!/bin/sh
#
# actual build script
# most of the steps are ported from the atari800.spec file
#
BUILDROOT="${PWD}/.travis/tmp"
OUT="${PWD}/.travis/out"
mkdir -p "${BUILDROOT}"
mkdir -p "${OUT}"
unset CC CXX
P=atari800
prefix=/usr
bindir=$prefix/bin
datadir=$prefix/share
icondir=$datadir/icons/hicolor
docdir=$datadir/doc/${P}
common_opts="--prefix=$prefix"
VERSION=`sed -n -e 's/^AC_INIT(Atari800, \([0-9][\.0-9]*\).*$/\1/p' src/configure.ac`
isrelease=false
ATAG=${VERSION}${archive_tag}
tag=`git tag --points-at ${TRAVIS_COMMIT}`
case $tag in
ATARI800_*)
isrelease=true
;;
*)
ATAG=${VERSION}${archive_tag}-${SHORT_ID}
;;
esac
NO_CONFIGURE=1 ./autogen.sh
targets="sdl"
maintarget="sdl"
options_sdl="--with-video=sdl --with-sound=sdl"
options_ncurses="--with-video=ncurses --with-sound=oss"
options_x11="--target=x11 --with-sound=oss"
case "$TRAVIS_OS_NAME" in
linux)
for target in $targets
do
./configure $common_opts `eval echo \\\$options_${target}`
make
mv src/${P} src/${P}-${target}
make clean
done
touch atari800
make DESTDIR="${BUILDROOT}" install || exit 1
for target in $targets
do
install -m 755 src/${P}-${target} "${BUILDROOT}${bindir}"
done
pushd "${BUILDROOT}${bindir}"
ln -sf ${P}-${maintarget} ${P}
popd
install debian/changelog "${BUILDROOT}$docdir/changelog.Debian"
install DOC/ChangeLog "${BUILDROOT}$docdir/ChangeLog"
install DOC/NEWS "${BUILDROOT}$docdir/NEWS"
install DOC/CREDITS "${BUILDROOT}$docdir/CREDITS"
install DOC/README "${BUILDROOT}$docdir/README"
install DOC/USAGE "${BUILDROOT}$docdir/USAGE"
install DOC/PORTING "${BUILDROOT}$docdir/PORTING"
gzip -9nv "${BUILDROOT}$docdir"/*
# These are too small to gzip
install DOC/FAQ "${BUILDROOT}$docdir/FAQ"
install DOC/BUGS "${BUILDROOT}$docdir/BUGS"
install DOC/TODO "${BUILDROOT}$docdir/TODO"
install debian/README.Debian "${BUILDROOT}$docdir/README.Debian"
install debian/${P}.cfg "${BUILDROOT}$docdir/${P}.cfg"
# and don't gzip the copyright statement
install debian/copyright "${BUILDROOT}$docdir/copyright"
# install and gzip man page
install -d "${BUILDROOT}man/man1"
install -m 644 src/${P}.man "${BUILDROOT}$datadir/man/man1/${P}.1"
gzip -9nv "${BUILDROOT}man/man1"/*.1
# install menu file
install -d "${BUILDROOT}$datadir/menu"
install -m 644 debian/menu "${BUILDROOT}$datadir/menu/${P}"
ARCHIVE="${PROJECT_LOWER}-${ATAG}.tar.xz"
(
cd "${BUILDROOT}"
tar cvfJ "${OUT}/${ARCHIVE}" .
)
;;
osx)
DMG="${PROJECT_LOWER}-${VERSION}${archive_tag}.dmg"
ARCHIVE="${PROJECT_LOWER}-${ATAG}.dmg"
pushd src/macosx
xcodebuild -derivedDataPath "$OUT" -project atari800.xcodeproj -configuration Release -scheme Packaging
popd
mv "$OUT/Build/Products/Release/$DMG" "$OUT/$ARCHIVE" || exit 1
;;
esac
export ARCHIVE
export isrelease
if $isrelease; then
make dist
for ext in gz bz2 xz lz; do
ARCHIVE="${PROJECT_LOWER}-${VERSION}.tar.${ext}"
test -f "${ARCHIVE}" && mv "${ARCHIVE}" "$OUT"
done
fi
atari800-7.1.2/.travis/deploy.sh 0000775 0000000 0000000 00000006772 15231600053 0016301 0 ustar 00root root 0000000 0000000 #!/bin/sh
# This script deploys the built binaries to bintray:
# https://bintray.com/atari800/atari800-files
# Bintray needs an api key for access as password.
# This must have been set as environment variable BINTRAY_API_KEY
# in the settings page of your travis account.
# You will find the key in your profile on bintray.
if [ -z "$BINTRAY_API_KEY" ]
then
echo "error: BINTRAY_API_KEY is undefined" >&2
exit 1
fi
OUT="${PWD}/.travis/out"
# variables
RELEASE_DATE=`date -u +%Y-%m-%dT%H:%M:%S`
BINTRAY_HOST=https://api.bintray.com
BINTRAY_USER="${BINTRAY_USER:-atari800}"
BINTRAY_REPO_OWNER="${BINTRAY_REPO_OWNER:-$BINTRAY_USER}" # owner and user not always the same
BINTRAY_REPO="${BINTRAY_REPO_OWNER}/${BINTRAY_REPO:-atari800-files}"
if [ "${TRAVIS_PULL_REQUEST}" != "false" ]
then
BINTRAY_DIR=pullrequests
BINTRAY_DESC="[${TRAVIS_REPO_SLUG}] Download: https://dl.bintray.com/${BINTRAY_REPO}/${BINTRAY_DIR}/${ARCHIVE}"
else
BINTRAY_DIR=snapshots
BINTRAY_DESC="[${PROJECT}] [${TRAVIS_BRANCH}] Commit: https://github.com/${GITHUB_USER}/${PROJECT}/commit/${TRAVIS_COMMIT}"
fi
# use the commit id as 'version' for bintray
BINTRAY_VERSION=$TRAVIS_COMMIT
echo "Deploying $ARCHIVE to ${BINTRAY_HOST}/${BINTRAY_REPO}"
echo "See result at ${BINTRAY_HOST}/${BINTRAY_REPO}/${BINTRAY_DIR}#files"
# See https://bintray.com/docs/api for a description of the REST API
CURL="curl -u ${BINTRAY_USER}:${BINTRAY_API_KEY} -H Accept:application/json -w \n"
cd "$OUT"
#create version:
echo "creating version ${BINTRAY_DIR}/${BINTRAY_VERSION}"
$CURL --data '{"name":"'"${BINTRAY_VERSION}"'","released":"'"${RELEASE_DATE}"'","desc":"'"${BINTRAY_DESC}"'","published":true}' --header 'Content-Type: application/json' "${BINTRAY_HOST}/packages/${BINTRAY_REPO}/${BINTRAY_DIR}/versions"
echo ""
#upload file:
echo "upload ${BINTRAY_DIR}/${ARCHIVE}"
$CURL --upload "${ARCHIVE}" "${BINTRAY_HOST}/content/${BINTRAY_REPO}/${BINTRAY_DIR}/${BINTRAY_VERSION}/${BINTRAY_DIR}/${ARCHIVE}?publish=1&override=1&explode=0"
echo ""
# publish the version
echo "publish ${BINTRAY_DIR}/${BINTRAY_VERSION}"
$CURL --data '' "${BINTRAY_HOST}/content/${BINTRAY_REPO}/${BINTRAY_DIR}/${BINTRAY_VERSION}/publish?publish_wait_for_secs=-1"
echo ""
if $isrelease; then
echo "celebrating new release ${VERSION}"
BINTRAY_DIR=releases
BINTRAY_VERSION=$VERSION
#create version:
echo "creating version ${BINTRAY_DIR}/${BINTRAY_VERSION}"
$CURL --data '{"name":"'"${BINTRAY_VERSION}"'","released":"'"${RELEASE_DATE}"'","desc":"'"${BINTRAY_DESC}"'","published":true}' --header 'Content-Type: application/json' "${BINTRAY_HOST}/packages/${BINTRAY_REPO}/${BINTRAY_DIR}/versions"
echo ""
#upload file(s):
# we only need to upload the src archive once
if test "$TRAVIS_OS_NAME" = linux; then
for ext in gz bz2 xz lz; do
SRCARCHIVE="${PROJECT_LOWER}-${VERSION}.tar.${ext}"
if test -f "${SRCARCHIVE}"; then
echo "upload ${BINTRAY_DIR}/${VERSION}/${SRCARCHIVE}"
$CURL --upload "${SRCARCHIVE}" "${BINTRAY_HOST}/content/${BINTRAY_REPO}/${BINTRAY_DIR}/${BINTRAY_VERSION}/${VERSION}/${PROJECT_LOWER}-${VERSION}.orig.tar.${ext}?publish=1&override=0&explode=0"
echo ""
fi
done
fi
echo "upload ${BINTRAY_DIR}/${ARCHIVE}"
$CURL --upload "${ARCHIVE}" "${BINTRAY_HOST}/content/${BINTRAY_REPO}/${BINTRAY_DIR}/${BINTRAY_VERSION}/${VERSION}/${ARCHIVE}?publish=1?override=0?explode=0"
# publish the version
echo "publish ${BINTRAY_DIR}/${BINTRAY_VERSION}"
$CURL --data '' "${BINTRAY_HOST}/content/${BINTRAY_REPO}/${BINTRAY_DIR}/${BINTRAY_VERSION}/publish?publish_wait_for_secs=-1"
echo ""
fi
atari800-7.1.2/.travis/install_prerequisities.sh 0000775 0000000 0000000 00000002326 15231600053 0021577 0 ustar 00root root 0000000 0000000 #!/bin/sh
echo rvm_autoupdate_flag=0 >> ~/.rvmrc
case "$TRAVIS_OS_NAME" in
linux)
sudo apt-get update
sudo apt-get install -y \
curl \
libsdl1.2-dev \
;;
osx)
curl --get https://www.libsdl.org/release/SDL-1.2.15.dmg --output SDL.dmg
mkdir -p ~/Library/Frameworks
mountpoint=~/sdltmp
mkdir "$mountpoint"
hdiutil attach -mountpoint "$mountpoint" -readonly SDL.dmg
cp -R "$mountpoint/SDL.framework" ~/Library/Frameworks
hdiutil detach "$mountpoint"
rmdir "$mountpoint"
rm -rf src/macosx/SDL.Framework
rm -rf src/macosx/SDL_image.Framework
ln -s ~/Library/Frameworks/SDL.Framework src/Unix/MacOSX/SDL.Framework
ln -s ~/Library/Frameworks/SDL_image.Framework src/Unix/MacOSX/SDL_image.Framework
# we must install the macports version of the dependencies,
# because the brew packages are not universal
mkdir src/Unix/MacOSX/external
for i in gmp/gmp-6.1.2_0+universal.darwin_16.i386-x86_64.tbz2 \
mpfr/mpfr-3.1.5_0+universal.darwin_16.i386-x86_64.tbz2 \
jpeg/jpeg-9b_0+universal.darwin_16.i386-x86_64.tbz2; do
f=`basename $i`
curl --get https://packages.macports.org/$i --output $f
tar -C src/Unix/MacOSX/external --include="./opt/local" --strip-components=3 -xf $f
done
;;
*)
exit 1
;;
esac
atari800-7.1.2/.travis/setup_env.sh 0000775 0000000 0000000 00000001270 15231600053 0017001 0 ustar 00root root 0000000 0000000 #!/bin/sh
# Use as: ". setup_env.sh"
export GITHUB_USER=$(echo "${TRAVIS_REPO_SLUG}" | cut -d '/' -f 1)
export BASE_RAW_URL="https://raw.githubusercontent.com/${GITHUB_USER}"
export PROJECT=$(echo "${TRAVIS_REPO_SLUG}" | cut -d '/' -f 2)
export SHORT_ID=$(git log -n1 --format="%h")
export PROJECT_LOWER=`echo ${PROJECT} | tr '[[:upper:]]' '[[:lower:]]'`
CPU=unknown
if echo "" | gcc -dM -E - | grep -q __x86_64__; then
CPU=x86_64
fi
if echo "" | gcc -dM -E - | grep -q __i386__; then
CPU=i386
fi
if echo "" | gcc -dM -E - | grep -q "__arm.*__"; then
CPU=arm
fi
export CPU
case "$TRAVIS_OS_NAME" in
linux)
archive_tag=-linux
;;
osx)
archive_tag=-macosx
;;
esac
export archive_tag
atari800-7.1.2/COPYING 0000664 0000000 0000000 00000043133 15231600053 0014103 0 ustar 00root root 0000000 0000000 GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.
atari800-7.1.2/DOC/ 0000775 0000000 0000000 00000000000 15231600053 0013451 5 ustar 00root root 0000000 0000000 atari800-7.1.2/DOC/.gitattributes 0000664 0000000 0000000 00000000035 15231600053 0016342 0 ustar 00root root 0000000 0000000 INSTALL.falcon text eol=crlf
atari800-7.1.2/DOC/BUGS 0000664 0000000 0000000 00000010631 15231600053 0014135 0 ustar 00root root 0000000 0000000 Bugs and Known Problems
-----------------------
* Cosmic Balance (game) hangs before the intro screen. This is probably
due to inaccurate emulation of POKEY interrupts (see below). The program
uses a hardware SIO loader as part of a presumed protection scheme.
There is a bug in the code which activates the POKEY timers at an
absurdly high frequency. This causes repeated interrupts which hangs the
program.
Probably there is some interaction with SIO which prevents this on
a real Atari.
A workaround is to invoke the monitor and type "c 10 40" and "cont".
* new Pokey engine doesn't switch to mono output in STEREO_SOUND config
* a few keyboard-related bugs: e.g. pressing SHIFT+1 and then
releasing SHIFT should still give '!' characters
* The cycle-exact ANTIC/GTIA/CPU timing is not 100%.
This causes display bugs in following programs:
- Surf's up (game) (the horizon)
- Satan's Hollow (game) (horizon) (confirmed sta WSYNC at WSYNC_C bug)
- Dimension X (game) (alignment problem)
- Te.mod (demo) (small glitched pixel in the final credits on the bottom left)
- Our 5oft Unity Part (demo) (cycle-alignment, probably WSYNC)
- Isolation (demo) (vector animations)
- 80 Random Moving Rectangles (demo) (top left of rectangles, screen data
is modified while drawing a scanline)
- Sirius games: Scores and Text in Worm War I, Final Orbit, Spider City,
Turmoil, Fantastic Voyage. These games store screen data in page 0
and modify it each scan line. They reuse the same data for each
scan line with an LMS on every line. This makes the code look
like 2600 code. Emulating this requires trapping writes to
page 0 and doing partial ANTIC loads.
- Spider City has another bug in the map which is caused by player graphics
and HPOS being changed before the player is finished being drawn. This
is only possible for wide players.
- Extract (demo) (face)
* Non-bugs:
- Ergo Bibamus (demo) (one pixel of the flower above the perspective scroll)
- Mail Order Monsters (game)
(some colour changes do not align with text, occurs on a real Atari)
- The Break (demo) (bugs on the left side of photo)
- Star Raiders (disk image) (game) (doesn't work on XL/XE, select OS/B)
- Many other disk images of cartridges that work on XL/XE require OS B
because a once-popular cart dumping program for the Atari 800 generates
an OS B-specific loader. IIRC it loads the image and jumps into the OS B
RESET vector location, which is changed on the XL.
- Strip Poker (game) (Atari Basic must be enabled)
- Joust (Atari 5200 game) (the game sets all colors to black on PAL systems,
you need to switch the emulator to NTSC mode)
* The following programs are improved by using the new cycle-exact code:
- 8 Players Demo (demo)
- Bewesoft's Demo (demo)
- Bitter Reality (demo)
- Demonic Laughter (music collection)
- Extract (graphics collection)
- GED (graphics editor)
- Joyride (demo)
- Mail Order Monsters (game)
- Master of the Lamps (game)
- Orneta '95 invitro (demo)
- Our 5oft Unity Part (demo)
- Studio Dream (demo)
- Sweet Illusion (demo)
- Te.mod (demo)
- The Break (demo)
- Miner 2049'er (game) (rotating 5's)
- Dimension X (game) (title screen upper and lower bars)
- Graphics impossible (demo) (Antic magazine)
- Power Graph (graphics editor)
- Darkness Warrior (picture)
* POKEY interrupts are scanline-, not cycle-exact.
This causes display or sound bugs in following programs:
- Joyride (demo) (white lines on title picture)
- Mirax Force (game) (speech)
- Saturday Demo (demo) (music)
- The Last Guardian (game) (speech)
- Digital Trash (demo) (music)
* intensive 130xe-banks switching slows down emulation much.
This causes performance problems in following programs:
- Impossible but Real (demo)
- Sheol (demo)
- Total Daze (demo)
- Ultra (demo)
* The following VAPI images are known to not work:
(This list may not be complete, as full VAPI documentation
has never been released by the author)
- Alternate Reality: The City
- Ankh
- Attack at EP CYG 4
- Ballblazer Activision (UK)
- Jenny of the Prairie
- Mercenary - Escape from Targ _ Novagen Software
- Mr. Do!
- Music Studio (The)
- Promoteur
- Rescue on Fractalus! _ Activision (UK)
- Spy vs Spy
- Targets - A Number Game
* SDL port uses call back system for filling sound buffer.
This causes wrong sound effects (noise) in some games.
atari800-7.1.2/DOC/BUILD.PS2 0000664 0000000 0000000 00000000671 15231600053 0014642 0 ustar 00root root 0000000 0000000 To compile use ps2dev from ps2dev.org
Additional libraries neeeded:
gsKit
Additional Modules
usbd.irx, kbd.irx, audsrv.irx
Convert irx modules to *.s via bin2s,
Copy *.s files to src directory.
./configure \
--target=ps2 \
--build=i686-pc-linux-gnu \
--host=mipsel \
--disable-stereosound \
--disable-monitorbreak
make
To install read DOC/INSTALL.ps2
Thanks Piotr of atari800!
Thanks ps2dev! Esp NeoVanglist, author of gsKit.
-Troy Ayers atari800-7.1.2/DOC/BUILD.RPI 0000664 0000000 0000000 00000002177 15231600053 0014673 0 ustar 00root root 0000000 0000000 RASPBERRY PI BUILD
==================
See README.RPI for system requirements.
With Pi OS Buster and earlier, Atari800 depended upon Pi-specific graphics libraries.
This situation changed with the release of Pi OS Bullseye. The Pi-specific libraries
were dropped, and a new standard KMS video driver was introduced, allowing a wide range
of Raspberry Pi models to run the Debian release of Atari800.
Consequently there are no longer special build procedures for the Raspberry Pi, and
it can be treated the same as any other Debian based Linux system.
To build the atari800 executable, follow the instructions in:
DOC/Build.linux.
To build a deb package for general release, follow the instructions in:
DOC/Build.linux_package.
Note that Atari800 v5.0.0 was released with build instructions for Pi OS Buster.
This was an error, because Bullseye had already been released at that time.
If you wish to build v5.0.0 refer to the files listed above, and not those in the
distribution file atari800-5.0.0-src.tgz.
Starting with v6.0.0, Atari800 uses SDL2 and the standard build procedure applies
to all Debian-based systems including Raspberry Pi.
atari800-7.1.2/DOC/BUILD.android 0000664 0000000 0000000 00000004410 15231600053 0015651 0 ustar 00root root 0000000 0000000 Build instructions for the Android port
---------------------------------------
If you are looking for instructions on how to use the Android port, what the
preferences mean etc. you should check out instead:
https://atari800.github.io/Atari800forAndroid.html
See also DOC/README.android.
I. Prerequisites
----------------
To compile the Android port, you are going to need:
1. A working autotools/make environment (e.g. Cygwin or MinGW on Windows).
Before trying to build the Android port, it is a good idea to first try building
the desktop version, for instance the SDL port. It is a good way to verify that
the necessary tools are installed and working correctly. See DOC/INSTALL to
build Atari800 on Unix environments, or DOC/BUILD.windows to build under Cygwin
and MinGW.
2. The Java JDK.
Version 17 or later is recommended:
https://adoptium.net/
3. The Android SDK (command-line tools).
Install the Android command-line tools (cmdline-tools) from:
https://developer.android.com/studio#command-line-tools-only
Then use sdkmanager to install required packages:
# sdkmanager "platform-tools" "build-tools;36.0.0" "platforms;android-36" "cmake;3.22.1"
4. The Android NDK.
Install the NDK via sdkmanager:
# sdkmanager "ndk;27.0.12077973"
Or download it manually from:
https://developer.android.com/ndk/downloads
II. Setting up the environment
------------------------------
1. Set the ANDROID_HOME environment variable to point to the SDK root, e.g.:
# export ANDROID_HOME=/path/to/android-sdk
2. Set the JAVA_HOME environment variable to point to your JDK, e.g.:
# export JAVA_HOME=/path/to/jdk-17
3. Add the Android SDK tools to PATH:
# export PATH="$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$PATH"
III. Compiling
--------------
1. Unpack the source tarball of Atari800.
2. If the configure script is missing, create it:
# ./autogen.sh
3. Configure the build:
# ./configure --target=android
4. Build the APK package:
# make
After a while, the APK package should appear in:
src/android/build/outputs/apk/debug/colleen-debug.apk
To build a release APK suitable for distribution:
# cd src/android && ./gradlew assembleRelease
You will need to configure signing in src/android/build.gradle.kts or supply
keystore properties via the command line.
atari800-7.1.2/DOC/BUILD.linux 0000664 0000000 0000000 00000003633 15231600053 0015376 0 ustar 00root root 0000000 0000000 TO COMPILE, BUILD AND INSTALL ATARI800 FROM SOURCE CODE
=======================================================
OBTAIN THE SOURCE CODE
======================
If you wish to compile the current development version, clone the
atari800/atari800 repository using Github.
Or
If you wish to compile a specific released version of atari800, obtain the
source code from the atari800 Github releases area. Source is available
in zipped files with names like atari800-6.0.0-src.tgz (where 6.0.0 denotes
the version).
Open a terminal on the directory containing your atari800 source files.
You need to remain in this directory for all the procedures below to work.
CREATE THE CONFIGURE FILE
=========================
If your directory already contains a file called 'configure' you can skip
this. This will be the case if you are compiling a released version
of atari800.
If you don't have a configure file, generate it as follows.
Make sure you have autoconf installed:
sudo apt-get install autoconf
Create the configure file:
./autogen.sh
See DOC/INSTALL for further details.
INSTALL SDL DEVELOPMENT FILES
=============================
Ensure the SDL development files are installed:
sudo apt-get install libsdl2-dev
COMPILE
=======
Configure and make:
./configure
make
Make generates the executable file src/atari800. You can run atari800 by
on it, or by changing to the src directory and
using the command:
./atari800
If you are happy to run the emulator this way, you don't need to need
to install as described below.
INSTALL
=======
To install atari800:
sudo make install
You can then run the emulator with the following command, regardless of which
directory you are in:
atari800
UNINSTALL
=========
The package manager knows nothing about this installation, so it can't be
uninstalled in the usual manner. Use the following command instead:
sudo make uninstall
atari800-7.1.2/DOC/BUILD.linux_package 0000664 0000000 0000000 00000014436 15231600053 0017054 0 ustar 00root root 0000000 0000000 HOW TO BUILD A LINUX DEB PACKAGE FOR GENERAL RELEASE
====================================================
INSTALL PACKAGE DEVELOPMENT TOOLS
=================================
Ensure that you have the necessary tools installed:
sudo apt-get install build-essential
sudo apt-get install fakeroot
sudo apt-get install devscripts
INSTALL DEPENDENCIES
====================
Check that SDL 2 and it's development files are present. They are not
installed as standard in all Linux distributions.
sudo apt-get install libsdl2-2.0
sudo apt-get install libsdl2-dev
OBTAIN SOURCE CODE
==================
Download the latest release of the source code from the Github Releases Area
(https://github.com/atari800/atari800/releases). Look for a file with a name
like 'atari800-6.0.0-src.tgz', where 6.0.0 denotes the version.
Unzip the source code. The contents will go into a directory called
'atari800-6.0.0' or similar, which will be referred to in these notes as the
'atari800' directory.
Do not obtain the source code by cloning the current atari800 repository
because this may have been modified since the last release, and may contain
partially developed and untested code.
UPDATE DEBIAN CHANGELOG
=======================
Update file 'atari800/debian/changelog'. You can simply edit this manually,
but the system is fussy about the exact format, location of spaces etc., so it
is handy to use the debchange command as follows.
Open a terminal on the atari800 directory.
debchange
Select an editor from the presented menu. Debchange guesses a new version
number and other details and enters some new lines into the log for you. The
top of the file should look something like this:
atari800 (5.0.0ubuntu1) UNRELEASED; urgency=medium
*
-- Cliff Sat, 30 Dec 2023 17:03:52 +0000
Edit these lines as appropriate. For example:
atari800 (6.0.0) unstable; urgency=medium
* New upstream version 6.0.0
* SDL2 support
* Packages released via GitHub, Jun 2026:
* https://github.com/atari800/atari800/releases
-- Antonin Kral Fri, 19 Jun 2026 17:03:52 +0000
The version number '6.0.0' will be used as part of the name of the package
you are going to build.
Label the release 'unstable'. This does not mean it is actually unstable, just
that no tests have been performed at this stage to prove otherwise.
You may add as many comments as you wish on lines beginning with two spaces
and a '*'.
Set urgency to 'low', or 'medium' for major updates.
You should replace your default user information with the name and email
address of the current package maintainer, as identified in
debian/README.debian.
ADJUST CONFIGURATION OPTIONS IN THE DEBIAN RULES FILE
=====================================================
The debian rules file 'atari800/debian/rules' contains the following command
(split over two lines):
./configure \
--with-video=sdl2 --with-sound=sdl2
BUILD THE PACKAGE
=================
dpkg-buildpackage -B -uc
This configures and compiles atari800 and builds the package.
Look out for warning and error messages. Warnings can usually be ignored,
but you will have to investigate and correct any errors.
If you receive messages about missing dependencies, install them and run
the command again. For example if libsdl2-2.0 is missing, install it with
the command:
sudo apt-get install libsdl2-2.0
The dpkg-buildpackage command creates three files and places them in the
parent of the atari800 directory. They will have names like these:
atari800_6.0.0_amd64.buildinfo - Checksums and a list of dependencies
in the .deb file.
atari800_6.0.0_amd64.changes - Changelog update and checksums for
the .deb and .buildinfo files.
atari800_6.0.0_amd64.deb - The .deb package file for release.
'amd64' indicates the architecture of the machine that the build was done on.
If you wish to create packages for several different architectures, you should
copy the atari800 directory to machines with the appropriate architectures and repeat
the build process there.
INSTALL
=======
Some Linux distributions allow you to install packages via the GUI, e.g.:
on the .deb file to install.
or
and select the appropriate menu item, or similar.
If these methods don't work on your distribution, use the command:
sudo dpkg -i atari800_6.0.0_amd64.deb
TEST
====
Check that the atari800 command runs the emulator successfully:
atari800
The command should also work with options, for example:
atari800 -v
atari800 -help
man atari800
UNINSTALL
=========
You can unistall the package with the Software Manager, or the command:
sudo dpkg --remove atari800
This removes the command and documentation, but leaves the configuration file
.atari800.cfg in place.
ISSUE A PULL REQUEST TO UPDATE THE DEBIAN CHANGELOG IF THIS HAS NOT ALREADY BEEN DONE
=====================================================================================
Enter the new lines you created in atari800/debian/changelog into the master
of this file on Git. This is just to keep the record intact.
DISTRIBUTION VIA THE GITHUB RELEASES AREA
=========================================
Send the three files created (.buildinfo, .changes and .deb) to the owner of
the Git repository (https://github.com/atari800/atari800).
The owner will post the .deb file to the releases area
(https://github.com/atari800/atari800/releases) for download by users.
This is a shortcut method. It is quicker than distribution via the Debian
Project.
When a new release is announced on the Atari800 mailing list, anyone in the
community can follow the procedure described in this document and make it
available to users without delay.
DISTRIBUTION VIA THE DEBIAN PROJECT
===================================
Formal distribution via the Debian Project can only be performed by the
package maintainer, a listed Debian member. The procedure is rigourous in
order to ensure the quality of the software. Depending on how much free
time the maintainer has it may take many months to complete.
Packages distributed in this manner become available in official repositories.
Users may download and install them using the apt-get command or a software
manager.
atari800-7.1.2/DOC/BUILD.windows 0000664 0000000 0000000 00000010532 15231600053 0015725 0 ustar 00root root 0000000 0000000 Building Atari800 for MS Windows
================================
Atari800 executable for Windows is built the same way as on any other Unix-like
OS: using a Unix-like environment such as Cygwin, MinGW or MSYS2.
All of these toolchains provide a Unix-like environment on Windows, so building
Atari800 with them is based on the same configure/make sequence as on other
platforms. The procedure is described in detail in DOC/INSTALL, section
"Building the Emulator on most platforms" - read it before continuing below.
There are several configure options applicable to the Windows platform:
Type "./configure --with-video= --with-sound=" to build other
versions. The available options are:
* --with-video:
* sdl - uses SDL,
* ncurses - uses the ncurses library,
* no - pure console interface.
* --with-sound:
* sdl - uses SDL,
* no - no sound.
You can add other configure options if desired.
The recommended version is --with-video=sdl --with-audio=sdl, as it has the
largest set of features.
Building the SDL version
------------------------
The procedure for building the SDL version is described in DOC/INSTALL, section
"Building the Emulator for SDL".
Notes on building using Cygwin
------------------------------
1. Get Cygwin at http://cygwin.com/
2. The executable requires the following DLLs: /bin/mgwz.dll and (for SDL)
sdl.dll - copy them to the same directory as atari800.exe.
Notes on building using MinGW
-----------------------------
1. To build the SDL version with OpenGL support, get the OpenGL headers at
http://www.libsdl.org/extras/win32/common/opengl-devel.tar.gz .
See also http://www.libsdl.org/extras/win32/mingw32/README.txt
2. If the configure script does not find the SDL library, you might need to add
"--with-sdl-prefix=/mingw" to the configure options.
Notes on building using MSYS2
-----------------------------
1. Install MSYS2 itself:
- Based on:
https://www.msys2.org/
https://www.msys2.org/wiki/MSYS2-installation/
a) Get the MSYS2 installer package from https://www.msys2.org/ . The
instructions below is tailored towards MSYS2 release dated 20250221, which
was the latest at the time of this writing.
b) Run the installer to install the environment.
- Note: MSYS2 provides 5 Start menu shortcuts to the MSYS shell:
"MSYS2 MSYS" - use this and only this shell to install or remove packages.
"MSYS2 CLANG64" - use this shell to build 64-bit programs with clang
compiler and UCRT64 runtime.
"MSYS2 CLANGARM64" - use this shell to build 64-bit programs for ARM CPU
with clang compiler and UCRT64 runtime.
"MSYS2 UCRT64" - use this shell to build 64-bit programs with gcc
compiler and UCRT64 runtime.
"MSYS2 MinGW64" - use this shell to build 64-bit programs with gcc
compiler and MSVCRT runtime.
See https://www.msys2.org/docs/environments/ for more detailed
description.
c) If not selected at the end of installer, run "MSYS2 MSYS" shell (from Start
menu).
d) Update the environment using pacman -Syuu. Run it multiple times until no
more packages are left to update.
Note: if after an update there appears a message to "exit pacman without
returning to the MSYS shell", then close the MSYS shell window, and use
Task Manager to kill the "pacman.exe" process that is left hanging. Then
re-run "MSYS2 MSYS" to continue updating.
2. Install packages required by Atari800:
- Note: to install a package, enter
pacman -S ...
a) Start the "MSYS2 MSYS" shell.
b) If you want to regenerate the configure script, install the following
packages:
- autoconf
- automake
- perl
c) To build Atari800, install:
- make
- mingw-w64-ucrt-x86_64-gcc
- mingw-w64-ucrt-x86_64-SDL
- mingw-w64-ucrt-x86_64-readline
- mingw-w64-ucrt-x86_64-libpng
3. Build Atari800:
a) Start the "MSYS2 UCRT64" shell to build the 64-bit binary.
b) Follow the common build procedure as described in DOC/INSTALL, section
"Building the Emulator for SDL".
c) The executable requires the following DLLs - copy them from ucrt64/bin
to the same directory as atari800.exe:
- libpng16-16.dll
- libreadline8.dll
- libtermcap-0.dll
- SDL.dll
- zlib1.dll
atari800-7.1.2/DOC/CHANGES.OLD 0000664 0000000 0000000 00000252766 15231600053 0015103 0 ustar 00root root 0000000 0000000 /***********************************************************************\
|* This file is obsolete now. Update ChangeLog and NEWS files instead. *|
\***********************************************************************/
----
o the configure process can be silent now - use --enable-FEATURE or --disable-FEATURE
(e.g. --disable-SOUND). Sent by Dale Scheetz (the original author is Alan Shutko).
o completely refactored UI by Vasyl. Now allows different (port specific) GUIs.
o Basic XE (OSS Supercart) should work now
o nonblocking open of sound device on linux
o ANTIC.C is no longer LONG_ALIGNMENT dependent. Macros READ_U32/WRITE_U32
take care of the memory access.
o a fix in antic.c (lines 408-411) for artefacting on systems requiring
aligned memory access.
Changes in 1.0.7
----------------
o atari_x11.c: Added clipping and made the -large and -huge work with XShm.
The XShm code was rewritten, so that only the screen-portion which
has been changed is copied to the X-server (on older PCs with
PCI-graphic this brings a noticable performance gain).
New options are:
-clip_x
-clip_width
-clip_y
-clip_height
atari.h: commented out USE_COLOUR_TRANSLATION_TABLE because it produced
funny results with options -large and -huge.
Rudolf Opalla
o introduced autoconf stuff
o win32: standard wave output routines added to sound driver (-wavonly switch
to disable direct sound)
o sound_update removed from port specific routines (moved to atari.c) and
some other sound fixes
o unix, windows and dos makefiles rewritten and reorganized
o all open() calls on regular files replaced by fopen().
o win32 conditionals removed; new win32 port
o atari_sleep_ms() replaced by new function atari_sync() with better
synchronization code (lasttime is increased by constant interval
and previously could differ depending on gettime call delay)
o bug causing vesa modes not to be detected correctly fixed.
o cpu_m68k.s is 100% compatible with the cpu.c now
o Don Mahurin added sound support to curses version.
Also Voxware_ routines were renamed.
o it seems that zero in first byte of block 41/C1 should be interpreted
as 00, not 0x100 [eg. 1st disk of Big Demo couldn't be read because of
this]. Jakub Bogusz
o double density DCM disks weren't handled properly ("Output
desynchronized...") [eg. 1st disk of Sweet Illusions demo couldn't be
read because of this]
o some preliminary code for UI menu switch for readonly/readwrite disk
in UI.C. This needs to be discussed first, then finished.
Changes in 1.0.6 - 2000/10/09
----------------
o cpu_m68k.s updated
- the rest is Piotr's work:
o BUGS updated
o antic: fixed PMG collisions bug in horizontally scrolled lines
(bug was found by Krzysztof)
o antic: PMG flickering depends on VDELAY setting
o makefile.dos: in 1.0.4 BASIC and PDCURSES weren't compilable,
because of pokeysnd call, while pokeysnd wasn't linked - fixed
o antic,gtia: few warnings killed
o devices: -H1..-H4 options work correctly now
o E_Device, K_Device and AtariEscape moved from atari.c to devices.c
o E_Device and K_Device ESC codes work only in BASIC version now
o sio: debug code removed
o devices, rt-config: H: devices can be set to read-only mode:
use -hdreadonly option or HD_READ_ONLY config file item
(0 disables, 1 enables read-only mode). For safety, by default
it is on
o BASIC version: EOF in stdin quits emulator. BASIC version can be used now
with redirected input (from a script file, for example).
Changes in 1.0.5 - 2000/10/02
----------------
o possibility to set color saturation
Now you can set black level, white level, color intensity and even color
shift if you prefer artificial palettes.
Added config option allows to select whether include existing palettes
into binary. By default artificial palette is generated (by surprise it
doesn't look very bad)
New options are:
-black
-white
-colors
-colshift
-realpal