#!/bin/bash
#
# Compiles and installs a Linux/x86_64 -> Linux/ARM crosstool based on LLVM and
# LLVM-GCC-4.2 using SVN snapshots in provided tarballs.

set -o nounset
set -o errexit

echo -n "Welcome to LLVM Linux/X86_64 -> Linux/ARM crosstool "
echo "builder/installer; some steps will require sudo privileges.setconst global FOO = "bar""

readonly INSTALL_ROOT = $(INSTALL_ROOT:-/usr/local/crosstool)setconst global FOO = "bar"
# Both $USER and root *must* have read/write access to this dir.
readonly SCRATCH_ROOT = $[mktemp -d "$(TMPDIR:-/tmp)/llvm-project.XXXXXX]setconst global FOO = "bar"
readonly SRC_ROOT = ""$(SCRATCH_ROOT)/src"setconst global FOO = "bar""
readonly OBJ_ROOT = ""$(SCRATCH_ROOT)/obj"setconst global FOO = "bar""

readonly CROSS_HOST = '"x86_64-unknown-linux-gnu'setconst global FOO = "bar""
readonly CROSS_TARGET = '"arm-none-linux-gnueabi'setconst global FOO = "bar""
readonly CROSS_MARCH = $(CROSS_MARCH:-armv6)setconst global FOO = "bar"

readonly CODE_SOURCERY = ""$(INSTALL_ROOT)/codesourcery"setconst global FOO = "bar""
readonly CODE_SOURCERY_PKG_PATH = $(CODE_SOURCERY_PKG_PATH:-${HOME}/codesourcery)setconst global FOO = "bar"
readonly CODE_SOURCERY_HTTP = '"http://www.codesourcery.com/sgpp/lite/arm/portal/package1787/public'setconst global FOO = "bar""
readonly CODE_SOURCERY_PKG = '"arm-2007q3-51-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2'setconst global FOO = "bar""
readonly CODE_SOURCERY_ROOT = ""$(CODE_SOURCERY)/arm-2007q3"setconst global FOO = "bar""
readonly CODE_SOURCERY_BIN = ""$(CODE_SOURCERY_ROOT)/bin""
# Make sure ${CROSS_TARGET}-* binutils are in command path
export PATH="$(CODE_SOURCERY_BIN):$(PATH)setconst global FOO = "bar""

readonly CROSS_TARGET_AS = ""$(CODE_SOURCERY_BIN)/$(CROSS_TARGET)-as"setconst global FOO = "bar""
readonly CROSS_TARGET_LD = ""$(CODE_SOURCERY_BIN)/$(CROSS_TARGET)-ld"setconst global FOO = "bar""

readonly SYSROOT = ""$(CODE_SOURCERY_ROOT)/$(CROSS_TARGET)/libc"setconst global FOO = "bar""

readonly LLVM_PKG_PATH = $(LLVM_PKG_PATH:-${HOME}/llvm-project/snapshots)setconst global FOO = "bar"

# Latest SVN revisions known to be working in this configuration.
readonly LLVM_DEFAULT_REV = '"74530'setconst global FOO = "bar""
readonly LLVMGCC_DEFAULT_REV = '"74535'setconst global FOO = "bar""

readonly LLVM_PKG = ""llvm-$(LLVM_SVN_REV:-${LLVM_DEFAULT_REV}).tar.bz2"setconst global FOO = "bar""
readonly LLVM_SRC_DIR = ""$(SRC_ROOT)/llvm"setconst global FOO = "bar""
readonly LLVM_OBJ_DIR = ""$(OBJ_ROOT)/llvm"setconst global FOO = "bar""
readonly LLVM_INSTALL_DIR = ""$(INSTALL_ROOT)/$(CROSS_TARGET)/llvm"setconst global FOO = "bar""

readonly LLVMGCC_PKG = ""llvm-gcc-4.2-$(LLVMGCC_SVN_REV:-${LLVMGCC_DEFAULT_REV}).tar.bz2"setconst global FOO = "bar""
readonly LLVMGCC_SRC_DIR = ""$(SRC_ROOT)/llvm-gcc-4.2"setconst global FOO = "bar""
readonly LLVMGCC_OBJ_DIR = ""$(OBJ_ROOT)/llvm-gcc-4.2"setconst global FOO = "bar""
readonly LLVMGCC_INSTALL_DIR = ""$(INSTALL_ROOT)/$(CROSS_TARGET)/llvm-gcc-4.2"setconst global FOO = "bar""

readonly MAKE_OPTS = $(MAKE_OPTS:--j2)

# Params:
#   $1: directory to be created
#   $2: optional mkdir command prefix, e.g. "sudo"
proc createDir {
  if [[ ! -e $1 ]] {
    $(2:-) mkdir -p $1
  } elif [[ -e $1 && ! -d $1 ]] {
    echo "$1 exists but is not a directory; exiting."
    exit 3
  }
}

proc sudoCreateDir {
  createDir $1 sudo
  sudo chown $(USER) $1
}

# Prints out and runs the command, but without logging -- intended for use with
# lightweight commands that don't have useful output to parse, e.g. mkdir, tar,
# etc.
proc runCommand {
  var message = $1
  shift
  echo "=> $message"
  echo "==> Running: $ifsjoin(Argv)"
  $ifsjoin(Argv)
}

proc runAndLog {
  var message = $1
  var log_file = $2
  shift 2
  echo "=> $message; log in $log_file"
  echo "==> Running: $ifsjoin(Argv)"
  # Pop-up a terminal with the output of the current command?
  # e.g.: xterm -e /bin/bash -c "$* >| tee $log_file"
  $ifsjoin(Argv) &> $log_file
  if [[ $? != 0 ]] {
    echo "Error occurred: see most recent log file for details."
    exit
  }
}

proc installCodeSourcery {
  # Unpack the tarball, creating the CodeSourcery dir, if necessary.
  if [[ ! -d ${CODE_SOURCERY_ROOT} ]] {
    sudoCreateDir $(CODE_SOURCERY)
    cd $(CODE_SOURCERY)
    if [[ -e ${CODE_SOURCERY_PKG_PATH}/${CODE_SOURCERY_PKG} ]] {
      runCommand "Unpacking CodeSourcery in $(CODE_SOURCERY)" \
          tar jxf $(CODE_SOURCERY_PKG_PATH)/$(CODE_SOURCERY_PKG)
    } else {
      echo -n "CodeSourcery tarball not found in "
      echo "$(CODE_SOURCERY_PKG_PATH)/$(CODE_SOURCERY_PKG)"
      echo -n "Fix the path or download it from "
      echo "$(CODE_SOURCERY_HTTP)/$(CROSS_TARGET)/$(CODE_SOURCERY_PKG)"
      exit
    }
  } else {
    echo "CodeSourcery install dir already exists; skipping."
  }

  # Verify our CodeSourcery toolchain installation.
  if [[ ! -d "${SYSROOT}" ]] {
    echo -n "Error: CodeSourcery does not contain libc for $(CROSS_TARGET): "
    echo "$(SYSROOT) not found."
    exit
  }

  for tool in [$(CROSS_TARGET_AS) $(CROSS_TARGET_LD)] {
    if [[ ! -e $tool ]] {
      echo "$(tool) not found; exiting."
      exit
    }
  }
}

proc installLLVM {
  if [[ -d ${LLVM_INSTALL_DIR} ]] {
    echo "LLVM install dir $(LLVM_INSTALL_DIR) exists; skipping."
    return
  }

  sudoCreateDir $(LLVM_INSTALL_DIR)

  # Unpack LLVM tarball; should create the directory "llvm".
  cd $(SRC_ROOT)
  runCommand "Unpacking LLVM" tar jxf $(LLVM_PKG_PATH)/$(LLVM_PKG)

  # Configure, build, and install LLVM.
  createDir $(LLVM_OBJ_DIR)
  cd $(LLVM_OBJ_DIR)
  runAndLog "Configuring LLVM" $(LLVM_OBJ_DIR)/llvm-configure.log \
      $(LLVM_SRC_DIR)/configure \
      --disable-jit \
      --enable-optimized \
      --prefix=$(LLVM_INSTALL_DIR) \
      --target=$(CROSS_TARGET) \
      --with-llvmgccdir=$(LLVMGCC_INSTALL_DIR)
  runAndLog "Building LLVM" $(LLVM_OBJ_DIR)/llvm-build.log \
      make $(MAKE_OPTS)
  runAndLog "Installing LLVM" $(LLVM_OBJ_DIR)/llvm-install.log \
      make $(MAKE_OPTS) install
}

proc installLLVMGCC {
  if [[ -d ${LLVMGCC_INSTALL_DIR} ]] {
    echo "LLVM-GCC install dir $(LLVMGCC_INSTALL_DIR) exists; skipping."
    return
  }

  sudoCreateDir $(LLVMGCC_INSTALL_DIR)

  # Unpack LLVM-GCC tarball; should create the directory "llvm-gcc-4.2".
  cd $(SRC_ROOT)
  runCommand "Unpacking LLVM-GCC" tar jxf $(LLVM_PKG_PATH)/$(LLVMGCC_PKG)

  # Configure, build, and install LLVM-GCC.
  createDir $(LLVMGCC_OBJ_DIR)
  cd $(LLVMGCC_OBJ_DIR)
  runAndLog "Configuring LLVM-GCC" $(LLVMGCC_OBJ_DIR)/llvmgcc-configure.log \
      $(LLVMGCC_SRC_DIR)/configure \
      --enable-languages=c,c++ \
      --enable-llvm=$(LLVM_INSTALL_DIR) \
      --prefix=$(LLVMGCC_INSTALL_DIR) \
      --program-prefix=llvm- \
      --target=$(CROSS_TARGET) \
      --with-arch=$(CROSS_MARCH) \
      --with-as=$(CROSS_TARGET_AS) \
      --with-ld=$(CROSS_TARGET_LD) \
      --with-sysroot=$(SYSROOT)
  runAndLog "Building LLVM-GCC" $(LLVMGCC_OBJ_DIR)/llvmgcc-build.log \
      make
  runAndLog "Installing LLVM-GCC" $(LLVMGCC_OBJ_DIR)/llvmgcc-install.log \
      make install
}

echo "Building in $(SCRATCH_ROOT); installing in $(INSTALL_ROOT)"

createDir $(SRC_ROOT)
createDir $(OBJ_ROOT)

installCodeSourcery
installLLVM
installLLVMGCC

echo "Done."
(CommandList
  children: [
    (C {(set)} {(-o)} {(nounset)})
    (C {(set)} {(-o)} {(errexit)})
    (C {(echo)} {(-n)} {(DQ ("Welcome to LLVM Linux/X86_64 -> Linux/ARM crosstool "))})
    (C {(echo)} {(DQ ("builder/installer; some steps will require sudo privileges."))})
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:INSTALL_ROOT)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name INSTALL_ROOT>
                  suffix_op: 
                    (StringUnary
                      op_id: VTest_ColonHyphen
                      arg_word: {(Lit_Slash /) (usr) (Lit_Slash /) (local) (Lit_Slash /) (crosstool)}
                    )
                  spids: [45 54]
                )
              )
            }
          spids: [43]
        )
      ]
      spids: [41]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:SCRATCH_ROOT)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(mktemp)} {(-d)} 
                        {
                          (DQ 
                            (BracedVarSub
                              token: <VSub_Name TMPDIR>
                              suffix_op: 
                                (StringUnary
                                  op_id: VTest_ColonHyphen
                                  arg_word: {(Lit_Slash /) (tmp)}
                                )
                              spids: [69 74]
                            ) (/llvm-project.XXXXXX)
                          )
                        }
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [63 77]
              )
            }
          spids: [62]
        )
      ]
      spids: [60]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:SRC_ROOT)
          op: Equal
          rhs: {(DQ (${ VSub_Name SCRATCH_ROOT) (/src))}
          spids: [81]
        )
      ]
      spids: [79]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:OBJ_ROOT)
          op: Equal
          rhs: {(DQ (${ VSub_Name SCRATCH_ROOT) (/obj))}
          spids: [91]
        )
      ]
      spids: [89]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:CROSS_HOST)
          op: Equal
          rhs: {(DQ (x86_64-unknown-linux-gnu))}
          spids: [102]
        )
      ]
      spids: [100]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:CROSS_TARGET)
          op: Equal
          rhs: {(DQ (arm-none-linux-gnueabi))}
          spids: [109]
        )
      ]
      spids: [107]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:CROSS_MARCH)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name CROSS_MARCH>
                  suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(armv6)})
                  spids: [118 122]
                )
              )
            }
          spids: [116]
        )
      ]
      spids: [114]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:CODE_SOURCERY)
          op: Equal
          rhs: {(DQ (${ VSub_Name INSTALL_ROOT) (/codesourcery))}
          spids: [128]
        )
      ]
      spids: [126]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:CODE_SOURCERY_PKG_PATH)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name CODE_SOURCERY_PKG_PATH>
                  suffix_op: 
                    (StringUnary
                      op_id: VTest_ColonHyphen
                      arg_word: {(${ VSub_Name HOME) (Lit_Slash /) (codesourcery)}
                    )
                  spids: [140 148]
                )
              )
            }
          spids: [138]
        )
      ]
      spids: [136]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:CODE_SOURCERY_HTTP)
          op: Equal
          rhs: {(DQ ("http://www.codesourcery.com/sgpp/lite/arm/portal/package1787/public"))}
          spids: [153]
        )
      ]
      spids: [151]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:CODE_SOURCERY_PKG)
          op: Equal
          rhs: {(DQ (arm-2007q3-51-arm-none-linux-gnueabi-i686-pc-linux-gnu.tar.bz2))}
          spids: [160]
        )
      ]
      spids: [158]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:CODE_SOURCERY_ROOT)
          op: Equal
          rhs: {(DQ (${ VSub_Name CODE_SOURCERY) (/arm-2007q3))}
          spids: [167]
        )
      ]
      spids: [165]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:CODE_SOURCERY_BIN)
          op: Equal
          rhs: {(DQ (${ VSub_Name CODE_SOURCERY_ROOT) (/bin))}
          spids: [177]
        )
      ]
      spids: [175]
    )
    (C {(export)} 
      {(Lit_VarLike "PATH=") (DQ (${ VSub_Name CODE_SOURCERY_BIN) (":") (${ VSub_Name PATH))}
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:CROSS_TARGET_AS)
          op: Equal
          rhs: {(DQ (${ VSub_Name CODE_SOURCERY_BIN) (/) (${ VSub_Name CROSS_TARGET) (-as))}
          spids: [204]
        )
      ]
      spids: [202]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:CROSS_TARGET_LD)
          op: Equal
          rhs: {(DQ (${ VSub_Name CODE_SOURCERY_BIN) (/) (${ VSub_Name CROSS_TARGET) (-ld))}
          spids: [218]
        )
      ]
      spids: [216]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:SYSROOT)
          op: Equal
          rhs: {(DQ (${ VSub_Name CODE_SOURCERY_ROOT) (/) (${ VSub_Name CROSS_TARGET) (/libc))}
          spids: [233]
        )
      ]
      spids: [231]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:LLVM_PKG_PATH)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name LLVM_PKG_PATH>
                  suffix_op: 
                    (StringUnary
                      op_id: VTest_ColonHyphen
                      arg_word: 
                        {(${ VSub_Name HOME) (Lit_Slash /) (llvm-project) (Lit_Slash /) (snapshots)}
                    )
                  spids: [250 260]
                )
              )
            }
          spids: [248]
        )
      ]
      spids: [246]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:LLVM_DEFAULT_REV)
          op: Equal
          rhs: {(DQ (74530))}
          spids: [269]
        )
      ]
      spids: [267]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:LLVMGCC_DEFAULT_REV)
          op: Equal
          rhs: {(DQ (74535))}
          spids: [276]
        )
      ]
      spids: [274]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:LLVM_PKG)
          op: Equal
          rhs: 
            {
              (DQ (llvm-) 
                (BracedVarSub
                  token: <VSub_Name LLVM_SVN_REV>
                  suffix_op: 
                    (StringUnary
                      op_id: VTest_ColonHyphen
                      arg_word: {(${ VSub_Name LLVM_DEFAULT_REV)}
                    )
                  spids: [287 293]
                ) (.tar.bz2)
              )
            }
          spids: [284]
        )
      ]
      spids: [282]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:LLVM_SRC_DIR)
          op: Equal
          rhs: {(DQ (${ VSub_Name SRC_ROOT) (/llvm))}
          spids: [299]
        )
      ]
      spids: [297]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:LLVM_OBJ_DIR)
          op: Equal
          rhs: {(DQ (${ VSub_Name OBJ_ROOT) (/llvm))}
          spids: [309]
        )
      ]
      spids: [307]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:LLVM_INSTALL_DIR)
          op: Equal
          rhs: {(DQ (${ VSub_Name INSTALL_ROOT) (/) (${ VSub_Name CROSS_TARGET) (/llvm))}
          spids: [319]
        )
      ]
      spids: [317]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:LLVMGCC_PKG)
          op: Equal
          rhs: 
            {
              (DQ (llvm-gcc-4.2-) 
                (BracedVarSub
                  token: <VSub_Name LLVMGCC_SVN_REV>
                  suffix_op: 
                    (StringUnary
                      op_id: VTest_ColonHyphen
                      arg_word: {(${ VSub_Name LLVMGCC_DEFAULT_REV)}
                    )
                  spids: [337 343]
                ) (.tar.bz2)
              )
            }
          spids: [334]
        )
      ]
      spids: [332]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:LLVMGCC_SRC_DIR)
          op: Equal
          rhs: {(DQ (${ VSub_Name SRC_ROOT) (/llvm-gcc-4.2))}
          spids: [349]
        )
      ]
      spids: [347]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:LLVMGCC_OBJ_DIR)
          op: Equal
          rhs: {(DQ (${ VSub_Name OBJ_ROOT) (/llvm-gcc-4.2))}
          spids: [359]
        )
      ]
      spids: [357]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:LLVMGCC_INSTALL_DIR)
          op: Equal
          rhs: {(DQ (${ VSub_Name INSTALL_ROOT) (/) (${ VSub_Name CROSS_TARGET) (/llvm-gcc-4.2))}
          spids: [369]
        )
      ]
      spids: [367]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:MAKE_OPTS)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name MAKE_OPTS>
                  suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(-j2)})
                  spids: [386 390]
                )
              )
            }
          spids: [384]
        )
      ]
      spids: [382]
    )
    (FuncDef
      name: createDir
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (LogicalNot
                              child: (BoolUnary op_id:BoolUnary_e child:{($ VSub_Number "$1")})
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C 
                      {
                        (BracedVarSub
                          token: <VSub_Number 2>
                          suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{})
                          spids: [426 429]
                        )
                      } {(mkdir)} {(-p)} {($ VSub_Number "$1")}
                    )
                  ]
                  spids: [-1 423]
                )
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (LogicalAnd
                              left: (BoolUnary op_id:BoolUnary_e child:{($ VSub_Number "$1")})
                              right: 
                                (LogicalNot
                                  child: (BoolUnary op_id:BoolUnary_d child:{($ VSub_Number "$1")})
                                )
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(echo)} {(DQ ($ VSub_Number "$1") (" exists but is not a directory; exiting."))})
                    (C {(exit)} {(3)})
                  ]
                  spids: [438 457]
                )
              ]
              spids: [-1 473]
            )
          ]
          spids: [407]
        )
      spids: [403 406]
    )
    (FuncDef
      name: sudoCreateDir
      body: 
        (BraceGroup
          children: [
            (C {(createDir)} {($ VSub_Number "$1")} {(sudo)})
            (C {(sudo)} {(chown)} {(${ VSub_Name USER)} {($ VSub_Number "$1")})
          ]
          spids: [482]
        )
      spids: [478 481]
    )
    (FuncDef
      name: runCommand
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:message)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [523]
                )
              ]
              spids: [521]
            )
            (C {(shift)})
            (C {(echo)} {(DQ ("=> ") ($ VSub_Name "$message"))})
            (C {(echo)} {(DQ ("==> Running: ") ($ VSub_Star "$*"))})
            (C {($ VSub_Star "$*")})
          ]
          spids: [518]
        )
      spids: [514 517]
    )
    (FuncDef
      name: runAndLog
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:message)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [562]
                )
              ]
              spids: [560]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:log_file)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$2"))}
                  spids: [570]
                )
              ]
              spids: [568]
            )
            (C {(shift)} {(2)})
            (C {(echo)} {(DQ ("=> ") ($ VSub_Name "$message") ("; log in ") ($ VSub_Name "$log_file"))})
            (C {(echo)} {(DQ ("==> Running: ") ($ VSub_Star "$*"))})
            (Sentence child:(C {($ VSub_Star "$*")}) terminator:<Op_Amp "&">)
            (SimpleCommand
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {($ VSub_Name "$log_file")}
                  spids: [610]
                )
              ]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolBinary
                              op_id: BoolBinary_GlobNEqual
                              left: {($ VSub_QMark "$?")}
                              right: {(0)}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(echo)} {(DQ ("Error occurred: see most recent log file for details."))})
                    (C {(exit)})
                  ]
                  spids: [-1 628]
                )
              ]
              spids: [-1 641]
            )
          ]
          spids: [557]
        )
      spids: [553 556]
    )
    (FuncDef
      name: installCodeSourcery
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (LogicalNot
                              child: 
                                (BoolUnary
                                  op_id: BoolUnary_d
                                  child: {(${ VSub_Name CODE_SOURCERY_ROOT)}
                                )
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(sudoCreateDir)} {(${ VSub_Name CODE_SOURCERY)})
                    (C {(cd)} {(${ VSub_Name CODE_SOURCERY)})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (BoolUnary
                                      op_id: BoolUnary_e
                                      child: 
                                        {(${ VSub_Name CODE_SOURCERY_PKG_PATH) (/) 
                                          (${ VSub_Name CODE_SOURCERY_PKG)
                                        }
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(runCommand)} 
                              {(DQ ("Unpacking CodeSourcery in ") (${ VSub_Name CODE_SOURCERY))} {(tar)} {(jxf)} {(${ VSub_Name CODE_SOURCERY_PKG_PATH) (/) (${ VSub_Name CODE_SOURCERY_PKG)}
                            )
                          ]
                          spids: [-1 706]
                        )
                      ]
                      else_action: [
                        (C {(echo)} {(-n)} {(DQ ("CodeSourcery tarball not found in "))})
                        (C {(echo)} 
                          {
                            (DQ (${ VSub_Name CODE_SOURCERY_PKG_PATH) (/) 
                              (${ VSub_Name CODE_SOURCERY_PKG)
                            )
                          }
                        )
                        (C {(echo)} {(-n)} {(DQ ("Fix the path or download it from "))})
                        (C {(echo)} 
                          {
                            (DQ (${ VSub_Name CODE_SOURCERY_HTTP) (/) (${ VSub_Name CROSS_TARGET) (/) 
                              (${ VSub_Name CODE_SOURCERY_PKG)
                            )
                          }
                        )
                        (C {(exit)})
                      ]
                      spids: [733 787]
                    )
                  ]
                  spids: [-1 672]
                )
              ]
              else_action: [(C {(echo)} {(DQ ("CodeSourcery install dir already exists; skipping."))})]
              spids: [790 800]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (LogicalNot
                              child: (BoolUnary op_id:BoolUnary_d child:{(DQ (${ VSub_Name SYSROOT))})
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(echo)} {(-n)} 
                      {
                        (DQ ("Error: CodeSourcery does not contain libc for ") 
                          (${ VSub_Name CROSS_TARGET) (": ")
                        )
                      }
                    )
                    (C {(echo)} {(DQ (${ VSub_Name SYSROOT) (" not found."))})
                    (C {(exit)})
                  ]
                  spids: [-1 825]
                )
              ]
              spids: [-1 854]
            )
            (ForEach
              iter_name: tool
              iter_words: [{(${ VSub_Name CROSS_TARGET_AS)} {(${ VSub_Name CROSS_TARGET_LD)}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (DBracket
                                  expr: 
                                    (LogicalNot
                                      child: 
                                        (BoolUnary
                                          op_id: BoolUnary_e
                                          child: {($ VSub_Name "$tool")}
                                        )
                                    )
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)} {(DQ (${ VSub_Name tool) (" not found; exiting."))})
                            (C {(exit)})
                          ]
                          spids: [-1 889]
                        )
                      ]
                      spids: [-1 905]
                    )
                  ]
                  spids: [873 908]
                )
              spids: [863 871]
            )
          ]
          spids: [650]
        )
      spids: [646 649]
    )
    (FuncDef
      name: installLLVM
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: (BoolUnary op_id:BoolUnary_d child:{(${ VSub_Name LLVM_INSTALL_DIR)})
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(echo)} 
                      {
                        (DQ ("LLVM install dir ") (${ VSub_Name LLVM_INSTALL_DIR) 
                          (" exists; skipping.")
                        )
                      }
                    )
                    (ControlFlow token:<ControlFlow_Return return>)
                  ]
                  spids: [-1 933]
                )
              ]
              spids: [-1 950]
            )
            (C {(sudoCreateDir)} {(${ VSub_Name LLVM_INSTALL_DIR)})
            (C {(cd)} {(${ VSub_Name SRC_ROOT)})
            (C {(runCommand)} {(DQ ("Unpacking LLVM"))} {(tar)} {(jxf)} 
              {(${ VSub_Name LLVM_PKG_PATH) (/) (${ VSub_Name LLVM_PKG)}
            )
            (C {(createDir)} {(${ VSub_Name LLVM_OBJ_DIR)})
            (C {(cd)} {(${ VSub_Name LLVM_OBJ_DIR)})
            (C {(runAndLog)} {(DQ ("Configuring LLVM"))} 
              {(${ VSub_Name LLVM_OBJ_DIR) (/llvm-configure.log)} {(${ VSub_Name LLVM_SRC_DIR) (/configure)} {(--disable-jit)} {(--enable-optimized)} 
              {(--prefix) (Lit_Other "=") (${ VSub_Name LLVM_INSTALL_DIR)} {(--target) (Lit_Other "=") (${ VSub_Name CROSS_TARGET)} 
              {(--with-llvmgccdir) (Lit_Other "=") (${ VSub_Name LLVMGCC_INSTALL_DIR)}
            )
            (C {(runAndLog)} {(DQ ("Building LLVM"))} {(${ VSub_Name LLVM_OBJ_DIR) (/llvm-build.log)} 
              {(make)} {(${ VSub_Name MAKE_OPTS)}
            )
            (C {(runAndLog)} {(DQ ("Installing LLVM"))} 
              {(${ VSub_Name LLVM_OBJ_DIR) (/llvm-install.log)} {(make)} {(${ VSub_Name MAKE_OPTS)} {(install)}
            )
          ]
          spids: [917]
        )
      spids: [913 916]
    )
    (FuncDef
      name: installLLVMGCC
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: 
                            (BoolUnary
                              op_id: BoolUnary_d
                              child: {(${ VSub_Name LLVMGCC_INSTALL_DIR)}
                            )
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(echo)} 
                      {
                        (DQ ("LLVM-GCC install dir ") (${ VSub_Name LLVMGCC_INSTALL_DIR) 
                          (" exists; skipping.")
                        )
                      }
                    )
                    (ControlFlow token:<ControlFlow_Return return>)
                  ]
                  spids: [-1 1126]
                )
              ]
              spids: [-1 1143]
            )
            (C {(sudoCreateDir)} {(${ VSub_Name LLVMGCC_INSTALL_DIR)})
            (C {(cd)} {(${ VSub_Name SRC_ROOT)})
            (C {(runCommand)} {(DQ ("Unpacking LLVM-GCC"))} {(tar)} {(jxf)} 
              {(${ VSub_Name LLVM_PKG_PATH) (/) (${ VSub_Name LLVMGCC_PKG)}
            )
            (C {(createDir)} {(${ VSub_Name LLVMGCC_OBJ_DIR)})
            (C {(cd)} {(${ VSub_Name LLVMGCC_OBJ_DIR)})
            (C {(runAndLog)} {(DQ ("Configuring LLVM-GCC"))} 
              {(${ VSub_Name LLVMGCC_OBJ_DIR) (/llvmgcc-configure.log)} {(${ VSub_Name LLVMGCC_SRC_DIR) (/configure)} 
              {(--enable-languages) (Lit_Other "=") (c) (Lit_Comma ",") (c) (Lit_Other "+") 
                (Lit_Other "+")
              } {(--enable-llvm) (Lit_Other "=") (${ VSub_Name LLVM_INSTALL_DIR)} 
              {(--prefix) (Lit_Other "=") (${ VSub_Name LLVMGCC_INSTALL_DIR)} {(--program-prefix) (Lit_Other "=") (llvm-)} {(--target) (Lit_Other "=") (${ VSub_Name CROSS_TARGET)} 
              {(--with-arch) (Lit_Other "=") (${ VSub_Name CROSS_MARCH)} {(--with-as) (Lit_Other "=") (${ VSub_Name CROSS_TARGET_AS)} 
              {(--with-ld) (Lit_Other "=") (${ VSub_Name CROSS_TARGET_LD)} {(--with-sysroot) (Lit_Other "=") (${ VSub_Name SYSROOT)}
            )
            (C {(runAndLog)} {(DQ ("Building LLVM-GCC"))} 
              {(${ VSub_Name LLVMGCC_OBJ_DIR) (/llvmgcc-build.log)} {(make)}
            )
            (C {(runAndLog)} {(DQ ("Installing LLVM-GCC"))} 
              {(${ VSub_Name LLVMGCC_OBJ_DIR) (/llvmgcc-install.log)} {(make)} {(install)}
            )
          ]
          spids: [1110]
        )
      spids: [1106 1109]
    )
    (C {(echo)} 
      {
        (DQ ("Building in ") (${ VSub_Name SCRATCH_ROOT) ("; installing in ") 
          (${ VSub_Name INSTALL_ROOT)
        )
      }
    )
    (C {(createDir)} {(${ VSub_Name SRC_ROOT)})
    (C {(createDir)} {(${ VSub_Name OBJ_ROOT)})
    (C {(installCodeSourcery)})
    (C {(installLLVM)})
    (C {(installLLVMGCC)})
    (C {(echo)} {(DQ (Done.))})
  ]
)