#!/bin/echo "This file is sourced, not run"

# Set of functions to download, extract, and patch source tarballs.
#
# Tools to populate and verify a directory of package source tarballs
# (saved in $SRCDIR which defaults to $TOP/packages). Used by download.sh.
#
#   You can supply your own tarball in $SRCDIR to avoid downloading it.
#
#   You can also provide an expanded directory (same filename as $URL
#   but no version or extension) to be used instead of a tarball. This is
#   usually a source control checkout.
#
#   $IGNORE_REPOS - comma separated list of package names (or "all") to
#     download tarballs for anyway, ignoring the directory version if present.
#
# Functions to call from here:
#
# download
#   - fetch a file (with wget) if it doesn't already exist, or doesn't match
#     checksum.
#
#   It expects you to set:
#     $URL - Default location of file, including filename
#     $SHA1 - sha1sum of good file. (Blank means accept any file.)
#
#   You can also set these (which use filename from $URL):
#     $PREFERRED_MIRROR - Check here first (appending filename from $URL)
#     $MIRROR_LIST - Space separated list of fallback locations (appending
#       filename from $URL) to check if default location didn't have it.
#
#   Does not re-download existing tarballs if the $SHA1 matches/is blank.
#   Does not download tarball if expanded directory present.
#
# cleanup_oldfiles
#   - remove stale files from $SRCDIR
#
#   Stale means not referenced by a download call since start of script.
#   Only affects files, not subdirectories.


# Remove version information and extension tarball name "$1".
# If "$2", add that version number back, keeping original extension.

proc noversion
{
  global LOGRUS := ''s/-*\(\([0-9\.]\)*\([_-]rc\)*\(-pre\)*\([0-9][a-zA-Z]\)*\)*\(\.tar\(\..z2*\)*\)$''
  test -z $2 && global LOGRUS := ""$LOGRUS//"" || global LOGRUS := ""$LOGRUS/$2\\6/""

  echo $1 | sed -e $LOGRUS
}

proc gather_patches
{
  ls "$PATCHDIR/$(PACKAGE)"-*.patch !2 > /dev/null | sort | while read i
  {
    if test -f $i
    {
      echo $i
    }
  }

  # gather external package patches sorted by filename
  if test ! -z $MY_PATCH_DIR && test -d "$(MY_PATCH_DIR)/$(PACKAGE)"
  {
    for i in ["$(MY_PATCH_DIR)/$(PACKAGE)/"*.patch]
    {
      if test -f $i
      {
        echo $i
      }
    }
  }
}

# Apply any patches to this package
proc patch_package
{
  gather_patches | while read i
  {
    if test -f $i
    {
      echo "Applying $i"
      shell {cd "$(SRCTREE)/$(PACKAGE)" &&
       patch -p1 -i $i &&
       sha1file $i >> $SHA1FILE} ||
        if test -z $ALLOW_PATCH_FAILURE
        {
          dienow
        }
    }
  }
}

# Get the tarball for this package

proc find_package_tarball
{
  # If there are multiple similar files we want the newest timestamp, in case
  # the URL just got upgraded but cleanup_oldfiles hasn't run yet.  Be able to
  # distinguish "package-123.tar.bz2" from "package-tests-123.tar.bz2" and
  # return the shorter one reliably.

  ls -tc "$SRCDIR/$1-"*.tar* !2 >/dev/null | while read i
  {
    if test $[noversion $(i/*\//)] == $1
    {
      echo $i
      break
    }
  }
}

proc package_cache
{
  global SNAPFROM := ""$SRCDIR/$1""
  shell {is_in_list $1 $IGNORE_REPOS || test ! -d $SNAPFROM} &&
    global SNAPFROM := ""$SRCTREE/$1""

  if test ! -d $SNAPFROM
  {
    echo "$1 not found.  Did you run download.sh?" > !2
    dienow
  }

  echo $SNAPFROM
}

# Extract tarball named in $1 and apply all relevant patches into
# "$BUILD/packages/$1".  Record sha1sum of tarball and patch files in
# sha1-for-source.txt.  Re-extract if tarball or patches change.

proc extract_package
{
  mkdir -p $SRCTREE || dienow

  # Announce to the world that we're cracking open a new package

  global PACKAGE := $1
  announce $PACKAGE

  ! is_in_list "PACKAGE" $IGNORE_REPOS && test -d "$SRCDIR/$PACKAGE" &&
    return 0

  # Find tarball, and determine type

  global FILENAME := $[find_package_tarball $PACKAGE]
  global DECOMPRESS := ''""
  test $FILENAME != $(FILENAME/%\.tar\.bz2/) && global DECOMPRESS := '"j'"
  test $FILENAME != $(FILENAME/%\.tar\.gz/) && global DECOMPRESS := '"z'"

  # If the source tarball doesn't exist, but the extracted directory is there,
  # assume everything's ok.

  global SHA1NAME := '"sha1-for-source.txt'"
  global SHA1FILE := ""$SRCTREE/$PACKAGE/$SHA1NAME""
  if test -z $FILENAME
  {
    if test ! -e "$SRCTREE/$PACKAGE"
    {
      echo "No tarball for $PACKAGE" > !2
      dienow
    }

    # If the sha1sum file isn't there, re-patch the package.
    test ! -e $SHA1FILE && patch_package
    return 0
  }

  # Check the sha1 list from the previous extract.  If the source is already
  # up to date (including patches), keep it.

  global SHA1TAR := $[sha1file $FILENAME]
  global SHALIST := $[cat $SHA1FILE !2 > /dev/null]
  if test ! -z $SHALIST
  {
    for i in [$SHA1TAR $[sha1file $[gather_patches]]]
    {
      # Is this sha1 in the file?
      if test -z $[echo $SHALIST | grep $i]
      {
        global SHALIST := 'missing'
        break
      }
      # Remove it
      global SHALIST := $[echo $SHALIST | sed "s/$i//]
    }
    # If we matched all the sha1sums, nothing more to do.
    test -z $SHALIST && return 0
  }

  # Re-extract the package, deleting the old one (if any)..

  echo -n "Extracting '$PACKAGE'"
  shell {
    global UNIQUE := $[readlink /proc/self]
    trap 'rm -rf "$BUILD/temp-'$UNIQUE'"' EXIT
    rm -rf "$SRCTREE/$PACKAGE" !2 >/dev/null
    mkdir -p "$BUILD/temp-$UNIQUE" $SRCTREE || dienow

    do { tar -xv$(DECOMPRESS) -f $FILENAME -C "$BUILD/temp-$UNIQUE" &&
      # Wildcards only expand when they ponit to something that exists,
      # and even then they have to be an argument to a command.
      global TARDIR := $[readlink -f "$BUILD/temp-$UNIQUE"/*] &&
      touch "$TARDIR/$SHA1NAME"
    } | dotprogress

    test -e "$BUILD/temp-$UNIQUE"/*/"$SHA1NAME" &&
    mv "$BUILD/temp-$UNIQUE/"* "$SRCTREE/$PACKAGE" &&
    echo $SHA1TAR >> $SHA1FILE
  }

  test $Status -ne 0 && dienow

  patch_package
}

# Confirm that a file has the appropriate checksum (or exists but SHA1 is blank)
# Delete invalid file.

proc confirm_checksum
{
  global SUM := $[sha1file "$SRCDIR/$FILENAME" !2 >/dev/null]
  if test x"$SUM" == x"$SHA1" || test -z $SHA1 && test -f "$SRCDIR/$FILENAME"
  {
    if test -z $SHA1
    {
      echo "No SHA1 for $FILENAME ($SUM)"
    } else {
      echo "Confirmed $FILENAME"
    }

    # Preemptively extract source packages?

    test -z $EXTRACT_ALL && return 0
    extract_package $BASENAME
    return $?
  }

  # If there's a corrupted file, delete it.  In theory it would be nice
  # to resume downloads, but wget creates "*.1" files instead.

  rm -f "$SRCDIR/$FILENAME"

  return 1
}

# Attempt to obtain file from a specific location

proc download_from
{
  # Return success if we already have a valid copy of the file

  confirm_checksum && return 0

  # If we have another source, try to download file from there.

  test -z $1 && return 1
  wget -t 2 -T 20 -O "$SRCDIR/$FILENAME" $1 ||
    shell {rm -f "$SRCDIR/$FILENAME"; return 2}
  touch -c "$SRCDIR/$FILENAME"

  confirm_checksum
}

# Confirm a file matches sha1sum, else try to download it from mirror list.

proc download
{
  global FILENAME := $[echo $URL | sed 's .*/  ]
  test -z $RENAME || global FILENAME := $[echo $FILENAME | sed -r $RENAME]

  if test -z $[sha1sum < /dev/null]
  {
    echo "Error: please install sha1sum" > !2
    exit 1
  }

  echo -ne "checking $FILENAME\r"

  # Update timestamp on tarball (if it exists) so cleanup_oldfiles keeps it

  touch -c "$SRCDIR"/"$FILENAME" !2 >/dev/null

  # Give package name, minus file's version number and archive extension.
  global BASENAME := $[noversion $FILENAME]
  if ! is_in_list $BASENAME $IGNORE_REPOS && test -d "$SRCDIR/$BASENAME"
  {
    echo "Using $SRCDIR/$BASENAME"
    if test $EXTRACT_ALL == force
    {
      rm -rf "$SRCTREE/$BASENAME" &&
      cp -a "$SRCDIR/$BASENAME" "$SRCTREE/$BASENAME" || dienow
    }

    return 0
  }

  # If environment variable specifies a preferred mirror, try that first.

  if test ! -z $PREFERRED_MIRROR
  {
    download_from "$PREFERRED_MIRROR/$FILENAME" && return 0
  }

  # Try original location, then mirrors.
  # Note: the URLs in mirror list cannot contain whitespace.

  download_from $URL && return 0
  for i in [$MIRROR_LIST]
  {
    download_from "$i/$FILENAME" && return 0
  }

  # Return failure.

  echo "Could not download $FILENAME"
  echo -en "\e[0m"
  return 1
}

# Clean obsolete files out of the source directory

global START_TIME := $[date +%s]

proc cleanup_oldfiles
{
  # wait for asynchronous downloads to complete

  wait

  for i in ["$(SRCDIR)"/*]
  {
    if test -f $i && test $[date +%s -r $i] -lt $(START_TIME)
    {
      echo Removing old file $i
      rm -rf $i
    }
  }
}
(CommandList
  children: [
    (FuncDef
      name: noversion
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:LOGRUS)
                  op: Equal
                  rhs: 
                    {
                      (SQ 
                        <
"s/-*\\(\\([0-9\\.]\\)*\\([_-]rc\\)*\\(-pre\\)*\\([0-9][a-zA-Z]\\)*\\)*\\(\\.tar\\(\\..z2*\\)*\\)$"
                        >
                      )
                    }
                  spids: [131]
                )
              ]
              spids: [131]
            )
            (AndOr
              children: [
                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Number "$2"))} {(Lit_Other "]")})
                (AndOr
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:LOGRUS)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$LOGRUS") (//))}
                          spids: [149]
                        )
                      ]
                      spids: [149]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:LOGRUS)
                          op: Equal
                          rhs: 
                            {
                              (DQ ($ VSub_Name "$LOGRUS") (/) ($ VSub_Number "$2") 
                                (EscapedLiteralPart
                                  token: <Lit_EscapedChar "\\\\">
                                ) (6/)
                              )
                            }
                          spids: [157]
                        )
                      ]
                      spids: [157]
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              op_id: Op_DAmp
            )
            (Pipeline
              children: [
                (C {(echo)} {(DQ ($ VSub_Number "$1"))})
                (C {(sed)} {(-e)} {(DQ ($ VSub_Name "$LOGRUS"))})
              ]
              negated: False
            )
          ]
          spids: [128]
        )
      spids: [124 127]
    )
    (FuncDef
      name: gather_patches
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (SimpleCommand
                  words: [
                    {(ls)}
                    {(DQ ($ VSub_Name "$PATCHDIR") (/) (${ VSub_Name PACKAGE)) (-) (Lit_Other "*") 
                      (.patch)
                    }
                  ]
                  redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[207])]
                )
                (C {(sort)})
                (While
                  cond: [(C {(read)} {(i)})]
                  body: 
                    (DoGroup
                      children: [
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (C {(Lit_Other "[")} {(-f)} {(DQ ($ VSub_Name "$i"))} {(Lit_Other "]")})
                              ]
                              action: [(C {(echo)} {(DQ ($ VSub_Name "$i"))})]
                              spids: [-1 240]
                            )
                          ]
                          spids: [-1 250]
                        )
                      ]
                      spids: [224 253]
                    )
                )
              ]
              negated: False
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(Lit_Other "[")} {(KW_Bang "!")} {(-z)} {(DQ ($ VSub_Name "$MY_PATCH_DIR"))} 
                          {(Lit_Other "]")}
                        )
                        (C {(Lit_Other "[")} {(-d)} 
                          {(DQ (${ VSub_Name MY_PATCH_DIR) (/) (${ VSub_Name PACKAGE))} {(Lit_Other "]")}
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (ForEach
                      iter_name: i
                      iter_words: [
                        {(DQ (${ VSub_Name MY_PATCH_DIR) (/) (${ VSub_Name PACKAGE) (/)) 
                          (Lit_Other "*") (.patch)
                        }
                      ]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (C {(Lit_Other "[")} {(-f)} {(DQ ($ VSub_Name "$i"))} 
                                      {(Lit_Other "]")}
                                    )
                                  ]
                                  action: [(C {(echo)} {(DQ ($ VSub_Name "$i"))})]
                                  spids: [-1 333]
                                )
                              ]
                              spids: [-1 343]
                            )
                          ]
                          spids: [317 346]
                        )
                      spids: [302 -1]
                    )
                  ]
                  spids: [-1 294]
                )
              ]
              spids: [-1 349]
            )
          ]
          spids: [191]
        )
      spids: [187 190]
    )
    (FuncDef
      name: patch_package
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (C {(gather_patches)})
                (While
                  cond: [(C {(read)} {(i)})]
                  body: 
                    (DoGroup
                      children: [
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (C {(Lit_Other "[")} {(-f)} {(DQ ($ VSub_Name "$i"))} {(Lit_Other "]")})
                              ]
                              action: [
                                (C {(echo)} {(DQ ("Applying ") ($ VSub_Name "$i"))})
                                (AndOr
                                  children: [
                                    (Subshell
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(cd)} 
                                              {
                                                (DQ (${ VSub_Name SRCTREE) (/) (${ VSub_Name PACKAGE))
                                              }
                                            )
                                            (AndOr
                                              children: [
                                                (C {(patch)} {(-p1)} {(-i)} {(DQ ($ VSub_Name "$i"))})
                                                (SimpleCommand
                                                  words: [{(sha1file)} {(DQ ($ VSub_Name "$i"))}]
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_DGreat
                                                      fd: -1
                                                      arg_word: {(DQ ($ VSub_Name "$SHA1FILE"))}
                                                      spids: [437]
                                                    )
                                                  ]
                                                )
                                              ]
                                              op_id: Op_DAmp
                                            )
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      spids: [402 442]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (C {(Lit_Other "[")} {(-z)} 
                                              {(DQ ($ VSub_Name "$ALLOW_PATCH_FAILURE"))} {(Lit_Other "]")}
                                            )
                                          ]
                                          action: [(C {(dienow)})]
                                          spids: [-1 460]
                                        )
                                      ]
                                      spids: [-1 466]
                                    )
                                  ]
                                  op_id: Op_DPipe
                                )
                              ]
                              spids: [-1 391]
                            )
                          ]
                          spids: [-1 469]
                        )
                      ]
                      spids: [375 472]
                    )
                )
              ]
              negated: False
            )
          ]
          spids: [361]
        )
      spids: [357 360]
    )
    (FuncDef
      name: find_package_tarball
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (SimpleCommand
                  words: [
                    {(ls)}
                    {(-tc)}
                    {(DQ ($ VSub_Name "$SRCDIR") (/) ($ VSub_Number "$1") (-)) (Lit_Other "*") (.tar) 
                      (Lit_Other "*")
                    }
                  ]
                  redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[519])]
                )
                (While
                  cond: [(C {(read)} {(i)})]
                  body: 
                    (DoGroup
                      children: [
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (C {(Lit_Other "[")} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(noversion)} 
                                                {
                                                  (DQ 
                                                    (BracedVarSub
                                                      token: <VSub_Name i>
                                                      suffix_op: 
                                                        (PatSub
                                                          pat: 
                                                            {("*") 
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\/">
                                                              )
                                                            }
                                                          replace: {(SQ )}
                                                          do_all: False
                                                          do_prefix: False
                                                          do_suffix: False
                                                        )
                                                      spids: [543 549]
                                                    )
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [539 551]
                                      )
                                    )
                                  } {(Lit_Other "=") (Lit_Other "=")} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")}
                                )
                              ]
                              action: [
                                (C {(echo)} {(DQ ($ VSub_Name "$i"))})
                                (ControlFlow
                                  token: <ControlFlow_Break break>
                                )
                              ]
                              spids: [-1 564]
                            )
                          ]
                          spids: [-1 577]
                        )
                      ]
                      spids: [531 580]
                    )
                )
              ]
              negated: False
            )
          ]
          spids: [485]
        )
      spids: [481 484]
    )
    (FuncDef
      name: package_cache
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:SNAPFROM)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$SRCDIR") (/) ($ VSub_Number "$1"))}
                  spids: [592]
                )
              ]
              spids: [592]
            )
            (AndOr
              children: [
                (Subshell
                  child: 
                    (AndOr
                      children: [
                        (C {(is_in_list)} {(DQ ($ VSub_Number "$1"))} 
                          {(DQ ($ VSub_Name "$IGNORE_REPOS"))}
                        )
                        (C {(Lit_Other "[")} {(KW_Bang "!")} {(-d)} {(DQ ($ VSub_Name "$SNAPFROM"))} 
                          {(Lit_Other "]")}
                        )
                      ]
                      op_id: Op_DPipe
                    )
                  spids: [600 624]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:SNAPFROM)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name "$SRCTREE") (/) ($ VSub_Number "$1"))}
                      spids: [629]
                    )
                  ]
                  spids: [629]
                )
              ]
              op_id: Op_DAmp
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(Lit_Other "[")} {(KW_Bang "!")} {(-d)} {(DQ ($ VSub_Name "$SNAPFROM"))} 
                      {(Lit_Other "]")}
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [
                        {(echo)}
                        {(DQ ($ VSub_Number "$1") (" not found.  Did you run download.sh?"))}
                      ]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[663])]
                    )
                    (C {(dienow)})
                  ]
                  spids: [-1 653]
                )
              ]
              spids: [-1 670]
            )
            (C {(echo)} {(DQ ($ VSub_Name "$SNAPFROM"))})
          ]
          spids: [589]
        )
      spids: [585 588]
    )
    (FuncDef
      name: extract_package
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [(C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$SRCTREE"))}) (C {(dienow)})]
              op_id: Op_DPipe
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:PACKAGE)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [719]
                )
              ]
              spids: [719]
            )
            (C {(announce)} {(DQ ($ VSub_Name "$PACKAGE"))})
            (AndOr
              children: [
                (Pipeline
                  children: [(C {(is_in_list)} {(DQ (PACKAGE))} {(DQ ($ VSub_Name "$IGNORE_REPOS"))})]
                  negated: True
                )
                (AndOr
                  children: [
                    (C {(Lit_Other "[")} {(-d)} 
                      {(DQ ($ VSub_Name "$SRCDIR") (/) ($ VSub_Name "$PACKAGE"))} {(Lit_Other "]")}
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:FILENAME)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [(C {(find_package_tarball)} {(DQ ($ VSub_Name "$PACKAGE"))})]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [775 781]
                        )
                      )
                    }
                  spids: [773]
                )
              ]
              spids: [773]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:DECOMPRESS) op:Equal rhs:{(DQ )} spids:[785])]
              spids: [785]
            )
            (AndOr
              children: [
                (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$FILENAME"))} {(KW_Bang "!") (Lit_Other "=")} 
                  {
                    (DQ 
                      (BracedVarSub
                        token: <VSub_Name FILENAME>
                        suffix_op: 
                          (PatSub
                            pat: 
                              {(EscapedLiteralPart token:<Lit_EscapedChar "\\.">) (tar) 
                                (EscapedLiteralPart
                                  token: <Lit_EscapedChar "\\.">
                                ) (bz2)
                              }
                            replace: {(SQ )}
                            do_all: False
                            do_prefix: False
                            do_suffix: True
                          )
                        spids: [800 809]
                      )
                    )
                  } {(Lit_Other "]")}
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:DECOMPRESS)
                      op: Equal
                      rhs: {(DQ (j))}
                      spids: [816]
                    )
                  ]
                  spids: [816]
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$FILENAME"))} {(KW_Bang "!") (Lit_Other "=")} 
                  {
                    (DQ 
                      (BracedVarSub
                        token: <VSub_Name FILENAME>
                        suffix_op: 
                          (PatSub
                            pat: 
                              {(EscapedLiteralPart token:<Lit_EscapedChar "\\.">) (tar) 
                                (EscapedLiteralPart
                                  token: <Lit_EscapedChar "\\.">
                                ) (gz)
                              }
                            replace: {(SQ )}
                            do_all: False
                            do_prefix: False
                            do_suffix: True
                          )
                        spids: [832 841]
                      )
                    )
                  } {(Lit_Other "]")}
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:DECOMPRESS)
                      op: Equal
                      rhs: {(DQ (z))}
                      spids: [848]
                    )
                  ]
                  spids: [848]
                )
              ]
              op_id: Op_DAmp
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:SHA1NAME)
                  op: Equal
                  rhs: {(DQ (sha1-for-source.txt))}
                  spids: [864]
                )
              ]
              spids: [864]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:SHA1FILE)
                  op: Equal
                  rhs: 
                    {
                      (DQ ($ VSub_Name "$SRCTREE") (/) ($ VSub_Name "$PACKAGE") (/) 
                        ($ VSub_Name "$SHA1NAME")
                      )
                    }
                  spids: [870]
                )
              ]
              spids: [870]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$FILENAME"))} {(Lit_Other "]")})
                  ]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(Lit_Other "[")} {(KW_Bang "!")} {(-e)} 
                              {(DQ ($ VSub_Name "$SRCTREE") (/) ($ VSub_Name "$PACKAGE"))} {(Lit_Other "]")}
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [{(echo)} {(DQ ("No tarball for ") ($ VSub_Name "$PACKAGE"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: -1
                                  arg_word: {(2)}
                                  spids: [923]
                                )
                              ]
                            )
                            (C {(dienow)})
                          ]
                          spids: [-1 913]
                        )
                      ]
                      spids: [-1 930]
                    )
                    (AndOr
                      children: [
                        (C {(Lit_Other "[")} {(KW_Bang "!")} {(-e)} {(DQ ($ VSub_Name "$SHA1FILE"))} 
                          {(Lit_Other "]")}
                        )
                        (C {(patch_package)})
                      ]
                      op_id: Op_DAmp
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [-1 893]
                )
              ]
              spids: [-1 960]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:SHA1TAR)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [(C {(sha1file)} {(DQ ($ VSub_Name "$FILENAME"))})]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [975 981]
                        )
                      )
                    }
                  spids: [973]
                )
              ]
              spids: [973]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:SHALIST)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (SimpleCommand
                                words: [{(cat)} {(DQ ($ VSub_Name "$SHA1FILE"))}]
                                redirects: [
                                  (Redir
                                    op_id: Redir_Great
                                    fd: 2
                                    arg_word: {(/dev/null)}
                                    spids: [993]
                                  )
                                ]
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [986 996]
                      )
                    }
                  spids: [985]
                )
              ]
              spids: [985]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(Lit_Other "[")} {(KW_Bang "!")} {(-z)} {(DQ ($ VSub_Name "$SHALIST"))} 
                      {(Lit_Other "]")}
                    )
                  ]
                  action: [
                    (ForEach
                      iter_name: i
                      iter_words: [
                        {(DQ ($ VSub_Name "$SHA1TAR"))}
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(sha1file)} 
                                    {
                                      (CommandSubPart
                                        command_list: (CommandList children:[(C {(gather_patches)})])
                                        left_token: <Left_CommandSub "$(">
                                        spids: [1030 1032]
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [1027 1033]
                          )
                        }
                      ]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (C {(Lit_Other "[")} {(-z)} 
                                      {
                                        (DQ 
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (Pipeline
                                                    children: [
                                                      (C {(echo)} {(DQ ($ VSub_Name "$SHALIST"))})
                                                      (C {(grep)} {(DQ ($ VSub_Name "$i"))})
                                                    ]
                                                    negated: False
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [1050 1064]
                                          )
                                        )
                                      } {(Lit_Other "]")}
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:SHALIST)
                                          op: Equal
                                          rhs: {(missing)}
                                          spids: [1073]
                                        )
                                      ]
                                      spids: [1073]
                                    )
                                    (ControlFlow
                                      token: <ControlFlow_Break break>
                                    )
                                  ]
                                  spids: [-1 1070]
                                )
                              ]
                              spids: [-1 1080]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:SHALIST)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (Pipeline
                                                  children: [
                                                    (C {(echo)} {(DQ ($ VSub_Name "$SHALIST"))})
                                                    (C {(sed)} {(DQ (s/) ($ VSub_Name "$i") (//))})
                                                  ]
                                                  negated: False
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1089 1106]
                                        )
                                      )
                                    }
                                  spids: [1087]
                                )
                              ]
                              spids: [1087]
                            )
                          ]
                          spids: [1036 1110]
                        )
                      spids: [1022 -1]
                    )
                    (AndOr
                      children: [
                        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$SHALIST"))} {(Lit_Other "]")})
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  spids: [-1 1014]
                )
              ]
              spids: [-1 1134]
            )
            (C {(echo)} {(-n)} {(DQ ("Extracting '") ($ VSub_Name "$PACKAGE") ("'"))})
            (Subshell
              child: 
                (CommandList
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:UNIQUE)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(readlink)} {(/proc/self)})]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [1158 1162]
                              )
                            }
                          spids: [1157]
                        )
                      ]
                      spids: [1157]
                    )
                    (C {(trap)} {(SQ <"rm -rf \"$BUILD/temp-">) ($ VSub_Name "$UNIQUE") (SQ <"\"">)} 
                      {(EXIT)}
                    )
                    (SimpleCommand
                      words: [{(rm)} {(-rf)} {(DQ ($ VSub_Name "$SRCTREE") (/) ($ VSub_Name "$PACKAGE"))}]
                      redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[1188])]
                    )
                    (AndOr
                      children: [
                        (C {(mkdir)} {(-p)} 
                          {(DQ ($ VSub_Name "$BUILD") (/temp-) ($ VSub_Name "$UNIQUE"))} {(DQ ($ VSub_Name "$SRCTREE"))}
                        )
                        (C {(dienow)})
                      ]
                      op_id: Op_DPipe
                    )
                    (Pipeline
                      children: [
                        (BraceGroup
                          children: [
                            (AndOr
                              children: [
                                (C {(tar)} {(-xv) (${ VSub_Name DECOMPRESS)} {(-f)} 
                                  {(DQ ($ VSub_Name "$FILENAME"))} {(-C)} {(DQ ($ VSub_Name "$BUILD") (/temp-) ($ VSub_Name "$UNIQUE"))}
                                )
                                (AndOr
                                  children: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:TARDIR)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (CommandSubPart
                                                  command_list: 
                                                    (CommandList
                                                      children: [
                                                        (C {(readlink)} {(-f)} 
                                                          {
                                                            (DQ ($ VSub_Name "$BUILD") (/temp-) 
                                                              ($ VSub_Name "$UNIQUE")
                                                            ) (/) (Lit_Other "*")
                                                          }
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub "$(">
                                                  spids: [1248 1260]
                                                )
                                              )
                                            }
                                          spids: [1246]
                                        )
                                      ]
                                      spids: [1246]
                                    )
                                    (C {(touch)} 
                                      {(DQ ($ VSub_Name "$TARDIR") (/) ($ VSub_Name "$SHA1NAME"))}
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          spids: [1212]
                        )
                        (C {(dotprogress)})
                      ]
                      negated: False
                    )
                    (AndOr
                      children: [
                        (C {(Lit_Other "[")} {(-e)} 
                          {(DQ ($ VSub_Name "$BUILD") (/temp-) ($ VSub_Name "$UNIQUE")) (/) 
                            (Lit_Other "*") (/) (DQ ($ VSub_Name "$SHA1NAME"))
                          } {(Lit_Other "]")}
                        )
                        (AndOr
                          children: [
                            (C {(mv)} 
                              {(DQ ($ VSub_Name "$BUILD") (/temp-) ($ VSub_Name "$UNIQUE") (/)) 
                                (Lit_Other "*")
                              } {(DQ ($ VSub_Name "$SRCTREE") (/) ($ VSub_Name "$PACKAGE"))}
                            )
                            (SimpleCommand
                              words: [{(echo)} {(DQ ($ VSub_Name "$SHA1TAR"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_DGreat
                                  fd: -1
                                  arg_word: {(DQ ($ VSub_Name "$SHA1FILE"))}
                                  spids: [1329]
                                )
                              ]
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                )
              spids: [1154 1336]
            )
            (AndOr
              children: [
                (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-ne)} {(0)} {(Lit_Other "]")})
                (C {(dienow)})
              ]
              op_id: Op_DAmp
            )
            (C {(patch_package)})
          ]
          spids: [697]
        )
      spids: [693 696]
    )
    (FuncDef
      name: confirm_checksum
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:SUM)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [
                                (SimpleCommand
                                  words: [
                                    {(sha1file)}
                                    {(DQ ($ VSub_Name "$SRCDIR") (/) ($ VSub_Name "$FILENAME"))}
                                  ]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_Great
                                      fd: 2
                                      arg_word: {(/dev/null)}
                                      spids: [1386]
                                    )
                                  ]
                                )
                              ]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [1377 1388]
                        )
                      )
                    }
                  spids: [1375]
                )
              ]
              spids: [1375]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(Lit_Other "[")} {(x) (DQ ($ VSub_Name "$SUM"))} 
                          {(Lit_Other "=") (Lit_Other "=")} {(x) (DQ ($ VSub_Name "$SHA1"))} {(Lit_Other "]")}
                        )
                        (AndOr
                          children: [
                            (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$SHA1"))} {(Lit_Other "]")})
                            (C {(Lit_Other "[")} {(-f)} 
                              {(DQ ($ VSub_Name "$SRCDIR") (/) ($ VSub_Name "$FILENAME"))} {(Lit_Other "]")}
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$SHA1"))} {(Lit_Other "]")})
                          ]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ ("No SHA1 for ") ($ VSub_Name "$FILENAME") (" (") 
                                  ($ VSub_Name "$SUM") (")")
                                )
                              }
                            )
                          ]
                          spids: [-1 1454]
                        )
                      ]
                      else_action: [(C {(echo)} {(DQ ("Confirmed ") ($ VSub_Name "$FILENAME"))})]
                      spids: [1468 1479]
                    )
                    (AndOr
                      children: [
                        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$EXTRACT_ALL"))} {(Lit_Other "]")})
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (C {(extract_package)} {(DQ ($ VSub_Name "$BASENAME"))})
                    (ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {($ VSub_QMark "$?")}
                    )
                  ]
                  spids: [-1 1438]
                )
              ]
              spids: [-1 1517]
            )
            (C {(rm)} {(-f)} {(DQ ($ VSub_Name "$SRCDIR") (/) ($ VSub_Name "$FILENAME"))})
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [1372]
        )
      spids: [1368 1371]
    )
    (FuncDef
      name: download_from
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(confirm_checksum)})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(wget)} {(-t)} {(2)} {(-T)} {(20)} {(-O)} 
                  {(DQ ($ VSub_Name "$SRCDIR") (/) ($ VSub_Name "$FILENAME"))} {(DQ ($ VSub_Number "$1"))}
                )
                (Subshell
                  child: 
                    (CommandList
                      children: [
                        (Sentence
                          child: 
                            (C {(rm)} {(-f)} {(DQ ($ VSub_Name "$SRCDIR") (/) ($ VSub_Name "$FILENAME"))})
                          terminator: <Op_Semi ";">
                        )
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(2)}
                        )
                      ]
                    )
                  spids: [1622 1637]
                )
              ]
              op_id: Op_DPipe
            )
            (C {(touch)} {(-c)} {(DQ ($ VSub_Name "$SRCDIR") (/) ($ VSub_Name "$FILENAME"))})
            (C {(confirm_checksum)})
          ]
          spids: [1557]
        )
      spids: [1553 1556]
    )
    (FuncDef
      name: download
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:FILENAME)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Pipeline
                                children: [
                                  (C {(echo)} {(DQ ($ VSub_Name "$URL"))})
                                  (C {(sed)} {(SQ <"s .*/  ">)})
                                ]
                                negated: False
                              )
                            ]
                          )
                        left_token: <Left_Backtick "`">
                        spids: [1669 1683]
                      )
                    }
                  spids: [1668]
                )
              ]
              spids: [1668]
            )
            (AndOr
              children: [
                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$RENAME"))} {(Lit_Other "]")})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:FILENAME)
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [
                                    (Pipeline
                                      children: [
                                        (C {(echo)} {(DQ ($ VSub_Name "$FILENAME"))})
                                        (C {(sed)} {(-r)} {(DQ ($ VSub_Name "$RENAME"))})
                                      ]
                                      negated: False
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub "$(">
                              spids: [1700 1716]
                            )
                          )
                        }
                      spids: [1698]
                    )
                  ]
                  spids: [1698]
                )
              ]
              op_id: Op_DPipe
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(Lit_Other "[")} {(-z)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (SimpleCommand
                                    words: [{(sha1sum)}]
                                    redirects: [
                                      (Redir
                                        op_id: Redir_Less
                                        fd: -1
                                        arg_word: {(/dev/null)}
                                        spids: [1731]
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [1728 1734]
                          )
                        )
                      } {(Lit_Other "]")}
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [{(echo)} {(DQ ("Error: please install sha1sum"))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[1749])]
                    )
                    (C {(exit)} {(1)})
                  ]
                  spids: [-1 1740]
                )
              ]
              spids: [-1 1758]
            )
            (C {(echo)} {(-ne)} 
              {
                (DQ ("checking ") ($ VSub_Name "$FILENAME") 
                  (EscapedLiteralPart token:<Lit_EscapedChar "\\r">)
                )
              }
            )
            (SimpleCommand
              words: [{(touch)} {(-c)} {(DQ ($ VSub_Name "$SRCDIR")) (/) (DQ ($ VSub_Name "$FILENAME"))}]
              redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[1791])]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:BASENAME)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [(C {(noversion)} {(DQ ($ VSub_Name "$FILENAME"))})]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [1802 1808]
                        )
                      )
                    }
                  spids: [1800]
                )
              ]
              spids: [1800]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (Pipeline
                          children: [
                            (C {(is_in_list)} {(DQ ($ VSub_Name "$BASENAME"))} 
                              {(DQ ($ VSub_Name "$IGNORE_REPOS"))}
                            )
                          ]
                          negated: True
                        )
                        (C {(Lit_Other "[")} {(-d)} 
                          {(DQ ($ VSub_Name "$SRCDIR") (/) ($ VSub_Name "$BASENAME"))} {(Lit_Other "]")}
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (C {(echo)} {(DQ ("Using ") ($ VSub_Name "$SRCDIR") (/) ($ VSub_Name "$BASENAME"))})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$EXTRACT_ALL"))} 
                              {(Lit_Other "=") (Lit_Other "=")} {(force)} {(Lit_Other "]")}
                            )
                          ]
                          action: [
                            (AndOr
                              children: [
                                (C {(rm)} {(-rf)} 
                                  {(DQ ($ VSub_Name "$SRCTREE") (/) ($ VSub_Name "$BASENAME"))}
                                )
                                (AndOr
                                  children: [
                                    (C {(cp)} {(-a)} 
                                      {(DQ ($ VSub_Name "$SRCDIR") (/) ($ VSub_Name "$BASENAME"))} {(DQ ($ VSub_Name "$SRCTREE") (/) ($ VSub_Name "$BASENAME"))}
                                    )
                                    (C {(dienow)})
                                  ]
                                  op_id: Op_DPipe
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          spids: [-1 1870]
                        )
                      ]
                      spids: [-1 1907]
                    )
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [-1 1841]
                )
              ]
              spids: [-1 1916]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(Lit_Other "[")} {(KW_Bang "!")} {(-z)} {(DQ ($ VSub_Name "$PREFERRED_MIRROR"))} 
                      {(Lit_Other "]")}
                    )
                  ]
                  action: [
                    (AndOr
                      children: [
                        (C {(download_from)} 
                          {(DQ ($ VSub_Name "$PREFERRED_MIRROR") (/) ($ VSub_Name "$FILENAME"))}
                        )
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  spids: [-1 1940]
                )
              ]
              spids: [-1 1958]
            )
            (AndOr
              children: [
                (C {(download_from)} {(DQ ($ VSub_Name "$URL"))})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
              op_id: Op_DAmp
            )
            (ForEach
              iter_name: i
              iter_words: [{($ VSub_Name "$MIRROR_LIST")}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (AndOr
                      children: [
                        (C {(download_from)} {(DQ ($ VSub_Name "$i") (/) ($ VSub_Name "$FILENAME"))})
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  spids: [1993 2011]
                )
              spids: [1989 -1]
            )
            (C {(echo)} {(DQ ("Could not download ") ($ VSub_Name "$FILENAME"))})
            (C {(echo)} {(-en)} {(DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\e">) ("[0m"))})
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [1665]
        )
      spids: [1661 1664]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:START_TIME)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [(C {(date)} {(Lit_Other "+") (Lit_Other "%") (s)})]
                  )
                left_token: <Left_Backtick "`">
                spids: [2050 2056]
              )
            }
          spids: [2049]
        )
      ]
      spids: [2049]
    )
    (FuncDef
      name: cleanup_oldfiles
      body: 
        (BraceGroup
          children: [
            (C {(wait)})
            (ForEach
              iter_name: i
              iter_words: [{(DQ (${ VSub_Name SRCDIR)) (/) (Lit_Other "*")}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (AndOr
                              children: [
                                (C {(Lit_Other "[")} {(-f)} {(DQ ($ VSub_Name "$i"))} {(Lit_Other "]")})
                                (C {(Lit_Other "[")} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(date)} {(Lit_Other "+") (Lit_Other "%") (s)} {(-r)} 
                                                {(DQ ($ VSub_Name "$i"))}
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [2110 2122]
                                      )
                                    )
                                  } {(-lt)} {(DQ (${ VSub_Name START_TIME))} {(Lit_Other "]")}
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          action: [
                            (C {(echo)} {(Removing)} {(old)} {(file)} {(DQ ($ VSub_Name "$i"))})
                            (C {(rm)} {(-rf)} {(DQ ($ VSub_Name "$i"))})
                          ]
                          spids: [-1 2136]
                        )
                      ]
                      spids: [-1 2161]
                    )
                  ]
                  spids: [2090 2164]
                )
              spids: [2080 -1]
            )
          ]
          spids: [2063]
        )
      spids: [2059 2062]
    )
  ]
)