runxl

#!/bin/bash
# -----------------------------------------------------------------
# runxl - Script for comfortable starting of the atari800 emulator
# (cdw) 03.12.2010 Stephan Elsner
# -----------------------------------------------------------------
# TODO:
#   1. images in an index file can not be found by the filename (difficult)
#   2. filenames containing a single-quote ' (occurs with Rohar archives) generate an error in the
#      output-script. This must be quotet in the filename.
#
# History:
# 1.4.3: fixed comments - no change in function
# 1.4.2: Language changed to english, bugfix with -o
# 1.4.1: Bugfix with -r
# 1.4.0: allows {dir} as abbreviation in the emu-ops of the index file. Replaced by current path
# 1.3.10:help text adapted
# 1.3.9: allow {dos} as shortcut in emulator options of index file, fix for Atari800 2.2.1
# 1.3.8: images with file extensions in upper case are found
# 1.3.7: Allow to hide images via the index file
# 1.3.6: Images contained in an index file will not be found additionally
#        by the filename
# 1.3.5: -b and -d parameters added
# 1.3.4: bugfix (ignore case in game names)
# 1.3.3: Bugfix (index files can be symlinked)
# 1.3.2: Bugfix (syntax error)
# 1.3.1: Code cleanup
# 1.3.0: added -e parameter for 130XE emulation
# 1.2.0: support emulator options for each program in index files
# 1.1.0: support index files for multi-file disks (e.g.Yogi) with loader
# 1.06 : Bugfixes
# 1.05 : Text adjustments
# 1.04 : startup behavior changed, default now list + interactive selection
#        -r parameter added for start of first find.
# 1.03 : bugfix: missing quotes in find commands
# 1.02 : renamed to runxl
# 1.01 : help text adapted
# 1.00 : support for cartridge-files rom, bin
# 0.90 : program list is sorted by program name

# -----------------------------------------------------------------
#  Change these settings to your own needs:
# -----------------------------------------------------------------

# Base directory for atari programs (without slash!)
BASEDIR="/usr/share/atari"

# Fixed start options fuer atari800, dynamic options will be added
STARTOPTIONS="-windowed -audio16"

# Path to preferred DOS disk
DOSDISKPATH="/usr/share/atari/XL_Proggies/XL-DISKS_Lars/TURBO.XFD"

# -----------------------------------------------------------------


USAGE=$( cat << EOF
Usage: runxl [-lhosr] [-n number] <program name>
use runxl -h for detailed help
EOF
)

HELP=$( cat << EOF
runxl v.1.4.2 - starts an Atari 8-Bit program or disk image from the commend line
Usage: runxl [-lhosefbd] [-n <number>] <program name>

The program name is used to search in files and index files.
Without further options a list of programs matching the search term is shown and interactively asked for the number of the program to be started.

Options:
-h        This help message
-l        just list matching programs, not ask for number to start
-n <num>  Start Program Nr. <num> from the search result list shown with -l 
-r        Start the first matching program

Emulator otions:
-f        Fullscreen
-o        emulate Atari 400/800
-e        emulate 130XE with 128 KB
-b        Boot with BASIC enabled
-d        Boot to DOS, Program disk is in D2
-s        Show emulator speed in %
EOF
)

# Internal variables:

# MODI (internal use)
# 0 = start of fist program in search result list
# 1 = list programs
# 2 = start specific program
# 3 = list first, then ask for program to start
MODE=3

# atari800 options for the start of specific program types
RUNCMD=""

# atari800 additional options
OPTIONS=""

# used for special emulator options for i.e. Yogi-Disks, 
# will be set with the path to the loader 
DISKEMUPTS=""

# Functions:

# --------------------------------------------------------------------------------
# shows a numbered list of all files with $GAMENAME in their name 
listprogs()
{
   createlist
   if [ "$NUMFINDS" -gt "0" ]; then
       echo
       echo "   No.  Name"
       echo "--------------------------------------------------------------"

       # extract name, add number, display
       cat /tmp/atarilist | cut -d '|' -f 2 | nl
       echo
       rm /tmp/atarilist
   else
       echo "No matching programm found."
   fi
}

# --------------------------------------------------------------------------------
# Create a temporary list of the searched programs in /tmp/atarilist
# and count entries (in $NUMFINDS)
# format of the list:
# Path to disk image or atari-executable|Displayed name|additional emulator options
createlist()
{
   # Suche files nach Dateinamen und schreibe die Funde in die Datei flist
   find $BASEDIR -iname "*$GAMENAME*" -type f | grep "[axcbeAXCBE][teafioxTEAFIOX][rxsdnmeRXSDNME]$" | awk -F"/" '
      {
         printf("%s|%s|\n",$0,$NF) 
      }' > /tmp/flist

   # search in runxmlindex*.text and append the finds to the result list
   # The first line of runxmlindex contains the name of the image file
   # The second line contains the additional options to start the emulator which are valid for all indexed files. 
   # For the Yogi discs it is the Yogiloader image
   # An index line is constructed as follows:
   # Filename Disk-Image (without path)|Displayed name of the game|Emulator-options, and {dos} as
   # placeholder for DOS-Disk 
   # (e.g. if the game does not run on an XL, or a DOS must be booted)
   # If the displayed name is - the file is hidden, comes handy e.g. with multi-disk games

   find -L $BASEDIR -iname "runxlindex*.txt" -type f -exec awk -F"|" '
      function basename(path) {
         n=split(path,a,"/")
         return a[n]
      }

      function dirname(path) {
         if (sub(/\/[^\/]*$/, "", path))
            return path
         else
            return "."
      }

      BEGIN { 
         IGNORECASE = 1;
      }

      {
         # process first line of index file (name of collection)
         if (NR == 1) {
            # title of the disk image(s) which are indexed by current file
            diskname=$0;

            # get path to index file and to inxed disk images (same path)
            mindex = match(FILENAME, "^.*/");
            filepath = substr(FILENAME,1,RLENGTH);
         }

         # second line of index file: additional emulator options for this collection
         if (NR == 2) {
            diskopts=$0
            gsub("{dos}","'$DOSDISKPATH'", diskopts);
         }
      }
      # if gamename found in description...
      tolower($2) ~ /'$GAMENAME'/ {
         if (NR > 2) {
            gsub(/[ \t]+$/, "", $2);
            # Kuerzel aufloesen
            gsub("{dos}","'$DOSDISKPATH'", $3);
            gsub("{dir}",dirname(filepath $1) "/", $3);
            printf("%s%s|%s (%s)|%s %s\n",filepath,$1,$2,diskname,$3,diskopts);
         }
      }
      # mark the line for later removal if the second column contains a "-"
      $2 ~ "-" {
         printf("%s%s|**delete**|\n",filepath,$1);
      }
   ' {} \; > /tmp/ilist

   # Filter the search results by file name. Only those results are taken into account that
   # were not already found by the search in the index files

   awk -F"|" '
      BEGIN {
         while ((getline < "/tmp/ilist") > 0)
            myarray[$1] = $1
      }
      {
         if (!($1 in myarray))
            printf("%s\n",$0)
      }' /tmp/flist > /tmp/llist

   # filter lines out that are marked with "delete"
   cat /tmp/llist /tmp/ilist | grep -v '**delete**' > /tmp/alist

   # sort result list
   sort -t '|' -k2 /tmp/alist > /tmp/atarilist
   NUMFINDS=$(cat /tmp/atarilist | wc -l)
   rm /tmp/alist
   rm /tmp/ilist
   rm /tmp/flist
   rm /tmp/llist
}

# --------------------------------------------------------------------------------
# Select the Atari program no. $GAMENUMBER from the list of files matching $GAMENAME. 
# Full path is in $AFILE
findprog()
{
   createlist
   if ([ "$GAMENUMBER" -le "$NUMFINDS" ] && [ "$GAMENUMBER" -ge "1" ]) then 
      # read path
      AFILE=$(cat /tmp/atarilist | head -$GAMENUMBER | tail -1 | cut -d '|' -f1)

      # reading the additional options, for normal programs empty, for yogi-disks path to loader
      DISKEMUOPTS=$(cat /tmp/atarilist | head -$GAMENUMBER | tail -1 | cut -d '|' -f3)
   else
      echo "Please type a number beween 1 and $NUMFINDS."
      exit
   fi
   rm /tmp/atarilist
}

# --------------------------------------------------------------------------------

if [ $# -lt 1 ]; then
   echo "$USAGE"
   exit 1
fi

# Name of game ist always last element
GNAME=${@: -1}
# convert to lower case
GAMENAME=${GNAME,,}

if [ ${GAMENAME:0:1} == "-" -a $GAMENAME != "-h"  ]; then
   echo "$USAGE"
   exit 1
fi

# Evaluate parameters
while getopts n:lhosrefbd OPT; do
  case $OPT in
     l)
        # list programs
        if [ $# -lt 2 ]; then
           echo "$USAGE"
           exit 1
        fi
        MODE=1
        ;;
     r) # start fist found program
        MODE=2
        GAMENUMER=1
        ;;
     n)
        # start specific program from the list
        MODE=2
        GAMENUMBER=$OPTARG
        ;;
     h)
        # Help
        echo "$HELP"
        exit
        ;;
     o)
        # o = old Atari 400/800
        OPTIONS="$OPTIONS -atari"
        ;;
     e)
        # e = Atari 130 XE
        OPTIONS="$OPTIONS -xe"
        ;;
     s)
        # s = show speed
        OPTIONS="$OPTIONS -showspeed"
        ;;
     f)
        # f = fullscreen
        OPTIONS="$OPTIONS -fullscreen"
        ;;
     b)
        # b = basic
        OPTIONS="$OPTIONS -basic"
        ;;
     d)
        # d = DOS
        OPTIONS="$OPTIONS $DOSDISKPATH"
        ;;
     \?)
        #echo "Wrong Parameter: -$OPT" >&2
        exit 1
        ;;
  esac
done

case $MODE in
   0) # -r start first matching program
      # findfirstprog
      ;;
   1) # -l list matching programs
      listprogs
      exit
      ;;
   2) # -n start a specific program from the list
      findprog
      ;;
   3) # without parameters: List the programs and query which of them should be started
      listprogs
      if [ "$NUMFINDS" -eq 0 ];
      then
	 exit
      fi
      echo "Start which program? [1-$NUMFINDS]"
      read GAMENUMBER

      # Test if input is numerical
      if [[ $GAMENUMBER =~ ^[0-9]+$ ]]; then
         findprog
      else
         exit
      fi
      ;;
esac

# Path to the program is determined, now start
if [ "$AFILE" != "" ];
then
   EXTENSION="`echo ${AFILE: -3}|tr '[:upper:]' '[:lower:]'`"
   case $EXTENSION in
      xex|com|exe)
         RUNCMD="-run"
         ;;
      atr|xfd)
         RUNCMD=""
         ;;
      bas|lst)
         RUNCMD="-basic -run"
         ;;
      cas)
         RUNCMD="-boottape"
         ;;
      rom|bin)
         RUNCMD="-cart"
         ;;
      *)
         echo "unknown file type: $EXTENSION"
         exit
         ;;
   esac
else
   echo "$GAMENAME not found."
   exit
fi

if [ "$MODE" -eq "0" -o "$MODE" -eq "2" ]; then
  echo  \"`basename "$AFILE"`\" "  starten? [J/n]"
  read TASTE
fi

if [ "$TASTE" == "n" ]; then
   echo "ok then."
else
  # Create and execute the start script
  echo  "atari800 $STARTOPTIONS $OPTIONS $DISKEMUOPTS $RUNCMD '$AFILE'" > /tmp/atariscript
  chmod +x /tmp/atariscript
  /tmp/atariscript
  #rm /tmp/atariscript
fi
exit