#!/bin/sh
#             __________               __   ___.
#   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
#   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
#   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
#   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
#                     \/            \/     \/    \/            \/
# $Id$
#

# global CC options for all platforms
CCOPTS="-W -Wall -Wundef -O -nostdlib -ffreestanding -Wstrict-prototypes"

use_logf="#undef ROCKBOX_HAS_LOGF"

scriptver=`echo '$Revision$' | sed -e 's:\\$::g' -e 's/Revision: //'`

#
# Begin Function Definitions
#
input() {
    read response
    echo $response
}

prefixtools () {
 prefix="$1"
 CC=${prefix}gcc
 WINDRES=${prefix}windres
 DLLTOOL=${prefix}dlltool
 DLLWRAP=${prefix}dllwrap
 RANLIB=${prefix}ranlib
 LD=${prefix}ld
 AR=${prefix}ar
 AS=${prefix}as
 OC=${prefix}objcopy
}

crosswincc () {
 # naive approach to selecting a mingw cross-compiler on linux/*nix
 echo "Enabling win32 crosscompiling"

 prefixtools i586-mingw32msvc-

 # add cross-compiler option(s)
 GCCOPTS="$GCCOPTS `sdl-config --cflags`"
 LDOPTS="`sdl-config --libs` -mconsole"

 output="rockboxui.exe" # use this as output binary name
 crosscompile="yes"
 endian="little" # windows is little endian
}

# scan the $PATH for the given command
findtool(){
  file="$1"

  IFS=":"
  for path in $PATH
  do
    # echo "checks for $file in $path" >&2
    if test -f "$path/$file"; then
      echo "$path/$file"
      return
    fi
  done
}

# parse the argument list, returns the value after the = in case of a
# option=value type option, returns 0 in case of --ccache or --no-ccache,
# returns 1 if the searched argument type wasn't fount in the argument list
# Usage [var = ]`parse_args <argumenttype>`, i.e. `parse_args target`

# var definitons below are needed so that parse_args can see the arguments
arg1=$1 arg2=$2 arg3=$3 arg4=$4 arg5=$5 arg6=$6 arg7=$7 arg8=$8 arg9=$9

parse_args() {
  ret="1"
  for i in $arg1 $arg2 $arg3 $arg4 $arg5 $arg6 $arg7 $arg8 $arg9
  do
    if [ "$1" = "--ccache" ]; then
      if [ "$i" = "--ccache" ]; then
        ret="0"
      fi
    elif [ "$1" = "--no-ccache" ]; then
      if [ "$i" = "--no-ccache" ]; then
        ret="0"
      fi
    elif [ "$1" = `echo $i|cut -d'=' -f1` ]; then
      ret=`echo $i|cut -d'=' -f2`
    fi
  done
  echo "$ret"
}

simcc () {

 # default tool setup for native building
 prefixtools ""

 simver=sdl
 GCCOPTS='-W -Wall -g -fno-builtin'

 output="rockboxui" # use this as default output binary name

 # generic sdl-config checker
 sdl=`findtool sdl-config`

 if [ -z "$sdl" ]; then
     echo "configure didn't find sdl-config, which indicates that you"
     echo "don't have SDL (properly) installed. Please correct and"
     echo "re-run configure!"
     exit
 fi

 # default share option, override below if needed
 SHARED_FLAG="-shared"

 case $uname in
   CYGWIN*)
   echo "Cygwin host detected"

   # sdl version
   GCCOPTS="$GCCOPTS `sdl-config --cflags`"
   LDOPTS="`sdl-config --libs` -mconsole"

   output="rockboxui.exe" # use this as output binary name
   ;;

   Linux)
   echo "Linux host detected"
   if [ "0" != `sdl-config --libs |grep -c mwindows` ]; then
       # Enable crosscompiling if sdl-config is from Windows SDL
       crosswincc
   else
       GCCOPTS="$GCCOPTS `sdl-config --cflags`"
       LDOPTS="`sdl-config --libs`"
   fi
   ;;

   FreeBSD)
   echo "FreeBSD host detected"
   # sdl version
   GCCOPTS="$GCCOPTS `sdl-config --cflags`"
   LDOPTS="`sdl-config --libs`"
   ;;

   Darwin)
   echo "Darwin host detected"
   # sdl version
   GCCOPTS="$GCCOPTS `sdl-config --cflags`"
   LDOPTS="`sdl-config --libs`"
   SHARED_FLAG="-dynamiclib -Wl\,-single_module"
   ;;

   *)
   echo "Unsupported system: $uname, fix configure and retry"
   exit
   ;;
 esac

 GCCOPTS="$GCCOPTS -I\$(SIMDIR)"

 if test "X$crosscompile" != "Xyes"; then
   if [ "`uname -m`" = "x86_64" ] || [ "`uname -m`" = "amd64" ]; then
     # fPIC is needed to make shared objects link
     # setting visibility to hidden is necessary to avoid strange crashes
     # due to symbol clashing
     GCCOPTS="$GCCOPTS -fPIC -fvisibility=hidden"
   fi

   id=$$
   cat >/tmp/conftest-$id.c <<EOF
#include <stdio.h>
int main(int argc, char **argv)
{
  int var=0;
  char *varp = (char *)&var;
  *varp=1;

  printf("%d\n", var);
  return 0;
}
EOF

   $CC -o /tmp/conftest-$id /tmp/conftest-$id.c 2>/dev/null

   if test `/tmp/conftest-$id 2>/dev/null` -gt "1"; then
     # big endian
     endian="big"
   else
     # little endian
     endian="little"
   fi
   echo "Simulator environment deemed $endian endian"

   # use wildcard here to make it work even if it was named *.exe like
   # on cygwin
   rm -f /tmp/conftest-$id*
 fi
}

#
# functions for setting up cross-compiler names and options
# also set endianess and what the exact recommended gcc version is
# the gcc version should most likely match what versions we build with
# rockboxdev.sh
#
shcc () {
 prefixtools sh-elf-
 GCCOPTS="$CCOPTS -m1"
 GCCOPTIMIZE="-fomit-frame-pointer -fschedule-insns"
 endian="big"
 gccchoice="4.0.3"
}

calmrisccc () {
 prefixtools calmrisc16-unknown-elf-
 GCCOPTS="-Wl\,--no-check-sections $CCOPTS"
 GCCOPTIMIZE="-fomit-frame-pointer"
 endian="big"
}

coldfirecc () {
 prefixtools m68k-elf-
 GCCOPTS="$CCOPTS -m5206e -Wa\,-m5249 -malign-int -mstrict-align"
 GCCOPTIMIZE="-fomit-frame-pointer"
 endian="big"
 gccchoice="3.4.6"
}

arm7tdmicc () {
 prefixtools arm-elf-
 GCCOPTS="$CCOPTS -mcpu=arm7tdmi"
 if test "X$1" != "Xshort"; then
   GCCOPTS="$GCCOPTS -mlong-calls"
 fi
 GCCOPTIMIZE="-fomit-frame-pointer"
 endian="little"
 gccchoice="4.0.3"
}

arm9tdmicc () {
 prefixtools arm-elf-
 GCCOPTS="$CCOPTS -mcpu=arm9tdmi -mlong-calls"
 GCCOPTIMIZE="-fomit-frame-pointer"
 endian="little"
 gccchoice="4.0.3"
}

arm946cc () {
 prefixtools arm-elf-
 GCCOPTS="$CCOPTS -mcpu=arm9e -mlong-calls"
 GCCOPTIMIZE="-fomit-frame-pointer"
 endian="little"
 gccchoice="4.0.3"
}

arm926ejscc () {
 prefixtools arm-elf-
 GCCOPTS="$CCOPTS -mcpu=arm926ej-s -mlong-calls"
 GCCOPTIMIZE="-fomit-frame-pointer"
 endian="little"
 gccchoice="4.0.3"
}

arm1136jfscc () {
 prefixtools arm-elf-
 GCCOPTS="$CCOPTS -mcpu=arm1136jf-s -mlong-calls"
 GCCOPTIMIZE="-fomit-frame-pointer"
 endian="little"
 gccchoice="4.0.3"
}

whichadvanced () {
  ##################################################################
  # Prompt for specific developer options
  #
  echo ""
  echo "Enter your developer options (press enter when done)"
  echo -n "(D)EBUG, (L)ogf, (S)imulator, (P)rofiling, (V)oice"
  if [ "$memory" = "2" ]; then
    echo -n ", (8)MB MOD"
  fi
  if [ "$modelname" = "h120" ]; then
    echo -n ", (R)TC MOD"
  fi
  echo ""

  cont=1

  while [ $cont = "1" ]; do

    option=`input`;

    case $option in
      [Dd])
        if [ "yes" = "$profile" ]; then
          echo "Debug is incompatible with profiling"
        else
          echo "define DEBUG"
          use_debug="yes"
        fi
        ;;
      [Ll])
        echo "logf() support enabled"
        logf="yes"
        ;;
      [Ss])
        echo "Simulator build enabled"
        simulator="yes"
        ;;
      [Pp])
        if [ "yes" = "$use_debug" ]; then
          echo "Profiling is incompatible with debug"
        else
          echo "Profiling support is enabled"
          profile="yes"
        fi
        ;;
      [Vv])
        echo "Voice build selected"
        voice="yes"
        ;;
      8)
        if [ "$memory" = "2" ]; then
          memory="8"
          echo "Memory size selected: 8MB"
        else
          cont=0
        fi
        ;;
      [Rr])
        if [ "$modelname" = "h120" ]; then
          config_rtc="#define CONFIG_RTC RTC_DS1339_DS3231"
          have_rtc_alarm="#define HAVE_RTC_ALARM"
          echo "RTC functions enabled (DS1339/DS3231)"
        else
          cont=0
        fi
        ;;
      *)
        cont=0
        ;;
    esac
  done
  echo "done"

  if [ "yes" = "$voice" ]; then
    # Ask about languages to build
    echo "Select a number for the language to use (default is english)"
    # The multiple-language feature is currently broken
    # echo "You may enter a comma-separated list of languages to build"

    picklang
    voicelanguage=`whichlang`

    if [ -z "$voicelanguage" ]; then
      # pick a default
      voicelanguage="english"
    fi
    echo "Voice language set to $voicelanguage"

    # Configure encoder and TTS engine for each language
    for thislang in `echo $voicelanguage | sed 's/,/ /g'`; do
      voiceconfig "$thislang"
    done
  fi
  if [ "yes" = "$use_debug" ]; then
    debug="-DDEBUG"
    GCCOPTS="$GCCOPTS -g -DDEBUG"
  fi
  if [ "yes" = "$logf" ]; then
    use_logf="#define ROCKBOX_HAS_LOGF 1"
  fi
  if [ "yes" = "$simulator" ]; then
    debug="-DDEBUG"
    extradefines="$extradefines -DSIMULATOR"
  fi
  if [ "yes" = "$profile" ]; then
    extradefines="$extradefines -DRB_PROFILE"
    PROFILE_OPTS="-finstrument-functions"
  fi
}

# Configure voice settings
voiceconfig () {
    thislang=$1
    echo "Building $thislang voice for $modelname. Select options"
    echo ""

    if [ -f "`which flite`" ]; then
        FLITE="F(l)ite "
        FLITE_OPTS=""
        DEFAULT_TTS="flite"
        DEFAULT_TTS_OPTS=$FLITE_OPTS
        DEFAULT_NOISEFLOOR="500"
        DEFAULT_CHOICE="L"
    fi
    if [ -f "`which espeak`" ]; then
        ESPEAK="(e)Speak "
        ESPEAK_OPTS=""
        DEFAULT_TTS="espeak"
        DEFAULT_TTS_OPTS=$ESPEAK_OPTS
        DEFAULT_NOISEFLOOR="500"
        DEFAULT_CHOICE="e"
    fi
    if [ -f "`which festival`" ]; then
        FESTIVAL="(F)estival "
        case "$thislang" in
            "italiano")
            FESTIVAL_OPTS="--language italian"
            ;;
            "espanol")
            FESTIVAL_OPTS="--language spanish"
            ;;
            "finnish")
            FESTIVAL_OPTS="--language finnish"
            ;;
            "czech")
            FESTIVAL_OPTS="--language czech"
            ;;
            *)
            FESTIVAL_OPTS=""
            ;;
        esac
        DEFAULT_TTS="festival"
        DEFAULT_TTS_OPTS=$FESTIVAL_OPTS
        DEFAULT_NOISEFLOOR="500"
        DEFAULT_CHOICE="F"
    fi
    if [ -f "`which swift`" ]; then
        SWIFT="S(w)ift "
        SWIFT_OPTS=""
        DEFAULT_TTS="swift"
        DEFAULT_TTS_OPTS=$SWIFT_OPTS
        DEFAULT_NOISEFLOOR="500"
        DEFAULT_CHOICE="w"
    fi
    # Allow SAPI if Windows is in use
    if [ -f "`which winver`" ]; then
        SAPI="(S)API "
        SAPI_OPTS=""
        DEFAULT_TTS="sapi"
        DEFAULT_TTS_OPTS=$SAPI_OPTS
        DEFAULT_NOISEFLOOR="500"
        DEFAULT_CHOICE="S"
    fi

    if [ "$FESTIVAL" = "$FLITE" ] && [ "$FLITE" = "$ESPEAK" ] && [ "$ESPEAK" = "$SAPI" ] && [ "$SAPI" = "$SWIFT" ]; then
        echo "You need Festival, eSpeak or Flite in your path, or SAPI available to build voice files"
        exit
    fi

    echo "TTS engine to use: ${FLITE}${FESTIVAL}${ESPEAK}${SAPI}${SWIFT}(${DEFAULT_CHOICE})?"
    option=`input`
    case "$option" in
        [Ll])
        TTS_ENGINE="flite"
        NOISEFLOOR="500" # TODO: check this value
        TTS_OPTS=$FLITE_OPTS
        ;;
        [Ee])
        TTS_ENGINE="espeak"
        NOISEFLOOR="500"
        TTS_OPTS=$ESPEAK_OPTS
        ;;
        [Ff])
        TTS_ENGINE="festival"
        NOISEFLOOR="500"
        TTS_OPTS=$FESTIVAL_OPTS
        ;;
        [Ss])
        TTS_ENGINE="sapi"
        NOISEFLOOR="500"
        TTS_OPTS=$SAPI_OPTS
        ;;
	[Ww])
        TTS_ENGINE="swift"
        NOISEFLOOR="500"
        TTS_OPTS=$SWIFT_OPTS
	;;
        *)
        TTS_ENGINE=$DEFAULT_TTS
        TTS_OPTS=$DEFAULT_TTS_OPTS
        NOISEFLOOR=$DEFAULT_NOISEFLOOR
    esac
    echo "Using $TTS_ENGINE for TTS"

    # Allow the user to input manual commandline options
    printf "Enter $TTS_ENGINE options (enter for defaults \"$TTS_OPTS\"): "
    USER_TTS_OPTS=`input`
    if [ -n "$USER_TTS_OPTS" ]; then
        TTS_OPTS="$USER_TTS_OPTS"
    fi

    echo ""

    if [ "$swcodec" = "yes" ]; then
        ENCODER="rbspeexenc"
        ENC_CMD="rbspeexenc"
        ENC_OPTS="-q 4 -c 10"
    else
        if [ -f "`which lame`" ]; then
            ENCODER="lame"
            ENC_CMD="lame"
            ENC_OPTS="--resample 12 -t -m m -h -V 9 -S -B 64 --vbr-new"
         else
            echo "You need LAME in the system path to build voice files for"
            echo "HWCODEC targets."
            exit
         fi
    fi
 
    echo "Using $ENCODER for encoding voice clips"

    # Allow the user to input manual commandline options
    printf "Enter $ENCODER options (enter for defaults \"$ENC_OPTS\"): "
    USER_ENC_OPTS=`input`
    if [ -n "$USER_ENC_OPTS" ]; then
        ENC_OPTS=$USER_ENC_OPTS
    fi

    TEMPDIR="${pwd}"
    if [ -f "`which cygpath`" ]; then
        TEMPDIR=`cygpath . -a -w`
    fi
}

picklang() {
    # figure out which languages that are around
    for file in $rootdir/apps/lang/*.lang; do
        clean=`echo $file | sed -e 's:.*/::g' | cut "-d." -f1`
        langs="$langs $clean"
    done

    num=1
    for one in $langs; do
        echo "$num. $one"
        num=`expr $num + 1`
    done

    read pick
}

whichlang() {
    output=""
    # Allow the user to pass a comma-separated list of langauges
    for thispick in `echo $pick | sed 's/,/ /g'`; do
        num=1
        for one in $langs; do
            # Accept both the language number and name
            if [ "$num" = "$thispick" ] || [ "$thispick" = "$one" ]; then
                if [ "$output" = "" ]; then
                    output=$one
                else
                    output=$output,$one
                fi
            fi
            num=`expr $num + 1`
        done
    done
    echo $output
}

opt=$1

if test "$opt" = "--help"; then
  echo "Rockbox configure script."
  echo "Invoke this in a directory to generate a Makefile to build Rockbox"
  echo "Do *NOT* run this within the tools directory!"
  echo ""
cat <<EOF
  Usage: configure [OPTION]...
  Options:
    --target=TARGET   Sets the target, TARGET can be either the target ID or
                      corresponding string. Run without this option to see the
                      available targets.

    --ram=RAM         Sets the RAM for certain targets. Even though any number
                      is accepted, not every number is correct. The default
                      value will be applied, if you entered a wrong number
                      (which depends on the target). Watch the output.  Run
                      without this option if you are not sure which the right
                      number is.

    --type=TYPE       Sets the build type. The shortcut is valied.
                      Run without this option to see available types.
    --ccache          Enable ccache use (done by default these days)
    --no-ccache       Disable ccache use
    --help            Shows this message (must not be used with other options)

EOF

  exit
fi

if test -r "configure"; then
 # this is a check for a configure script in the current directory, it there
 # is one, try to figure out if it is this one!

 if { grep "^#   Jukebox" configure >/dev/null 2>&1 ; } then
   echo "WEEEEEEEEP. Don't run this configure script within the tools directory."
   echo "It will only cause you pain and grief. Instead do this:"
   echo ""
   echo " cd .."
   echo " mkdir build-dir"
   echo " cd build-dir"
   echo " ../tools/configure"
   echo ""
   echo "Much happiness will arise from this. Enjoy"
   exit
 fi
fi

# get our current directory
pwd=`pwd`;

if { echo $pwd | grep " "; } then
  echo "You're running this script in a path that contains space. The build"
  echo "system is unfortunately not clever enough to deal with this. Please"
  echo "run the script from a different path, rename the path or fix the build"
  echo "system!"
  exit
fi

if [ -z "$rootdir" ]; then
  ##################################################################
  # Figure out where the source code root is!
  #
  rootdir=`dirname $0`/../

  #####################################################################
  # Convert the possibly relative directory name to an absolute version
  #
  now=`pwd`
  cd $rootdir
  rootdir=`pwd`

  # cd back to the build dir
  cd $now
fi

apps="apps"
appsdir='\$(ROOTDIR)/apps'
firmdir='\$(ROOTDIR)/firmware'
toolsdir='\$(ROOTDIR)/tools'


##################################################################
# Figure out target platform
#

if [ "1" != `parse_args --target` ]; then
  buildfor=`parse_args --target`;
else
  echo "Enter target platform:"
cat <<EOF
 ==Archos==            ==iriver==             ==Apple iPod==
  0) Player/Studio     10) H120/H140          20) Color/Photo
  1) Recorder          11) H320/H340          21) Nano
  2) FM Recorder       12) iHP-100/110/115    22) Video
  3) Recorder v2       13) iFP-790            23) 3G
  4) Ondio SP          14) H10 20Gb           24) 4G Grayscale
  5) Ondio FM          15) H10 5/6Gb          25) Mini 1G
  6) AV300                                    26) Mini 2G
                                              27) 1G, 2G

 ==iAudio==            ==Toshiba==            ==SanDisk==
 30) X5/X5V/X5L        40) Gigabeat F         50) Sansa e200
 31) M5/M5L            41) Gigabeat S         51) Sansa e200R
 32) 7                                        52) Sansa c200
 33) Cowon D2                                 53) Sansa m200
 34) M3/M3L                                   54) Sansa c100

 ==Tatung==            ==Olympus==            ==Logik==
 60) Elio TPJ-1022     70) M:Robe 500         80) DAX 1GB MP3/DAB
                       71) M:Robe 100

 ==Creative==          ==Philips==
 90) Zen Vision:M 30GB 100) GoGear SA9200
 91) Zen Vision:M 60GB
 92) Zen Vision

EOF

  buildfor=`input`;

fi
  # Set of tools built for all target platforms:
  toolset="rdf2binary convbdf codepages"

  # Toolsets for some target families:
  archosbitmaptools="$toolset scramble descramble sh2d uclpack bmp2rb"
  iriverbitmaptools="$toolset scramble descramble mkboot bmp2rb"
  iaudiobitmaptools="$toolset scramble descramble mkboot bmp2rb"
  ipodbitmaptools="$toolset scramble bmp2rb"
  gigabeatbitmaptools="$toolset scramble descramble bmp2rb"
  tccbitmaptools="$toolset scramble mktccboot bmp2rb"
  # generic is used by IFP, H10, Sansa-e200
  genericbitmaptools="$toolset bmp2rb"


  #  ---- For each target ----
  #
  #   *Variables*
  # target_id: a unique number identifying this target, IS NOT the menu number.
  #            Just use the currently highest number+1 when you add a new
  #            target.
  # modelname: short model name used all over to identify this target
  # memory:    number of megabytes of RAM this target has. If the amount can
  #            be selected by the size prompt, let memory be unset here
  # target:    -Ddefine passed to the build commands to make the correct
  #            config-*.h file get included etc
  # tool:      the tool that takes a plain binary and converts that into a
  #            working "firmware" file for your target
  # output:    the final output file name
  # boottool:  the tool that takes a plain binary and generates a bootloader
  #            file for your target (or blank to use $tool)
  # bootoutput:the final output file name for the bootloader (or blank to use
  #            $output)
  # appextra:  passed to the APPEXTRA variable in the Makefiles.
  #            TODO: add proper explanation
  # archosrom: used only for Archos targets that build a special flashable .ucl
  #            image.
  # flash:     name of output for flashing, for targets where there's a special
  #            file output for this.
  # plugins:   set to 'yes' to build the plugins. Early development builds can
  #            set this to no in the early stages to have an easier life for a
  #            while
  # swcodec:   set 'yes' on swcodec targets
  # toolset:   lists what particular tools in the tools/ directory that this
  #            target needs to have built prior to building Rockbox
  #
  #   *Functions*
  # *cc:       sets up gcc and compiler options for your target builds. Note
  #            that if you select a simulator build, the compiler selection is
  #            overridden later in the script.

  case $buildfor in

   0|player)
    target_id=1
    modelname="player"
    target="-DARCHOS_PLAYER"
    shcc
    tool="$rootdir/tools/scramble"
    output="archos.mod"
    appextra="player:gui"
    archosrom="$pwd/rombox.ucl"
    flash="$pwd/rockbox.ucl"
    plugins="yes"
    swcodec=""

    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset="$toolset scramble descramble sh2d player_unifont uclpack"

    # Note: the convbdf is present in the toolset just because: 1) the
    # firmware/Makefile assumes it is present always, and 2) we will need it when we
    # build the player simulator

    t_cpu="sh"
    t_manufacturer="archos"
    t_model="player"
    ;;

   1|recorder)
    target_id=2
    modelname="recorder"
    target="-DARCHOS_RECORDER"
    shcc
    tool="$rootdir/tools/scramble"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 0"
    output="ajbrec.ajz"
    appextra="recorder:gui"
    #archosrom="$pwd/rombox.ucl"
    flash="$pwd/rockbox.ucl"
    plugins="yes"
    swcodec=""
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$archosbitmaptools
    t_cpu="sh"
    t_manufacturer="archos"
    t_model="recorder"
    ;;

   2|fmrecorder)
    target_id=3
    modelname="fmrecorder"
    target="-DARCHOS_FMRECORDER"
    shcc
    tool="$rootdir/tools/scramble -fm"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 0"
    output="ajbrec.ajz"
    appextra="recorder:gui"
    #archosrom="$pwd/rombox.ucl"
    flash="$pwd/rockbox.ucl"
    plugins="yes"
    swcodec=""
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$archosbitmaptools
    t_cpu="sh"
    t_manufacturer="archos"
    t_model="fm_v2"
    ;;

   3|recorderv2)
    target_id=4
    modelname="recorderv2"
    target="-DARCHOS_RECORDERV2"
    shcc
    tool="$rootdir/tools/scramble -v2"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 0"
    output="ajbrec.ajz"
    appextra="recorder:gui"
    #archosrom="$pwd/rombox.ucl"
    flash="$pwd/rockbox.ucl"
    plugins="yes"
    swcodec=""
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$archosbitmaptools
    t_cpu="sh"
    t_manufacturer="archos"
    t_model="fm_v2"
    ;;

   4|ondiosp)
    target_id=7
    modelname="ondiosp"
    target="-DARCHOS_ONDIOSP"
    shcc
    tool="$rootdir/tools/scramble -osp"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 0"
    output="ajbrec.ajz"
    appextra="recorder:gui"
    archosrom="$pwd/rombox.ucl"
    flash="$pwd/rockbox.ucl"
    plugins="yes"
    swcodec=""
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$archosbitmaptools
    t_cpu="sh"
    t_manufacturer="archos"
    t_model="ondio"
    ;;

   5|ondiofm)
    target_id=8
    modelname="ondiofm"
    target="-DARCHOS_ONDIOFM"
    shcc
    tool="$rootdir/tools/scramble -ofm"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 0"
    output="ajbrec.ajz"
    appextra="recorder:gui"
    #archosrom="$pwd/rombox.ucl"
    flash="$pwd/rockbox.ucl"
    plugins="yes"
    swcodec=""
    toolset=$archosbitmaptools
    t_cpu="sh"
    t_manufacturer="archos"
    t_model="ondio"
    ;;

   6|av300)
    target_id=38
    modelname="av300"
    target="-DARCHOS_AV300"
    memory=16 # always
    arm7tdmicc
    tool="$rootdir/tools/scramble -mm=C"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 6"
    output="cjbm.ajz"
    appextra="recorder:gui"
    plugins="yes"
    swcodec=""
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset="$toolset scramble descramble bmp2rb"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="archos"
    t_model="av300"
    ;;

  10|h120)
    target_id=9
    modelname="h120"
    target="-DIRIVER_H120"
    memory=32 # always
    coldfirecc
    tool="$rootdir/tools/scramble -add=h120"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 2"
    bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0"
    output="rockbox.iriver"
    appextra="recorder:gui"
    flash="$pwd/rombox.iriver"
    plugins="yes"
    swcodec="yes"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$iriverbitmaptools
    t_cpu="coldfire"
    t_manufacturer="iriver"
    t_model="h100"
    ;;

   11|h300)
    target_id=10
    modelname="h300"
    target="-DIRIVER_H300"
    memory=32 # always
    coldfirecc
    tool="$rootdir/tools/scramble -add=h300"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
    bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0"
    output="rockbox.iriver"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$iriverbitmaptools
    t_cpu="coldfire"
    t_manufacturer="iriver"
    t_model="h300"
    ;;

   12|h100)
    target_id=11
    modelname="h100"
    target="-DIRIVER_H100"
    memory=16 # always
    coldfirecc
    tool="$rootdir/tools/scramble -add=h100"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 2"
    bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0"
    output="rockbox.iriver"
    appextra="recorder:gui"
    flash="$pwd/rombox.iriver"
    plugins="yes"
    swcodec="yes"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$iriverbitmaptools
    t_cpu="coldfire"
    t_manufacturer="iriver"
    t_model="h100"
    ;;

   13|ifp7xx)
    target_id=19
    modelname="ifp7xx"
    target="-DIRIVER_IFP7XX"
    memory=1
    arm7tdmicc short
    tool="cp"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 0"
    output="rockbox.wma"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$genericbitmaptools
    t_cpu="arm"
    t_manufacturer="pnx0101"
    t_model="iriver-ifp7xx"
    ;;

   14|h10)
    target_id=22
    modelname="h10"
    target="-DIRIVER_H10"
    memory=32 # always
    arm7tdmicc
    tool="$rootdir/tools/scramble -mi4v3 -model=h10 -type=RBOS"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 5"
    output="rockbox.mi4"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    boottool="$rootdir/tools/scramble -mi4v3 -model=h10 -type=RBBL"
    bootoutput="H10_20GC.mi4"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset="$genericbitmaptools scramble"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="iriver"
    t_model="h10"
    ;;

   15|h10_5gb)
    target_id=24
    modelname="h10_5gb"
    target="-DIRIVER_H10_5GB"
    memory=32 # always
    arm7tdmicc
    tool="$rootdir/tools/scramble -mi4v2 -model=h105 -type=RBOS"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 5"
    output="rockbox.mi4"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    boottool="$rootdir/tools/scramble -mi4v2 -model=h105 -type=RBBL"
    bootoutput="H10.mi4"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset="$genericbitmaptools scramble"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="iriver"
    t_model="h10"
    ;;

   20|ipodcolor)
    target_id=13
    modelname="ipodcolor"
    target="-DIPOD_COLOR"
    memory=32 # always
    arm7tdmicc
    tool="$rootdir/tools/scramble -add=ipco"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 5"
    output="rockbox.ipod"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    bootoutput="bootloader-$modelname.ipod"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$ipodbitmaptools
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="ipod"
    t_model="color"
    ;;

   21|ipodnano)
    target_id=14
    modelname="ipodnano"
    target="-DIPOD_NANO"
    memory=32 # always
    arm7tdmicc
    tool="$rootdir/tools/scramble -add=nano"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 5"
    output="rockbox.ipod"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    bootoutput="bootloader-$modelname.ipod"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$ipodbitmaptools
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="ipod"
    t_model="nano"
    ;;

   22|ipodvideo)
    target_id=15
    modelname="ipodvideo"
    target="-DIPOD_VIDEO"
    arm7tdmicc
    tool="$rootdir/tools/scramble -add=ipvd"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
    output="rockbox.ipod"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    bootoutput="bootloader-$modelname.ipod"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$ipodbitmaptools
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="ipod"
    t_model="video"
    ;;

   23|ipod3g)
    target_id=16
    modelname="ipod3g"
    target="-DIPOD_3G"
    memory=32 # always
    arm7tdmicc
    tool="$rootdir/tools/scramble -add=ip3g"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 6"
    output="rockbox.ipod"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    bootoutput="bootloader-$modelname.ipod"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$ipodbitmaptools
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="ipod"
    t_model="3g"
    ;;

   24|ipod4g)
    target_id=17
    modelname="ipod4g"
    target="-DIPOD_4G"
    memory=32 # always
    arm7tdmicc
    tool="$rootdir/tools/scramble -add=ip4g"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 6"
    output="rockbox.ipod"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    bootoutput="bootloader-$modelname.ipod"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$ipodbitmaptools
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="ipod"
    t_model="4g"
    ;;

   25|ipodmini)
    target_id=18
    modelname="ipodmini"
    target="-DIPOD_MINI"
    memory=32 # always
    arm7tdmicc
    tool="$rootdir/tools/scramble -add=mini"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 6"
    output="rockbox.ipod"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    bootoutput="bootloader-$modelname.ipod"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$ipodbitmaptools
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="ipod"
    t_model="mini"
    ;;

   26|ipodmini2g)
    target_id=21
    modelname="ipodmini2g"
    target="-DIPOD_MINI2G"
    memory=32 # always
    arm7tdmicc
    tool="$rootdir/tools/scramble -add=mn2g"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 6"
    output="rockbox.ipod"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    bootoutput="bootloader-$modelname.ipod"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$ipodbitmaptools
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="ipod"
    t_model="mini2g"
    ;;

   27|ipod1g2g)
    target_id=29
    modelname="ipod1g2g"
    target="-DIPOD_1G2G"
    memory=32 # always
    arm7tdmicc
    tool="$rootdir/tools/scramble -add=1g2g"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 6"
    output="rockbox.ipod"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    bootoutput="bootloader-$modelname.ipod"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$ipodbitmaptools
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="ipod"
    t_model="1g2g"
    ;;

   30|x5)
    target_id=12
    modelname="x5"
    target="-DIAUDIO_X5"
    memory=16 # always
    coldfirecc
    tool="$rootdir/tools/scramble -add=iax5"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
    bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 7"
    output="rockbox.iaudio"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset="$iaudiobitmaptools"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="coldfire"
    t_manufacturer="iaudio"
    t_model="x5"
    ;;

   31|m5)
    target_id=28
    modelname="m5"
    target="-DIAUDIO_M5"
    memory=16 # always
    coldfirecc
    tool="$rootdir/tools/scramble -add=iam5"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 2"
    bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 7"
    output="rockbox.iaudio"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset="$iaudiobitmaptools"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="coldfire"
    t_manufacturer="iaudio"
    t_model="m5"
    ;;

   32|iaudio7)
    target_id=32
    modelname="iaudio7"
    target="-DIAUDIO_7"
    memory=16 # always
    arm946cc
    tool="$rootdir/tools/scramble -add i7"
    boottool="$rootdir/tools/scramble -tcc=crc"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 5"
    output="rockbox.iaudio"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    bootoutput="I7_FW.BIN"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset="$tccbitmaptools"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="tcc77x"
    t_model="iaudio7"
    ;;

    33|cowond2)
    target_id=34
    modelname="cowond2"
    target="-DCOWON_D2"
    memory=32
    arm926ejscc
    tool="$rootdir/tools/scramble -add=d2"
    boottool="$rootdir/tools/scramble -tcc=crc"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
    bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0"
    output="rockbox.iaudio"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    toolset="$tccbitmaptools"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="tcc780x"
    t_model="cowond2"
    ;;
    
   34|m3)
    target_id=37
    modelname="m3"
    target="-DIAUDIO_M3"
    memory=16 # always
    coldfirecc
    tool="$rootdir/tools/scramble -add=iam3"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 7"
    output="rockbox.iaudio"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset="$iaudiobitmaptools"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="coldfire"
    t_manufacturer="iaudio"
    t_model="m3"
    ;;

   40|gigabeatf)
    target_id=20
    modelname="gigabeatf"
    target="-DGIGABEAT_F"
    memory=32 # always
    arm9tdmicc
    tool="$rootdir/tools/scramble -add=giga"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
    output="rockbox.gigabeat"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    toolset=$gigabeatbitmaptools
    boottool="$rootdir/tools/scramble -gigabeat"
    bootoutput="FWIMG01.DAT"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="s3c2440"
    t_model="gigabeat-fx"
    ;;

    41|gigabeats)
    target_id=26
    modelname="gigabeats"
    target="-DGIGABEAT_S"
    memory=64
    arm1136jfscc
    tool="$rootdir/tools/scramble -add=gigs"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
    output="rockbox.gigabeat"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    toolset="$gigabeatbitmaptools mknkboot"
    boottool="$rootdir/tools/scramble -gigabeats"
    bootoutput="nk.bin"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="imx31"
    t_model="gigabeat-s"
    ;;

    70|mrobe500)
    target_id=36
    modelname="mrobe500"
    target="-DMROBE_500"
    memory=64 # always
    arm926ejscc
    # tool="$rootdir/tools/scramble -add=m500"
    tool="cp "
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
    bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0"
    output="rockbox.mrobe500"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    toolset=$gigabeatbitmaptools
    boottool="cp "
    bootoutput="rockbox.mrboot"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="tms320dm320"
    t_model="mrobe-500"
    ;;

   71|mrobe100)
    target_id=33
    modelname="mrobe100"
    target="-DMROBE_100"
    memory=32 # always
    arm7tdmicc
    tool="$rootdir/tools/scramble -mi4v2 -model=m100 -type=RBOS"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0"
    output="rockbox.mi4"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    boottool="$rootdir/tools/scramble -mi4v2 -model=m100 -type=RBBL"
    bootoutput="pp5020.mi4"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset="$genericbitmaptools scramble"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="olympus"
    t_model="mrobe-100"
    ;;

   80|logikdax)
    target_id=31
    modelname="logikdax"
    target="-DLOGIK_DAX"
    memory=2 # always
    arm946cc
    tool="$rootdir/tools/scramble -add=ldax"
    boottool="$rootdir/tools/scramble -tcc=crc"
    bootoutput="player.rom"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 0"
    output="rockbox.logik"
    appextra="recorder:gui"
    plugins=""
    swcodec="yes"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$tccbitmaptools
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="tcc77x"
    t_model="logikdax"
    ;;
	
    90|creativezvm30gb)
    target_id=35
    modelname="creativezvm30"
    target="-DCREATIVE_ZVM"
    memory=64
    arm926ejscc
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
    bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0"
    tool="$rootdir/tools/scramble -creative=zvm"
    USE_ELF="yes"
    output="rockbox.zvm"
    appextra="recorder:gui"
    plugins=""
    swcodec="yes"
    toolset=$ipodbitmaptools
    boottool="$rootdir/tools/scramble -creative=zvm"
    bootoutput="rockbox.zvmboot"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="tms320dm320"
    t_model="creative-zvm"
    ;;
    
    91|creativezvm60gb)
    target_id=40
    modelname="creativezvm60"
    target="-DCREATIVE_ZVM60GB"
    memory=64
    arm926ejscc
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
    bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0"
    tool="$rootdir/tools/scramble -creative=zvm60"
    USE_ELF="yes"
    output="rockbox.zvm60"
    appextra="recorder:gui"
    plugins=""
    swcodec="yes"
    toolset=$ipodbitmaptools
    boottool="$rootdir/tools/scramble -creative=zvm60"
    bootoutput="rockbox.zvm60boot"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="tms320dm320"
    t_model="creative-zvm"
    ;;
    
    92|creativezenvision)
    target_id=39
    modelname="creativezv"
    target="-DCREATIVE_ZV"
    memory=64
    arm926ejscc
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
    bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0"
    tool="$rootdir/tools/scramble -creative=zenvision"
    USE_ELF="yes"
    output="rockbox.zv"
    appextra="recorder:gui"
    plugins=""
    swcodec="yes"
    toolset=$ipodbitmaptools
    boottool="$rootdir/tools/scramble -creative=zenvision"
    bootoutput="rockbox.zvboot"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="tms320dm320"
    t_model="creative-zvm"
    ;;

   50|e200)
    target_id=23
    modelname="e200"
    target="-DSANSA_E200"
    memory=32 # supposedly
    arm7tdmicc
    tool="$rootdir/tools/scramble -mi4v3 -model=e200 -type=RBOS"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
    output="rockbox.mi4"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    boottool="$rootdir/tools/scramble -mi4v3 -model=e200 -type=RBBL"
    bootoutput="PP5022.mi4"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset="$genericbitmaptools scramble"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="sandisk"
    t_model="sansa-e200"
    ;;

   51|e200r)
    # the e200R model is pretty much identical to the e200, it only has a
    # different option to the scramble tool when building a bootloader and
    # makes the bootloader output file name in all lower case.
    target_id=27
    modelname="e200r"
    target="-DSANSA_E200"
    memory=32 # supposedly
    arm7tdmicc
    tool="$rootdir/tools/scramble -mi4v3 -model=e20r -type=RBOS"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
    output="rockbox.mi4"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    boottool="$rootdir/tools/scramble -mi4r -model=e20r -type=RBBL"
    bootoutput="pp5022.mi4"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset="$genericbitmaptools scramble"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="sandisk"
    t_model="sansa-e200"
    ;;

   52|c200)
    target_id=30
    modelname="c200"
    target="-DSANSA_C200"
    memory=32 # supposedly
    arm7tdmicc
    tool="$rootdir/tools/scramble -mi4v3 -model=c200 -type=RBOS"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
    output="rockbox.mi4"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    boottool="$rootdir/tools/scramble -mi4v3 -model=c200 -type=RBBL"
    bootoutput="firmware.mi4"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset="$genericbitmaptools scramble"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="sandisk"
    t_model="sansa-c200"
    ;;

   53|m200)
    target_id=31
    modelname="m200"
    target="-DSANSA_M200"
    memory=2 # always
    arm946cc
    tool="$rootdir/tools/scramble -add=m200"
    boottool="$rootdir/tools/scramble -tcc=crc"
    bootoutput="player.rom"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 0"
    output="rockbox.m200"
    appextra="recorder:gui"
    plugins=""
    swcodec="yes"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset=$tccbitmaptools
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="tcc77x"
    t_model="m200"
    ;;

   54|c100)
    target_id=42 
    modelname="c100" 
    target="-DSANSA_C100" # The #define used in firmware/export/config.h for conditional compilation     
    memory=32  # how many megabytes of RAM
    arm946cc # Which compiler to use, see the beginning of the file
    tool="$rootdir/tools/scramble -add=c100" # Which command to use for creating a rockbox binary to be loaded by the bootloader
	boottool="$rootdir/tools/scramble -tcc=crc"
    bootoutput="player.rom"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" # How to create a monochrome bitmap
    bmp2rb_native="$rootdir/tools/bmp2rb -f 4" # How to create a native bitmap
    output="rockbox.c100" # The name of the Rockbox binary file
    appextra="recorder:gui" # What directories in the apps/ tree to include in compilation
    plugins="" # Does it support plugins?
    toolset=$tccbitmaptools
    t_cpu="arm"
    t_manufacturer="tcc77x"
    t_model="c100"
    ;;

   60|tpj1022)
    target_id=25
    modelname="tpj1022"
    target="-DELIO_TPJ1022"
    memory=32 # always
    arm7tdmicc
    tool="$rootdir/tools/scramble -add tpj2"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 5"
    output="rockbox.elio"
    appextra="recorder:gui"
    plugins="yes"
    swcodec="yes"
    boottool="$rootdir/tools/scramble -mi4v2"
    bootoutput="pp5020.mi4"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset="$genericbitmaptools scramble"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="tatung"
    t_model="tpj1022"
    ;;

   100|sa9200)
    target_id=41
    modelname="sa9200"
    target="-DPHILIPS_SA9200"
    memory=32 # supposedly
    arm7tdmicc
    tool="$rootdir/tools/scramble -mi4v3 -model=9200 -type=RBOS"
    bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
    bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
    output="rockbox.mi4"
    appextra="recorder:gui"
    plugins=""
    swcodec="yes"
    boottool="$rootdir/tools/scramble -mi4v3 -model=9200 -type=RBBL"
    bootoutput="FWImage.ebn"
    # toolset is the tools within the tools directory that we build for
    # this particular target.
    toolset="$genericbitmaptools scramble"
    # architecture, manufacturer and model for the target-tree build
    t_cpu="arm"
    t_manufacturer="philips"
    t_model="sa9200"
    ;;

   *)
    echo "Please select a supported target platform!"
    exit
    ;;

  esac

  echo "Platform set to $modelname"


#remove start
############################################################################
# Amount of memory, for those that can differ. They have $memory unset at
# this point.
#

if [ -z "$memory" ]; then
  case $target_id in
  15)
    echo "Enter size of your RAM (in MB): (Defaults to 32)"
    if [ "1" != `parse_args --ram` ]; then
      size=`parse_args --ram`;
    else
      size=`input`;
    fi
    case $size in
    60|64)
      memory="64"
      ;;
    *)
      memory="32"
      ;;
    esac
    ;;
  *)
    echo "Enter size of your RAM (in MB): (Defaults to 2)"
      if [ "1" != `parse_args --ram` ]; then
        size=`parse_args --ram`;
      else
        size=`input`;
      fi
      case $size in
      8)
        memory="8"
        ;;
      *)
        memory="2"
        ;;
      esac
    ;;
  esac
  echo "Memory size selected: $memory MB"
  echo ""
fi
#remove end

##################################################################
# Figure out build "type"
#

  # the ifp7x0 is the only platform that supports building a gdb stub like
  # this
case $modelname in
  ifp7xx)
     gdbstub="(G)DB stub, "
     ;;
  e200r|e200)
     gdbstub="(I)installer, "
     ;;
  *)
     ;;
esac
if [ "1" != `parse_args --type` ]; then
  option=`parse_args --type`;
else
  echo "Build (N)ormal, (A)dvanced, (S)imulator, (B)ootloader, $gdbstub(M)anual: (Defaults to N)"
  option=`input`;
fi

  case $option in
    [Ii])
      appsdir='\$(ROOTDIR)/bootloader'
      apps="bootloader"
      extradefines="-DBOOTLOADER -DE200R_INSTALLER -ffunction-sections -fdata-sections"
      bootloader="1"
      echo "e200R-installer build selected"
      ;;
    [Bb])
      if test $t_manufacturer = "archos"; then
          # Archos SH-based players do this somewhat differently for
          # some reason
          appsdir='\$(ROOTDIR)/flash/bootbox'
          apps="bootbox"
      else
          appsdir='\$(ROOTDIR)/bootloader'
          apps="bootloader"
          flash=""
          if test -n "$boottool"; then
              tool="$boottool"
          fi
          if test -n "$bootoutput"; then
              output=$bootoutput
          fi
      fi
      extradefines="-DBOOTLOADER -ffunction-sections -fdata-sections"
      bootloader="1"
      echo "Bootloader build selected"
      ;;
    [Ss])
      debug="-DDEBUG"
      simulator="yes"
      extradefines="-DSIMULATOR"
      echo "Simulator build selected"
      ;;
    [Aa])
      echo "Advanced build selected"
      whichadvanced
      ;;
    [Gg])
      extradefines="-DSTUB" # for target makefile symbol EXTRA_DEFINES
      appsdir='\$(ROOTDIR)/gdb'
      apps="stub"
      case $modelname in
          ifp7xx)
              output="stub.wma"
              ;;
          *)
              ;;
      esac
      echo "GDB stub build selected"
      ;;
    [Mm])
      toolset='';
      apps="manual"
      echo "Manual build selected"
      ;;
    *)
      if [ "$modelname" = "e200r" ]; then
          echo "Do not use the e200R target for regular builds.  Use e200 instead."
          exit
      fi
      debug=""
      echo "Normal build selected"
      ;;

  esac
  # to be able running "make manual" from non-manual configuration
  case $modelname in
      fmrecorder)
          manualdev="recorderv2fm"
          ;;
      recorderv2)
          manualdev="recorderv2fm"
          ;;
      h1??)
          manualdev="h1xx"
          ;;
      ipodmini2g)
          manualdev="ipodmini"
          ;;
      *)
          manualdev=$modelname
          ;;
  esac

if [ -z "$debug" ]; then
  GCCOPTS="$GCCOPTS $GCCOPTIMIZE"
fi

echo "Using source code root directory: $rootdir"

# this was once possible to change at build-time, but no more:
language="english"

uname=`uname`

if [ "yes" = "$simulator" ]; then
  # setup compiler and things for simulator
  simcc

  if [ -d "archos" ]; then
    echo "sub directory archos already present"
  else
    mkdir archos
    echo "created an archos subdirectory for simulating the hard disk"
  fi
fi

# Now, figure out version number of the (gcc) compiler we are about to use
gccver=`$CC -dumpversion`;

# figure out the binutil version too and display it, mostly for the build
# system etc to be able to see it easier
ldver=`$LD --version | head -n 1 | sed -e 's/[^0-9.]//g'`

if [ -z "$gccver" ]; then
  echo "WARNING: The compiler you must use ($CC) is not in your path!"
  echo "WARNING: this may cause your build to fail since we cannot do the"
  echo "WARNING: checks we want now."
else

  # gccver should now be "3.3.5", "3.4.3", "2.95.3-6" and similar, but don't
  # DEPEND on it

 num1=`echo $gccver | cut -d . -f1`
 num2=`echo $gccver | cut -d . -f2`
 gccnum=`(expr $num1 "*" 100 + $num2) 2>/dev/null`

 # This makes:
 # 3.3.X  => 303
 # 3.4.X  => 304
 # 2.95.3 => 295

 echo "Using $CC $gccver ($gccnum)"

 if test "$gccnum" -ge "400"; then
   # gcc 4.0 is just *so* much pickier on arguments that differ in signedness
   # so we ignore that warnings for now
   # -Wno-pointer-sign
   GCCOPTS="$GCCOPTS -Wno-pointer-sign"
 fi

 if test "$gccnum" -ge "401"; then
   # this is a lame hack to avoid "warning: dereferencing type-punned pointer
   # will break strict-aliasing rules"

   GCCOPTS="$GCCOPTS -fno-strict-aliasing"
 fi

 if test "$gccnum" -ge "402"; then
   # disable warning about "warning: initialized field overwritten" as gcc 4.2
   # and later would throw it for several valid cases
   GCCOPTS="$GCCOPTS -Wno-override-init"
 fi

 case $prefix in
   "")
     # simulator
   ;;
   i586-mingw32msvc-)
     # cross-compile for win32
   ;;
   *)
   # Verify that the cross-compiler is of a recommended version!
   if test "$gccver" != "$gccchoice"; then
     echo "WARNING: Your cross-compiler $CC $gccver is not of the recommended"
     echo "WARNING: version $gccchoice!"
     echo "WARNING: This may cause your build to fail since it may be a version"
     echo "WARNING: that isn't functional or known to not be the best choice."
     echo "WARNING: If you suffer from build problems, you know that this is"
     echo "WARNING: a likely source for them..."
   fi
   ;;
 esac

fi


echo "Using $LD $ldver"

# check the compiler for SH platforms
if test "$CC" = "sh-elf-gcc"; then
  if test "$gccnum" -lt "400"; then
    echo "WARNING: Consider upgrading your compiler to the 4.0.X series!"
    echo "WARNING: http://www.rockbox.org/twiki/bin/view/Main/CrossCompiler"
  else
    # figure out patch status
    gccpatch=`$CC --version`;

    if { echo $gccpatch | grep "rockbox" >/dev/null 2>&1; } then
      echo "gcc $gccver is rockbox patched"
      # then convert -O to -Os to get smaller binaries!
      GCCOPTS=`echo $GCCOPTS | sed 's/ -O / -Os /'`
    else
      echo "WARNING: You use an unpatched gcc compiler: $gccver"
      echo "WARNING: http://www.rockbox.org/twiki/bin/view/Main/CrossCompiler"
    fi
  fi
fi

if test "$CC" = "m68k-elf-gcc"; then
  # convert -O to -Os to get smaller binaries!
  GCCOPTS=`echo $GCCOPTS | sed 's/ -O / -Os /'`
fi
  for path in $PATH
  do
    # echo "checks for $file in $path" >&2
    if test -f "$path/$file"; then
      echo "$path/$file"
      return
    fi
  done

if [ "1" != `parse_args --ccache` ]; then
  echo "Enable ccache for building"
  ccache="ccache"
else
  if [ "1" = `parse_args --no-ccache` ]; then
    ccache=`findtool ccache`
    if test -n "$ccache"; then
      echo "Found and uses ccache ($ccache)"
    fi
  fi
fi

if test -n "$ccache"; then
  CC="$ccache $CC"
fi

if test "X$endian" = "Xbig"; then
  defendian="ROCKBOX_BIG_ENDIAN"
else
  defendian="ROCKBOX_LITTLE_ENDIAN"
fi

sed > autoconf.h \
 -e "s,@ENDIAN@,${defendian},g" \
 -e "s,^#undef ROCKBOX_HAS_LOGF,$use_logf,g" \
 -e "s,@config_rtc@,$config_rtc,g" \
 -e "s,@have_rtc_alarm@,$have_rtc_alarm,g" \
<<EOF
/* This header was made by configure */
#ifndef __BUILD_AUTOCONF_H
#define __BUILD_AUTOCONF_H

/* Define endianess for the target or simulator platform */
#define @ENDIAN@ 1

/* Define this if you build rockbox to support the logf logging and display */
#undef ROCKBOX_HAS_LOGF

/* optional defines for RTC mod for h1x0 */
@config_rtc@
@have_rtc_alarm@

#endif /* __BUILD_AUTOCONF_H */
EOF

if test -n "$t_cpu"; then
  TARGET_INC="-I\$(FIRMDIR)/target/$t_cpu/$t_manufacturer/$t_model"
  TARGET_INC="$TARGET_INC -I\$(FIRMDIR)/target/$t_cpu/$t_manufacturer"
  TARGET_INC="$TARGET_INC -I\$(FIRMDIR)/target/$t_cpu"
  GCCOPTS="$GCCOPTS"
fi

if test "$simulator" = "yes"; then
  # add simul make stuff on the #SIMUL# line
  simmagic1="s,@SIMUL1@,\$(SILENT)\$(MAKE) -C \$(SIMDIR) OBJDIR=\$(BUILDDIR)/sim,"
  simmagic2="s,@SIMUL2@,\$(SILENT)\$(MAKE) -C \$(ROOTDIR)/uisimulator/common OBJDIR=\$(BUILDDIR)/comsim,"
else
  # delete the lines that match
  simmagic1='/@SIMUL1@/D'
  simmagic2='/@SIMUL2@/D'
fi

if test "$swcodec" = "yes"; then
  voicetoolset="rbspeexenc voicefont wavtrim"
else
  voicetoolset="voicefont wavtrim"
fi

if test "$apps" = "apps"; then
  # only when we build "real" apps we build the .lng files
  buildlangs="langs"
fi

sed > Makefile \
 -e "s,@ROOTDIR@,${rootdir},g" \
 -e "s,@DEBUG@,${debug},g" \
 -e "s,@MEMORY@,${memory},g" \
 -e "s,@TARGET_ID@,${target_id},g" \
 -e "s,@TARGET@,${target},g" \
 -e "s,@CPU@,${t_cpu},g" \
 -e "s,@MANUFACTURER@,${t_manufacturer},g" \
 -e "s,@MODELNAME@,${modelname},g" \
 -e "s,@LANGUAGE@,${language},g" \
 -e "s:@VOICELANGUAGE@:${voicelanguage}:g" \
 -e "s,@PWD@,${pwd},g" \
 -e "s,@CC@,${CC},g" \
 -e "s,@LD@,${LD},g" \
 -e "s,@AR@,${AR},g" \
 -e "s,@AS@,${AS},g" \
 -e "s,@OC@,${OC},g" \
 -e "s,@WINDRES@,${WINDRES},g" \
 -e "s,@DLLTOOL@,${DLLTOOL},g" \
 -e "s,@DLLWRAP@,${DLLWRAP},g" \
 -e "s,@RANLIB@,${RANLIB},g" \
 -e "s,@TOOL@,${tool},g" \
 -e "s,@BMP2RB_NATIVE@,${bmp2rb_native},g" \
 -e "s,@BMP2RB_MONO@,${bmp2rb_mono},g" \
 -e "s,@BMP2RB_REMOTENATIVE@,${bmp2rb_remotenative},g" \
 -e "s,@BMP2RB_REMOTEMONO@,${bmp2rb_remotemono},g" \
 -e "s,@OUTPUT@,${output},g" \
 -e "s,@APPEXTRA@,${appextra},g" \
 -e "s,@ARCHOSROM@,${archosrom},g" \
 -e "s,@FLASHFILE@,${flash},g" \
 -e "s,@PLUGINS@,${plugins},g" \
 -e "s,@CODECS@,${swcodec},g" \
 -e "s,@PROFILE_OPTS@,${PROFILE_OPTS},g" \
 -e "s,@SHARED_FLAG@,${SHARED_FLAG},g" \
 -e "s,@GCCOPTS@,${GCCOPTS},g" \
 -e "s,@TARGET_INC@,${TARGET_INC},g" \
 -e "s!@LDOPTS@!${LDOPTS}!g" \
 -e "s,@LOADADDRESS@,${loadaddress},g" \
 -e "s,@EXTRADEF@,${extradefines},g" \
 -e "s,@APPSDIR@,${appsdir},g" \
 -e "s,@FIRMDIR@,${firmdir},g" \
 -e "s,@TOOLSDIR@,${toolsdir},g" \
 -e "s,@APPS@,${apps},g" \
 -e "s,@SIMVER@,${simver},g" \
 -e "s,@GCCVER@,${gccver},g" \
 -e "s,@GCCNUM@,${gccnum},g" \
 -e "s,@UNAME@,${uname},g" \
 -e "s,@ENDIAN@,${defendian},g" \
 -e "s,@TOOLSET@,${toolset},g" \
 -e "${simmagic1}" \
 -e "${simmagic2}" \
 -e "s,@MANUALDEV@,${manualdev},g" \
 -e "s,@ENCODER@,${ENC_CMD},g" \
 -e "s,@ENC_OPTS@,${ENC_OPTS},g" \
 -e "s,@TTS_ENGINE@,${TTS_ENGINE},g" \
 -e "s,@TTS_OPTS@,${TTS_OPTS},g" \
 -e "s,@VOICETOOLSET@,${voicetoolset},g" \
 -e "s,@LANGS@,${buildlangs},g" \
 -e "s,@USE_ELF@,${USE_ELF},g" \
<<EOF
## Automatically generated. http://www.rockbox.org/

ifndef V
SILENT=@
else
VERBOSEOPT=-v
endif

# old 'make' versions don't have the built-in 'info' function
info=old\$(shell echo >&2 "Consider upgrading to GNU make 3.81+ for optimum build performance.")
ifeq (\$(call info),old)
export info=echo "\$\$(1)";
endif

export ROOTDIR=@ROOTDIR@
export FIRMDIR=@FIRMDIR@
export APPSDIR=@APPSDIR@
export TOOLSDIR=@TOOLSDIR@
export DOCSDIR=\$(ROOTDIR)/docs
export MANUALDIR=\${ROOTDIR}/manual
export DEBUG=@DEBUG@
export MODELNAME=@MODELNAME@
export ARCHOSROM=@ARCHOSROM@
export FLASHFILE=@FLASHFILE@
export TARGET_ID=@TARGET_ID@
export TARGET=@TARGET@
export CPU=@CPU@
export MANUFACTURER=@MANUFACTURER@
export OBJDIR=@PWD@
export BUILDDIR=@PWD@
export LANGUAGE=@LANGUAGE@
export VOICELANGUAGE=@VOICELANGUAGE@
export MEMORYSIZE=@MEMORY@
export VERSION=\$(shell \$(ROOTDIR)/tools/svnversion.sh \$(ROOTDIR))
export BUILDDATE=\$(shell date -u +'-DYEAR=%Y -DMONTH=%m -DDAY=%d')
export MKFIRMWARE=@TOOL@
export BMP2RB_MONO=@BMP2RB_MONO@
export BMP2RB_NATIVE=@BMP2RB_NATIVE@
export BMP2RB_REMOTEMONO=@BMP2RB_REMOTEMONO@
export BMP2RB_REMOTENATIVE=@BMP2RB_REMOTENATIVE@
export BINARY=@OUTPUT@
export APPEXTRA=@APPEXTRA@
export ENABLEDPLUGINS=@PLUGINS@
export SOFTWARECODECS=@CODECS@
export EXTRA_DEFINES=@EXTRADEF@
export HOSTCC=gcc
export HOSTAR=ar
export CC=@CC@
export LD=@LD@
export AR=@AR@
export AS=@AS@
export OC=@OC@
export WINDRES=@WINDRES@
export DLLTOOL=@DLLTOOL@
export DLLWRAP=@DLLWRAP@
export RANLIB=@RANLIB@
export PROFILE_OPTS=@PROFILE_OPTS@
export SIMVER=@SIMVER@
export SIMDIR=\$(ROOTDIR)/uisimulator/sdl
export GCCOPTS=@GCCOPTS@
export TARGET_INC=@TARGET_INC@
export LOADADDRESS=@LOADADDRESS@
export SHARED_FLAG=@SHARED_FLAG@
export LDOPTS=@LDOPTS@
export GCCVER=@GCCVER@
export GCCNUM=@GCCNUM@
export UNAME=@UNAME@
export MANUALDEV=@MANUALDEV@
export TTS_OPTS=@TTS_OPTS@
export TTS_ENGINE=@TTS_ENGINE@
export ENC_OPTS=@ENC_OPTS@
export ENCODER=@ENCODER@
export USE_ELF=@USE_ELF@

# Do not print "Entering directory ..."
MAKEFLAGS += --no-print-directory

.PHONY: all clean tags zip tools manual bin build info langs

all: info

info: build
	\$(SILENT)\$(TOOLSDIR)/mkinfo.pl \$(BUILDDIR)/rockbox-info.txt

build: tools @LANGS@
	@SIMUL1@
	@SIMUL2@
	\$(SILENT)\$(MAKE) -C \$(FIRMDIR) OBJDIR=\$(BUILDDIR)/firmware
	\$(SILENT)\$(MAKE) -C \$(APPSDIR) OBJDIR=\$(BUILDDIR)/@APPS@

bin: tools @LANGS@
	@SIMUL1@
	@SIMUL2@
	\$(SILENT)\$(MAKE) -C \$(FIRMDIR) OBJDIR=\$(BUILDDIR)/firmware
	\$(SILENT)\$(MAKE) -C \$(APPSDIR) OBJDIR=\$(BUILDDIR)/@APPS@ \$(BUILDDIR)/\$(BINARY)

rocks: tools
	\$(SILENT)\$(MAKE) -C \$(APPSDIR) OBJDIR=\$(BUILDDIR)/@APPS@ rocks

veryclean: clean toolsclean

toolsclean:
	\$(SILENT)\$(MAKE) -C \$(TOOLSDIR) clean

clean:
	\$(SILENT)echo Cleaning build directory
	\$(SILENT)rm -rf rockbox.zip TAGS @APPS@ firmware comsim sim lang.[ch]\
                  manual *.pdf *.a credits.raw @OUTPUT@ bitmaps pluginbitmaps \
                  @ARCHOSROM@ @FLASHFILE@ UI256.bmp rockbox-full.zip \
	          html txt rockbox-manual*.zip sysfont.h rockbox-info.txt \
	          voicefontids *.wav *.mp3 *.voice max_language_size.h

tools:
	\$(SILENT)\$(MAKE) -C \$(TOOLSDIR) CC=\$(HOSTCC) AR=\$(HOSTAR) @TOOLSET@

voicetools:
	\$(SILENT)\$(MAKE) -C \$(TOOLSDIR) CC=\$(HOSTCC) AR=\$(HOSTAR) @VOICETOOLSET@

tags:
	\$(SILENT)rm -f TAGS
	\$(SILENT)\$(MAKE) -C \$(FIRMDIR) tags
	\$(SILENT)\$(MAKE) -C \$(APPSDIR) tags
	\$(SILENT)\$(MAKE) -C \$(APPSDIR)/plugins tags
	\$(SILENT)\$(MAKE) -C \$(APPSDIR)/plugins/lib tags

fontzip:
	\$(SILENT)\$(TOOLSDIR)/buildzip.pl \$(VERBOSEOPT) -t \"\$(MODELNAME)\" -r "\$(ROOTDIR)" -f 1 -o rockbox-fonts.zip \$(TARGET) \$(BINARY)

zip:
	\$(SILENT)for f in \`cat \$(BUILDDIR)/@APPS@/features\`; do feat="\$\$feat:\$\$f" ; done ; \\
	\$(TOOLSDIR)/buildzip.pl \$(VERBOSEOPT) -t \"\$(MODELNAME)\$\$feat\" -i \"\$(TARGET_ID)\"  -r "\$(ROOTDIR)" \$(TARGET) \$(BINARY)

mapzip:
	\$(SILENT)find . -name "*.map" | xargs zip rockbox-maps.zip

fullzip:
	\$(SILENT)for f in \`cat \$(BUILDDIR)/@APPS@/features\`; do feat="\$\$feat:\$\$f" ; done; \\
	\$(TOOLSDIR)/buildzip.pl \$(VERBOSEOPT) -t \"\$(MODELNAME)\$\$feat\" -i \"\$(TARGET_ID)\"  -r "\$(ROOTDIR)" -f 2 -o rockbox-full.zip \$(TARGET) \$(BINARY)

7zip:
	\$(SILENT)for f in \`cat \$(BUILDDIR)/@APPS@/features\`; do feat="\$\$feat:\$\$f" ; done; \\
	\$(TOOLSDIR)/buildzip.pl \$(VERBOSEOPT) -t \"\$(MODELNAME)\$\$feat\" -i \"\$(TARGET_ID)\"  -o "rockbox.7z" -z "7za a" -r "\$(ROOTDIR)" \$(TARGET) \$(BINARY)

tar:
	\$(SILENT)rm -f rockbox.tar
	\$(SILENT)for f in \`cat \$(BUILDDIR)/@APPS@/features\`; do feat="\$\$feat:\$\$f" ; done; \\
	\$(TOOLSDIR)/buildzip.pl \$(VERBOSEOPT) -t \"\$(MODELNAME)\$\$feat\" -i \"\$(TARGET_ID)\"  -o "rockbox.tar" -z "tar --no-recursion -uf" -r "\$(ROOTDIR)" \$(TARGET) \$(BINARY)

bzip2: tar
	\$(SILENT)bzip2 -f9 rockbox.tar

gzip: tar
	\$(SILENT)gzip -f9 rockbox.tar

langs: features
	\$(SILENT)mkdir -p \$(BUILDDIR)/apps/lang
	\$(SILENT)\$(MAKE) -C \$(APPSDIR)/lang OBJDIR=\$(BUILDDIR)/apps/lang

manual: manual-pdf
manual-pdf:
	\$(SILENT)\$(MAKE) -C \$(MANUALDIR) OBJDIR=\$(BUILDDIR)/manual manual-pdf
manual-html:
	\$(SILENT)\$(MAKE) -C \$(MANUALDIR) OBJDIR=\$(BUILDDIR)/manual manual-html
manual-zhtml: manual-zip
manual-txt:
	\$(SILENT)\$(MAKE) -C \$(MANUALDIR) OBJDIR=\$(BUILDDIR)/manual manual-txt
manual-ztxt:
	\$(SILENT)\$(MAKE) -C \$(MANUALDIR) OBJDIR=\$(BUILDDIR)/manual manual-txt-zip
manual-zip:
	\$(SILENT)\$(MAKE) -C \$(MANUALDIR) OBJDIR=\$(BUILDDIR)/manual manual-zip

features: tools
	\$(SILENT)\$(MAKE) -C \$(APPSDIR) OBJDIR=\$(BUILDDIR)/@APPS@ features

help:
	@echo "A few helpful make targets"
	@echo ""
	@echo "all         - builds a full Rockbox (default), including tools"
	@echo "bin         - builds only the Rockbox.<target name> file"
	@echo "rocks       - builds only plugins and codecs"
	@echo "clean       - cleans a build directory (not tools)"
	@echo "veryclean   - cleans the build and tools directories"
	@echo "manual      - builds a manual"
	@echo "manual-html - HTML manual"
	@echo "manual-zip  - HTML manual (zipped)"
	@echo "manual-txt  - txt manual"
	@echo "fullzip     - creates a rockbox.zip of your build with fonts"
	@echo "zip         - creates a rockbox.zip of your build (no fonts)"
	@echo "gzip        - creates a rockbox.tar.gz of your build (no fonts)"
	@echo "bzip2       - creates a rockbox.tar.bz2 of your build (no fonts)"
	@echo "7zip        - creates a rockbox.7z of your build (no fonts)"
	@echo "fontzip     - creates rockbox-fonts.zip"
	@echo "mapzip      - creates rockbox-maps.zip with all .map files"
	@echo "tools       - builds the tools only"
	@echo "voicetools  - builds the voice tools only"
	@echo "install     - installs your build (for simulator builds only)"

EOF

if [ "yes" = "$simulator" ]; then

 cat >> Makefile <<EOF

install:
	@echo "installing a full setup in your archos dir"
	@(\$(MAKE) fullzip && cd archos && unzip -oq ../rockbox-full.zip)
EOF

fi

if [ "yes" = "$voice" ]; then

 cat >> Makefile <<EOF

voice: voicetools features
	\$(SILENT)for f in \`cat \$(BUILDDIR)/${apps}/features\`; do feat="\$\$feat:\$\$f" ; done ; \\
	for lang in \`echo \$(VOICELANGUAGE) |sed "s/,/ /g"\`; do \$(TOOLSDIR)/voice.pl -V -l=\$\$lang -t=\$(MODELNAME)\$\$feat -i=\$(TARGET_ID) -e="\$(ENCODER)" -E="\$(ENC_OPTS)" -s=\$(TTS_ENGINE) -S="\$(TTS_OPTS)"; done \\
EOF

fi

echo "Created Makefile"