#!/bin/bash

# Combine filesystem images, kernel, and emulator launch scripts
# into something you can boot and run.

source sources/include.sh || exit 1

# We do our own dependency checking (like host-tool.sh) so don't delete stage
# dir when parsing sources/targets/$1

env KEEP_STAGEDIR=1 load_target $1

# Is $1 newer than cross compiler and all listed prerequisites ($2...)?

proc is_newer
{
  setglobal X = $1
  shift
  test ! -e $X && return 0
  test $[which "$(CC_PREFIX)cc] -nt $X && return 0
  while [ ! -z "$1" ]
  {
    test ! -z $[find $1 -newer $X !2 >/dev/null] && return 0
    shift
  }

  echo "Keeping $[basename $X]"
  return 1
}

# Provide qemu's common command line options between architectures.

proc qemu_defaults
{
  echo -n "-nographic -no-reboot -kernel linux"
  test $SYSIMAGE_TYPE != "rootfs" && echo -n " -initrd rootfs.cpio.gz"
  echo -n " -append \"panic=1 console=$CONSOLE HOST=$ARCH \$KERNEL_EXTRA\""
  echo -n " \$QEMU_EXTRA"
}

# Write out a script to call the appropriate emulator.  We split out the
# filesystem, kernel, and base kernel command line arguments in case you want
# to use an emulator other than qemu, but put the default case in qemu_defaults

cat > "$STAGE_DIR/run-emulator.sh" << """ &&
#!/bin/bash

# Boot the emulated system to a shell prompt.

ARCH=$ARCH
run_emulator()
{
  [ ! -z "'$'DEBUG" ] && set -x
  $[emulator_command]
}

if [ "'$'1" != "--norun" ]
then
  run_emulator
fi
"""
chmod +x "$STAGE_DIR/run-emulator.sh" &&

# Write out development wrapper scripts, substituting INCLUDE lines.

for FILE in [dev-environment.sh native-build.sh]
{
  shell {export IFS="$[echo -e "\n]"
   cat "$SOURCES/toys/$FILE" | while read -r i
   {
     if test $(i:0:8) == "INCLUDE "
     {
       cat "$SOURCES/toys/$(i:8)" || dienow
     } else {
       # because echo doesn't support --, that's why.
       echo $i || dienow
     }
   }
  } > "$STAGE_DIR/$FILE"

  chmod +x "$STAGE_DIR/$FILE" || dienow
}

# Package root-filesystem into cpio file for initramfs

if is_newer "$STAGE_DIR/rootfs.cpio.gz" "$BUILD/root-filesystem-$ARCH"
{
  env SYSIMAGE_TYPE=cpio image_filesystem "$BUILD/root-filesystem-$ARCH" \
    "$STAGE_DIR/temp" &&
    mv -f "$STAGE_DIR"/{temp,rootfs}.cpio.gz || dienow
  test $SYSIMAGE_TYPE == rootfs && rm -f "$STAGE_DIR/linux"
}

# Package native-compiler into squashfs for /dev/hda mount

if test -e "$BUILD/native-compiler-$ARCH" &&
  is_newer "$STAGE_DIR/toolchain.sqf" "$BUILD/native-compiler-$ARCH"
{
  env SYSIMAGE_TYPE=squashfs image_filesystem "$BUILD/native-compiler-$ARCH" \
    "$STAGE_DIR/temp" &&
    mv -f "$STAGE_DIR"/{temp,toolchain}.sqf || dienow
}

# Build linux kernel for the target

if is_newer "$STAGE_DIR/linux" "$BUILD/root-filesystem-$ARCH" \
  $[package_cache linux]
{
  setupfor linux
  echo "# make allnoconfig ARCH=$(BOOT_KARCH:-$KARCH) KCONFIG_ALLCONFIG=mini.config" \
    > $STAGE_DIR/mini.config
  getconfig linux >> "$STAGE_DIR"/mini.config
  test $SYSIMAGE_TYPE == rootfs &&
    echo -e "CONFIG_INITRAMFS_SOURCE=\"$STAGE_DIR/rootfs.cpio.gz\"\n" \
      >> "$STAGE_DIR"/mini.config
  make allnoconfig ARCH=$(BOOT_KARCH:-$KARCH) $LINUX_FLAGS \
    KCONFIG_ALLCONFIG="$STAGE_DIR"/mini.config >/dev/null &&
  make -j $CPUS ARCH=$(BOOT_KARCH:-$KARCH) $DO_CROSS $LINUX_FLAGS $VERBOSITY &&
  cp $KERNEL_PATH "$STAGE_DIR/linux"
  cleanup
}

# Tar it up.

env ARCH=$ARCH_NAME create_stage_tarball

announce "Packaging complete"