xbuild

#!/bin/bash

source ./xconfig
echo -e "armx-tool\nversion:v0.1\n"

# Project Settings.
cat ./README.md && echo ""
read -p "Project: " ID

# backup project into home folder.
backup_project(){
  tar -cf $ID-$(date +%d-%m)-bkp.tar.gz .build_$ID
  mv *-bkp.tar.gz $HOME
}

# check project name.
if [ -d .*_${ID} ]; then
  cd .*_${ID}
else
  mkdir -p .build_$ID && cd .*_${ID}
fi

# Project source.
DIR_BUILD=.build_${ID}

# Linaro ARM Compiler.
compiler(){
  pkglist=""
  versions=$(curl -s "$MIRROR_LINARO"|grep binaries|sed -e "s/<a href=\"\/components\/toolchain\/binaries\///g"|sed 's/\/"//g'|sort)

  for pkg in $versions; do
    pkglist="$pkglist FALSE $pkg";
  done

  compiladores=`zenity --title="Linaro Toolchain GCC Compiler List"\
		       --width=$WIDTH\
                       --height=$HEIGHT\
                       --text="Choose item:"\
                       --list\
                       --column="Selected"\
		       --column="Linaro Toolchain Package"\
                       --radiolist $pkglist\
                       --ok-label="Build Source"\
                       --cancel-label="Back"`

  if [ $? -eq 0 ]; then
    for VERSION in $compiladores; do

        # scrapping shell.
        GCC=$(curl -s "$MIRROR_LINARO$VERSION$HARD_FLOAT"|grep -E "$HARD_FLOAT_ARCH")
	GCC=$(echo $GCC|sed -e "s/<a href=\"\/components\/toolchain\/binaries\/"$VERSION"\/arm-linux-gnueabihf//g")
	GCC=${GCC:1:-1};
	mkdir -p $GCC_BUILD_NAME

	# download compiler.
        echo -e "\n[GCC] Download GCC ARM Compiler -> "$VERSION"\n"
        curl $MIRROR_LINARO$VERSION$HARD_FLOAT$GCC -L -O

	# extract compiler.
        echo -e "\n[GCC] Extract GCC ARM Compiler -> "$GCC""
        tar -xf $GCC && rm -f $GCC && BINARY=$(ls -d gcc*arm-linux-gnueabihf) && mv $BINARY $GCC_BUILD_NAME

        # update bash profile(GCC) & test ${CC}gcc --version
        echo "CC=$PWD/$GCC_BUILD_NAME/$BINARY/bin/arm-linux-gnueabihf-" >> ~/.bash_profile && . ~/.bash_profile
        ${CC}gcc --version|grep $VERSION
    done
    else
      echo "GCC Return Main Menu!"
  fi
}

# Universal Bootloader (U-Boot).
bootloader(){
  pkglist=""
  git init $UBOOT_BUILD_NAME --quiet && cd $UBOOT_BUILD_NAME
  git remote add master $MIRROR_UBOOT
  UBOOT_LIST=$(git ls-remote --tags $MIRROR_UBOOT|awk '{gsub("refs/tags/","");print $2}'|grep "v.*[^}]$"|sort)

  for pkg in $UBOOT_LIST; do
    pkglist="$pkglist FALSE $pkg";
  done

  uboot=`zenity --title="Universal Bootloader List"\
                  --width=$WIDTH\
		  --height=$HEIGHT\
                  --text="Choose item:"\
                  --list\
                  --column="Selected"\
                  --column="U-Boot Tag Version"\
                  --radiolist $pkglist\
		  --ok-label="Build Source"\
                  --cancel-label="Back"`

  if [ $? -eq 0 ]; then
    for VERSION in $uboot; do
	echo -e "\n[U-BOOT] Download Bootloader -> "$VERSION"\n"
	git clone -b $VERSION --depth 1 $MIRROR_UBOOT $VERSION && cd $VERSION
        git checkout -b $VERSION --quiet && git status
        make ARCH=arm CROSS_COMPILE=${CC} distclean
        make ARCH=arm CROSS_COMPILE=${CC} qemu_arm_defconfig
	make ARCH=arm CROSS_COMPILE=${CC}
	cd ../../
    done
    else
      echo "U-Boot Return Main Menu!"
  fi
}


# Linux Kernel.
kernel(){
  pkglist=""
  git init $KERNEL_BUILD_NAME --quiet && cd $KERNEL_BUILD_NAME
  git remote add master $MIRROR_KERNEL
  tag_list=$(git ls-remote --tags $MIRROR_KERNEL|awk '{gsub("refs/tags/","");print $2}'|grep ".*[^}]$"|sort)
  KERNEL_LIST=${tag_list::-3}

  for pkg in $KERNEL_LIST; do
    pkglist="$pkglist FALSE $pkg";
  done

  kernel=`zenity --title="Linux Kernel List"\
                  --width=$WIDTH\
                  --height=$HEIGHT\
                  --text="Choose item:"\
                  --list\
                  --column="Selected"\
                  --column="U-Boot Tag Version"\
                  --radiolist $pkglist`

  if [ $? -eq 0 ]; then
    for VERSION in $kernel; do
	echo -e "\n[KERNEL] Download Linux Kernel -> "$VERSION"\n"
	git clone -b $VERSION --depth 1 $MIRROR_KERNEL $VERSION && cd $VERSION
	git checkout -b $VERSION --quiet && git status
        make ARCH=arm CROSS_COMPILE=${CC} distclean
        make ARCH=arm CROSS_COMPILE=${CC} defconfig
        make ARCH=arm CROSS_COMPILE=${CC}
        cd ../../
    done
    else
      echo "Kernel Return Main Menu!"
  fi
}

# Root File System.
file_system(){
  pkglist=""
  RTFS_LIST=$(curl -s $MIRROR_FS|sed -nr 's/(.*)href="?([^ ">]*).*/\2\n\1/; T; P; D;')
  mkdir -p $RTFS_BUILD_NAME

  for pkg in $RTFS_LIST; do
    pkglist="$pkglist FALSE $pkg";
  done

  rtfs=`zenity --title="Root File System List"\
                  --width=$WIDTH\
                  --height=$HEIGHT\
                  --text="Choose item:"\
                  --list --column="Selected"\
                  --column="Root File System"\
                  --radiolist $pkglist`

  if [ $? -eq 0 ]; then
    for VERSION in $rtfs; do
	echo -e "\n[RTFS] Download Root File System -> "$VERSION"\n"
        curl $MIRROR_FS$VERSION -L -O && rm -f $MIRROR_FS$VERSION
        BINARY=$(ls -d alpine*-*) && mv $BINARY $RTFS_BUILD_NAME && cd ../../
    done
    else
      echo "RTFS Return Main Menu!"
  fi
}

build(){
  echo "testing..."
}

kvm(){
  echo "testing..."
}

# Beaglebone Black Main xbuild.
while true;
do
  main=`zenity --title="Build ARM Image for Beaglebone Black."\
               --width=$WIDTH\
	       --height=$HEIGHT\
               --list\
	       --column="Configure Packages:"\
               		"ARM Cross Compiler: GCC"\
                        "Bootloader: U-Boot"\
                        "Linux Kernel"\
                        "Root File System"\
                        "Install Kernel and Root File System"\
			"Virtual ARM with KVM/QEMU"`

  case "${main}" in
  "ARM Cross Compiler: GCC") compiler;;
  "Bootloader: U-Boot") bootloader;;
  "Linux Kernel") kernel;;
  "Root File System") file_system;;
  "Install Kernel and Root File System") build;;
  "Virtual ARM with KVM/QEMU") kvm;;
  *)
  exit 1
 esac
done