#!/bin/bash

# Run all the steps needed to build a system image from scratch.

# The default set of stages run by this script is (in order):
#   download, host-tools, simple-cross-compiler, root-filesystem,
#   native-compiler, system-image.

# That sanitizes the host build environment and builds a cross compiler,
# cross compiles a root filesystem and a native toolchain for the target,
# and finally packages the root filesystem up into a system image bootable
# by qemu.

# The optional cross-compiler stage (after simple-cross-compiler but before
# root-filesystem) creates a more powerful and portable cross compiler
# that can be used to cross compile more stuff (if you're into that sort of
# thing).  To enable that:

#   CROSS_COMPILER_HOST=i686 ./build.sh $TARGET

# Where "i686" is whichever target you want the new cross compiler to run on.

# The simplest set of stages (if you run them yourself) is:
#   download, simple-cross-compiler, root-filesystem, system-image.

# If this script was run with no arguments, list available architectures

test ! -z $2 && global REBUILD := $2 &&
  test ! -e "$2".sh && echo "no stage $2" && exit 1

if test $Argc -lt 1 || test $Argc -gt 2 || test ! -e sources/targets/"$1"
{
  echo
  echo "Usage: $0 TARGET [REBUILD_FROM_STAGE]"
  echo
  echo "Supported architectures:"
  ls sources/targets
  echo
  echo "Build stages:"
  sed -n 's/#.*//;s@.*[.]/\([^.]*\)[.]sh.*@\1@p' $0 | uniq | xargs echo
  echo

  exit 1
}
global ARCH := $1

# Use environment variables persistently set in the config file.

test -e config && source config

# Allow the output directory to be overridden.  This hasn't been tested in
# forever and probably doesn't work.

test -z $BUILD && global BUILD := '"build'"

# Very simple dependency tracking: skip stages that have already been done
# (because the tarball they create is already there).

# If you need to rebuild a stage (and everything after it), delete its
# tarball out of "build" and re-run build.sh.

proc not_already
{
  test $AGAIN == $1 && return 0
  test $REBUILD == $1 && zap $1

  if test -f "$BUILD/$1-$ARCH.tar.gz"
  {
    echo "=== Skipping $1-$ARCH (already there)"
    return 1
  }

  return 0
}

proc zap
{
  for i in [@Argv]
  {
    rm -f "$BUILD/$i-$ARCH.tar.gz"
  }
}

# If $AFTER set, skip stages until we match $AFTER to implement $2="start here"
proc do_stage
{
  global STAGE := $1
  shift

  if test $AFTER == $STAGE
  {
    unset AFTER
  } else {
    time ./"$STAGE".sh @Argv || exit 1
  }
}

# The first two stages (download.sh and host-tools.sh) are architecture
# independent. In order to allow multiple builds in parallel, re-running
# them after they've already completed must be a safe NOP.

# Download source code. If tarballs already there, verify sha1sums and
# delete/redownload if they don't match (to handle interrupted partial
# download).

do_stage download

# Build host tools.  This populates a single directory with every command the
# build needs, so we can ditch the host's $PATH afterwards.

if test -z $NO_HOST_TOOLS
{
  do_stage host-tools
}

# Do we need to build the simple cross compiler?

if test -z $MY_CROSS_PATH && not_already simple-cross-compiler
{
  # If we need to build cross compiler, assume root filesystem is stale.

  zap root-filesystem cross-compiler native-compiler

  do_stage simple-cross-compiler $ARCH
}

# Optionally, we can build a more capable statically linked compiler via
# canadian cross.  (It's more powerful than we need here, but if you're going
# to use the cross compiler in other contexts this is probably what you want.)

if test -z $MY_CROSS_PATH && test ! -z $CROSS_COMPILER_HOST &&
  not_already cross-compiler
{
  zap root-filesystem native-compiler

  # Build the host compiler if necessary

  if env ARCH=$CROSS_COMPILER_HOST not_already simple-cross-compiler
  {
    do_stage simple-cross-compiler $CROSS_COMPILER_HOST
  }

  do_stage cross-compiler $ARCH
}

if ! grep -q KARCH= sources/targets/"$ARCH"
{
  echo no KARCH in $1, stopping here
}

# Build the basic root filesystem.

if not_already root-filesystem
{
  do_stage root-filesystem $ARCH
}

# Build a native compiler.  It's statically linked by default so it can
# run on an arbitrary host system.

# Not trying to build nommu native compilers for the moment.

if test -z $MY_CROSS_PATH && ! grep -q ELF2FLT sources/targets/"$ARCH" &&
  not_already native-compiler
{
  do_stage native-compiler $ARCH
}

# Package it all up into something qemu can boot. Like host-tools.sh,
# this is always called and handles its own dependencies internally.

do_stage system-image $ARCH
(CommandList
  children: [
    (AndOr
      children: [
        (C {(Lit_Other "[")} {(KW_Bang "!")} {(-z)} {(DQ ($ VSub_Number "$2"))} {(Lit_Other "]")})
        (AndOr
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:REBUILD)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$2"))}
                  spids: [77]
                )
              ]
              spids: [77]
            )
            (AndOr
              children: [
                (C {(Lit_Other "[")} {(KW_Bang "!")} {(-e)} {(DQ ($ VSub_Number "$2")) (.sh)} 
                  {(Lit_Other "]")}
                )
                (AndOr
                  children: [(C {(echo)} {(DQ ("no stage ") ($ VSub_Number "$2"))}) (C {(exit)} {(1)})]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          op_id: Op_DAmp
        )
      ]
      op_id: Op_DAmp
    )
    (If
      arms: [
        (if_arm
          cond: [
            (AndOr
              children: [
                (C {(Lit_Other "[")} {($ VSub_Pound "$#")} {(-lt)} {(1)} {(Lit_Other "]")})
                (AndOr
                  children: [
                    (C {(Lit_Other "[")} {($ VSub_Pound "$#")} {(-gt)} {(2)} {(Lit_Other "]")})
                    (C {(Lit_Other "[")} {(KW_Bang "!")} {(-e)} 
                      {(sources/targets/) (DQ ($ VSub_Number "$1"))} {(Lit_Other "]")}
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              op_id: Op_DPipe
            )
          ]
          action: [
            (C {(echo)})
            (C {(echo)} {(DQ ("Usage: ") ($ VSub_Number "$0") (" TARGET [REBUILD_FROM_STAGE]"))})
            (C {(echo)})
            (C {(echo)} {(DQ ("Supported architectures:"))})
            (C {(ls)} {(sources/targets)})
            (C {(echo)})
            (C {(echo)} {(DQ ("Build stages:"))})
            (Pipeline
              children: [
                (C {(sed)} {(-n)} {(SQ <"s/#.*//;s@.*[.]/\\([^.]*\\)[.]sh.*@\\1@p">)} 
                  {(DQ ($ VSub_Number "$0"))}
                )
                (C {(uniq)})
                (C {(xargs)} {(echo)})
              ]
              negated: False
            )
            (C {(echo)})
            (C {(exit)} {(1)})
          ]
          spids: [-1 153]
        )
      ]
      spids: [-1 224]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:ARCH)
          op: Equal
          rhs: {(DQ ($ VSub_Number "$1"))}
          spids: [226]
        )
      ]
      spids: [226]
    )
    (AndOr
      children: [(C {(Lit_Other "[")} {(-e)} {(config)} {(Lit_Other "]")}) (C {(source)} {(config)})]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$BUILD"))} {(Lit_Other "]")})
        (Assignment
          keyword: Assign_None
          pairs: [(assign_pair lhs:(LhsName name:BUILD) op:Equal rhs:{(DQ (build))} spids:[270])]
          spids: [270]
        )
      ]
      op_id: Op_DAmp
    )
    (FuncDef
      name: not_already
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$AGAIN"))} {(Lit_Other "=") (Lit_Other "=")} 
                  {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")}
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$REBUILD"))} {(Lit_Other "=") (Lit_Other "=")} 
                  {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")}
                )
                (C {(zap)} {(DQ ($ VSub_Number "$1"))})
              ]
              op_id: Op_DAmp
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(Lit_Other "[")} {(-f)} 
                      {
                        (DQ ($ VSub_Name "$BUILD") (/) ($ VSub_Number "$1") (-) ($ VSub_Name "$ARCH") 
                          (.tar.gz)
                        )
                      } {(Lit_Other "]")}
                    )
                  ]
                  action: [
                    (C {(echo)} 
                      {
                        (DQ ("=== Skipping ") ($ VSub_Number "$1") (-) ($ VSub_Name "$ARCH") 
                          (" (already there)")
                        )
                      }
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
                  ]
                  spids: [-1 362]
                )
              ]
              spids: [-1 381]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
          spids: [294]
        )
      spids: [290 293]
    )
    (FuncDef
      name: zap
      body: 
        (BraceGroup
          children: [
            (ForEach
              iter_name: i
              iter_words: [{(DQ ($ VSub_At "$@"))}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (C {(rm)} {(-f)} 
                      {
                        (DQ ($ VSub_Name "$BUILD") (/) ($ VSub_Name "$i") (-) ($ VSub_Name "$ARCH") 
                          (.tar.gz)
                        )
                      }
                    )
                  ]
                  spids: [410 427]
                )
              spids: [404 -1]
            )
          ]
          spids: [396]
        )
      spids: [392 395]
    )
    (FuncDef
      name: do_stage
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:STAGE)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [442]
                )
              ]
              spids: [442]
            )
            (C {(shift)})
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$AFTER"))} {(Lit_Other "=") (Lit_Other "=")} 
                      {(DQ ($ VSub_Name "$STAGE"))} {(Lit_Other "]")}
                    )
                  ]
                  action: [(C {(unset)} {(AFTER)})]
                  spids: [-1 470]
                )
              ]
              else_action: [
                (AndOr
                  children: [
                    (TimeBlock
                      pipeline: (C {(./) (DQ ($ VSub_Name "$STAGE")) (.sh)} {(DQ ($ VSub_At "$@"))})
                    )
                    (C {(exit)} {(1)})
                  ]
                  op_id: Op_DPipe
                )
              ]
              spids: [478 500]
            )
          ]
          spids: [439]
        )
      spids: [435 438]
    )
    (C {(do_stage)} {(download)})
    (If
      arms: [
        (if_arm
          cond: [(C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$NO_HOST_TOOLS"))} {(Lit_Other "]")})]
          action: [(C {(do_stage)} {(host-tools)})]
          spids: [-1 549]
        )
      ]
      spids: [-1 556]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (AndOr
              children: [
                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$MY_CROSS_PATH"))} {(Lit_Other "]")})
                (C {(not_already)} {(simple-cross-compiler)})
              ]
              op_id: Op_DAmp
            )
          ]
          action: [
            (C {(zap)} {(root-filesystem)} {(cross-compiler)} {(native-compiler)})
            (C {(do_stage)} {(simple-cross-compiler)} {(DQ ($ VSub_Name "$ARCH"))})
          ]
          spids: [-1 581]
        )
      ]
      spids: [-1 607]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (AndOr
              children: [
                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$MY_CROSS_PATH"))} {(Lit_Other "]")})
                (AndOr
                  children: [
                    (C {(Lit_Other "[")} {(KW_Bang "!")} {(-z)} 
                      {(DQ ($ VSub_Name "$CROSS_COMPILER_HOST"))} {(Lit_Other "]")}
                    )
                    (C {(not_already)} {(cross-compiler)})
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          action: [
            (C {(zap)} {(root-filesystem)} {(native-compiler)})
            (If
              arms: [
                (if_arm
                  cond: [
                    (SimpleCommand
                      words: [{(not_already)} {(simple-cross-compiler)}]
                      more_env: [
                        (env_pair
                          name: ARCH
                          val: {(DQ ($ VSub_Name "$CROSS_COMPILER_HOST"))}
                          spids: [671]
                        )
                      ]
                    )
                  ]
                  action: [
                    (C {(do_stage)} {(simple-cross-compiler)} {(DQ ($ VSub_Name "$CROSS_COMPILER_HOST"))})
                  ]
                  spids: [-1 681]
                )
              ]
              spids: [-1 693]
            )
            (C {(do_stage)} {(cross-compiler)} {(DQ ($ VSub_Name "$ARCH"))})
          ]
          spids: [-1 653]
        )
      ]
      spids: [-1 705]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Pipeline
              children: [
                (C {(grep)} {(-q)} {(Lit_VarLike "KARCH=")} 
                  {(sources/targets/) (DQ ($ VSub_Name "$ARCH"))}
                )
              ]
              negated: True
            )
          ]
          action: [
            (C {(echo)} {(no)} {(KARCH)} {(KW_In in)} {($ VSub_Number "$1") (Lit_Comma ",")} {(stopping)} 
              {(here)}
            )
          ]
          spids: [-1 723]
        )
      ]
      spids: [-1 741]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(not_already)} {(root-filesystem)})]
          action: [(C {(do_stage)} {(root-filesystem)} {(DQ ($ VSub_Name "$ARCH"))})]
          spids: [-1 754]
        )
      ]
      spids: [-1 765]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (AndOr
              children: [
                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$MY_CROSS_PATH"))} {(Lit_Other "]")})
                (AndOr
                  children: [
                    (Pipeline
                      children: [
                        (C {(grep)} {(-q)} {(ELF2FLT)} {(sources/targets/) (DQ ($ VSub_Name "$ARCH"))})
                      ]
                      negated: True
                    )
                    (C {(not_already)} {(native-compiler)})
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          action: [(C {(do_stage)} {(native-compiler)} {(DQ ($ VSub_Name "$ARCH"))})]
          spids: [-1 813]
        )
      ]
      spids: [-1 824]
    )
    (C {(do_stage)} {(system-image)} {(DQ ($ VSub_Name "$ARCH"))})
  ]
)