AMiRo-OS

Subproject commit cacd990cefab7167a7cac1ea1f5a8ec8e87687d7

OS_MODULES_DIR := $(OS_DIR)/AMiRo-OS/modules

  printf "usage:    $(basename ${BASH_SOURCE[0]}) [-h|--help] [-p|--project=<project>] [-a|--all] [-c|--clean] [-w|--wipe] [-q|--quit] [--log=<file>]\n"

  printf "          -p, --project <project>\n"

  printf "              Create projects for a single configuration.\n"

  printf "          -a, --all\n"

  printf "              Create projects for all configurations.\n"

# usage:      getProjectsDir <pathvar>

function getProjectsDir {

#            -2

#                 Error: include directory could not be resolved.

  local gccincpath=""

      binpath=$(realpath $(dirname $binpath)/$(readlink $binpath))

    gccincpath=$(realpath $(dirname ${binpath})/../arm-none-eabi/include/)

    if [ ! -d "$gccincpath" ]; then

      printWarning "$gccincpath does not exist\n"

      return -2

    else

      eval $1="$gccincpath"

      return 0

    fi

### detect available configurations ############################################

# Detect all avalable configurations.

# usage:      detectConfigurations <configurationsarray>

# arguments:  <configurationsarray>

#                 Array variable to store all detected configurations to.

# return:     n/a

#

function detectConfigurations {

  local configsdir=$(realpath $(dirname $(realpath ${BASH_SOURCE[0]}))/../../../configurations)

  local configs_detected=()

  # detect all available modules (via directories)

  for dir in $(ls -d ${configsdir}/*/); do

    configs_detected[${#configs_detected[@]}]=$(basename $dir)

  done

  # set the output variable

  eval "$1=(${configs_detected[*]})"

}

### create project files for a single configuration ############################

# Create project files for all modules of a configuration.

#

# usage:      createConfigProjects <configurations> [-c|--config=<configuration>] [-p|--path=<path>] [--gcc=<path>] [-o|--out=<var>] [--gccout=<var>]

# arguments:  <configurations>

#                 Array containing all configurations available.

#             -c, --config <configuration>

#                 Name (folder name) of the configuration for which project files shall be generated.

#             -p, --path <path>

#                 If this optional arguments is absent, ths function will ask for user input.

#             1

#                 Aborted by user.

#             2

#                 The selected configuration does not contain any modules.

#             -1

#                 No configurations available.

#             -2

#                 The specified <configuration> could not be found.

#             -3

#                 Parsing the project for the specified configuration failed.

#             -4

#                 Missing dependencies.

function createConfigProjects {

  local configsdir=$(realpath $(dirname $(realpath ${BASH_SOURCE[0]}))/../../../configurations)

  local configs=("${!1}")

  local config=""

  local configidx=""

  local projectsdir=""

  # check dependencies

  checkCommands make

  if [ $? -ne 0 ]; then

    printError "Missing dependencies detected.\n"

    return -4

  fi

        -c=*|--config=*)

          config="${1#*=}"; shift 1;;

        -c|--config)

          config="$2"; shift 2;;

          projectsdir=$(realpath "${1#*=}"); shift 1;;

          projectsdir=$(realpath "$2"); shift 2;;

  # sanity check for the configs variable

  if [ -z "${configs[*]}" ]; then

    printError "no configurations available\n"

    return -1

  fi

  # select configuration

  if [ -z $config ]; then

    # list all available configurations

    printInfo "choose a configuration or type 'A' to abort:\n"

    for (( idx=0; idx<${#configs[@]}; ++idx )); do

      printf "%4u: %s\n" $(($idx + 1)) "${configs[$idx]}"

    done

    # read user input

    printLog "read user selection\n"

    local userinput=""

    while [[ ! "$userinput" =~ ^[0-9]+$ ]] || [ ! "$userinput" -gt 0 ] || [ ! "$userinput" -le ${#configs[@]} ] && [[ ! "$userinput" =~ ^[Aa]$ ]]; do

      read -p "your selection: " -e userinput

      printLog "user selection: $userinput\n"

      if [[ ! "$userinput" =~ ^[0-9]+$ ]] || [ ! "$userinput" -gt 0 ] || [ ! "$userinput" -le ${#configs[@]} ] && [[ ! "$userinput" =~ ^[Aa]$ ]]; then

        printWarning "Please enter an integer between 1 and ${#configs[@]} or 'A' to abort.\n"

      fi

    done

    if [[ "$userinput" =~ ^[Aa]$ ]]; then

      printWarning "aborted by user\n"

      return 1

    fi

    # store selection

    configidx=$(($userinput - 1))

    config="${configs[$configidx]}"

    printf "\n"

  else

    # search all configurations for the selected one

    for (( idx=0; idx<${#configs[@]}; ++idx )); do

      if [ "${configs[$idx]}" = "$config" ]; then

        configidx=$idx

        break

      fi

    done

    # error if the configurations could not be found

    if [ -z $configidx ]; then

      printError "configuration ($config) not available\n"

      return -2

    fi

  fi

  # retrieve modules in the configuration

  local modules=()

  if [ -d ${configsdir}/${config}/modules ]; then

    for dir in $(ls -d ${configsdir}/${config}/modules/*/); do

      modules[${#modules[@]}]=$(basename $dir)

    done

    if [ ${#modules[@]} -eq 0 ]; then

      printWarning "configuration ${config} does not contain any modules\n"

      return 2

    fi

  else

    printWarning "'module/' folder does not exist in configuration ${config}\n"

    return 2

  fi

  if [ -z "$projectsdir" ]; then

    getProjectsDir projectsdir

    printf "\n"

  fi

  # check for existing project files

  local projectfiles=""

  for module in ${modules[@]}; do

    projectfiles+="$(find ${projectsdir} -maxdepth 1 -type f | grep -E "${config}_${module}\.(includes|files|config|creator)$")"

  done

  IFS=$'\n'; projectfiles=($projectfiles); unset IFS

  if [ ! -z "${projectfiles[*]}" ]; then

    printWarning "The following files will be overwritten:\n"

    for pfile in ${projectfiles[@]}; do

      printWarning "\t$(basename $pfile)\n"

    done

    local userinput=""

    printInfo "Continue and overwrite? [y/n]\n"

    readUserInput "YyNn" userinput

    case "$userinput" in

      Y|y)

        ;;

      N|n)

        printWarning "Project generation for ${config} configuration aborted by user\n"

        return 1

        ;;

      *)

        printError "unexpected input: ${userinput}\n"; return -999;;

    esac

    printf "\n"

  # print message

  printInfo "generating QtCreator project files for the $config configuration...\n"

  # retrieve absolute GCC include path

  # change to project directory

  cd "$projectsdir"

  # create project files for each module of the selected configuration

  for module in ${modules[@]}; do

    # run make, but only run the GCC preprocessor and produce no binaries

    local sourcefiles=()

    local sourcefile=""

    local parse_state="WAIT_FOR_INCLUDE_COMPILE_MAKE"

    local makedirs=()

    # capture all output from make and GCC and append the return value of make as last line

    printInfo "processing module ${module} (this may take a while)...\n"

    local rawout=$(make --directory ${configsdir}/${config}/modules/${module} --always-make USE_OPT="-v -E -H" USE_VERBOSE_COMPILE="no" OUTFILES="" 2>&1 && echo $?)

    # check whether the make call was successfull

    if [[ $(echo "${rawout}" | tail -n 1) != "0" ]]; then

      printError "executing 'make' in configuration directory failed\n"

      cd "$userdir"

      return -3

    else

      # cleanup

      make --directory ${configsdir}/${config}/modules/${module} clean &>/dev/null

    fi

    # extract file names from raw output

    IFS=$'\n'; rawout=($rawout); unset IFS

    for line in "${rawout[@]}"; do

      case $parse_state in

        WAIT_FOR_INCLUDE_COMPILE_MAKE)

          # lines stating include files look like:

          # ... <../relative/path/to/file>

          if [[ "$line" =~ ^\.+[[:blank:]].+\..+$ ]]; then

            sourcefile=${line##* }

            if [[ ! "$sourcefile" =~ ^/ ]]; then

              sourcefile=$(realpath ${makedirs[-1]}/${sourcefile})

            fi

            sourcefiles[${#sourcefiles[@]}]="$sourcefile"

          # whenever the next source file is processed, a message appears like:

          # Compiling <filename>

          elif [[ "$line" =~ ^Compiling[[:blank:]](.+\..+)$ ]]; then

            printf "."

            sourcefile=${BASH_REMATCH[1]}

            parse_state="WAIT_FOR_COMPILERCALL"

          # if make is called again in another directory, a message appears like:

          # make[1]: Entering directory 'directory'

          elif [[ "$line" =~ ^make(\[[0-9]+\])?:\ Entering\ directory\ \'.+\'$ ]]; then

            makedirs+=($(echo "$line" | (cut -d "'" -f 2)))

          # if make is leaving a directory, a message appears like:

          # make[1]: Leaving directory 'directory'

          elif [[ "$line" =~ ^make(\[[0-9]+\])?:\ Leaving\ directory\ \'.+\'$ ]]; then

            unset makedirs[-1]

          fi;;

        WAIT_FOR_COMPILERCALL)

          # wait for the actual call of the compiler to retrieve the full path to the source file

          if [[ "$line" == *${sourcefile}* ]]; then

            line="${line%%${sourcefile}*}${sourcefile}"

            line="${line##* }"

            if [[ "$line" =~ ^/ ]]; then

              # aboslute path

              sourcefile=$line

            else

              # relative path

              sourcefile=$(realpath ${makedirs[-1]}/${line##* })

            fi

            sourcefiles[${#sourcefiles[@]}]="$sourcefile"

            parse_state="WAIT_FOR_INCLUDE_COMPILE_MAKE"

          fi;;

      esac

    done

    unset rawout

    printf "\n"

    # sort and remove duplicates

    IFS=$'\n'; sourcefiles=($(sort --unique <<< "${sourcefiles[*]}")); unset IFS

    # extract include paths

    local includes=()

    for source in ${sourcefiles[*]}; do

      includes[${#includes[@]}]="$(dirname ${source})"

    done

    # sort and remove duplicates

    IFS=$'\n'; includes=($(sort --unique <<< "${includes[*]}")); unset IFS

    # generate the .incldues file, containing all include paths

    echo "" > ${projectsdir}/${config}_${module}.includes

    for inc in ${includes[*]}; do

      echo "$inc" >> ${projectsdir}/${config}_${module}.includes

    done

    # generate the .files file, containing all source files

    echo "" > ${projectsdir}/${config}_${module}.files

    for source in ${sourcefiles[*]}; do

      # skip GCC files

      if [[ ! "$source" =~ .*/gcc.* ]]; then

        echo "$source" >> ${projectsdir}/${config}_${module}.files

      fi

    done

    # generate a default project configuration file if it doesn't exits yet

    if [ ! -f ${projectsdir}/${config}_${module}.config ]; then

      echo "// Add predefined macros for your project here. For example:" > ${projectsdir}/${config}_${module}.config

      echo "// #define YOUR_CONFIGURATION belongs here" >> ${projectsdir}/${config}_${module}.config

    fi

    # generate a default .creator file if it doesn't exist yet

    if [ ! -f ${projectsdir}/${config}_${module}.creator ]; then

      echo "[general]" > ${projectsdir}/${config}_${module}.creator

    fi

    eval $outvar="$projectsdir"

### create project files for all configurations ################################

# Create project files for all configurations.

#

# usage:      createAllProjects <configurations> [-p|--path=<path>] [--gcc=<path>] [-o|--out=<var>] [--gccout=<var>]

# arguments:  <configurations>

#                 Array containing all configurations available.

#             -p, --path <path>

#                 Path where to create the project files.

#             --gcc=<path>

#                 Path to the GCC include directory.

#             -o, --out <var>

#                 Variable to store the path to.

#             --gccout=<var>

#                 Variable to store the path to the GCC include directory to.

#                 If this optional arguments is absent, ths function will ask for user input.

# return:     0

#                 No error or warning occurred.

#             1

#                 Aborted by user.

#             -1

#                 No configurations available.

#

function createAllProjects {

  local configs=("${!1}")

  local projectsdir=""

  local gccincludedir=""

  local outvar=""

  local gccoutvar=""

  # parse arguments

  local otherargs=()

  while [ $# -gt 0 ]; do

    if ( parseIsOption $1 ); then

      case "$1" in

        -p=*|--path=*)

          projectsdir=$(realpath "${1#*=}"); shift 1;;

        -p|--path)

          projectsdir=$(realpath "$2"); shift 2;;

        --gcc=*)

          gccincludedir=$(realpath "${1#*=}"); shift 1;;

        --gcc)

          gccincludedir=$(realpath "$2"); shift 2;;

        -o=*|--out=*)

          outvar=${1#*=}; shift 1;;

        -o|--out)

          outvar=$2; shift 2;;

        --gccout=*)

          gccoutvar=$(realpath "${1#*=}"); shift 1;;

        --gccout)

          gccoutvar=$(realpath "$2"); shift 2;;

        *)

          printError "invalid option: $1\n"; shift 1;;

      esac

    else

      otherargs+=("$1")

      shift 1

    fi

  done

  # sanity check for the configurations variable

  if [ -z "${configs[*]}" ]; then

    printError "no configurations available\n"

    return -1

  fi

  # read absolute project directory if required

  if [ -z "$projectsdir" ]; then

    getProjectsDir projectsdir

  fi

  # check for existing project files

  local projectfiles=""

  for config in ${configs[@]}; do

    for module in ${modules[@]}; do

      projectfiles+="$(find ${projectsdir} -maxdepth 1 -type f | grep -E "${config}_${module}\.(includes|files|config|creator)$")"

    done

  done

  IFS=$'\n'; projectfiles=($projectfiles); unset IFS

  if [ ! -z "${projectfiles[*]}" ]; then

    printWarning "The following files will be removed:\n"

    for pfile in ${projectfiles[@]}; do

      printWarning "\t$(basename $pfile)\n"

    done

    local userinput=""

    printInfo "Continue and overwrite? [y/n]\n"

    readUserInput "YyNn" userinput

    case "${userinput}" in

      Y|y)

        for pfile in ${projectfiles[*]}; do

          rm "$pfile"

        done

        ;;

      N|n)

        printWarning "Project generation aborted by user\n"

        return 1

        ;;

      *)

        printError "unexpected input: ${userinput}\n"

        return 999

        ;;

    esac

  fi

  # print message

  printf "\n"

  printInfo "generating QtCreator project files for all configurations...\n"

  # retrieve absolute GCC include path

  if [ -z "$gccincludedir" ]; then

    retrieveGccIncludeDir gccincludedir

  fi

  # iterate over all configurations

  local retval=1

  for config in ${configs[@]}; do

    if [ $retval != 0 ]; then

      printf "\n"

    fi

    createConfigProjects configs[@] --config="$config" --path="$projectsdir" --gcc="$gccincludedir"

    retval=$?

  done

  return 0

}

# usage:      deleteProjects [-p|--path=<path>] [-c|--config=<configuration>] [-o|--out=<var>] [-w|-wipe]

#             -c, --config <configuration>

#                 Configuration name for which the project files shall be deleted.

#

function deleteProjects {

  local config=""

  local projectsdir=""

  local files=""

          projectsdir=$(realpath "${1#*=}"); shift 1;;

          projectsdir=$(realpath "$2"); shift 2;;

        -c=*|--config=*)

          config="${1#*=}"; shift 1;;

        -c|--config)

          config="${2}"; shift 2;;

  # read absolute project directory if required

  if [ -z "$projectsdir" ]; then

    getProjectsDir projectsdir

  # list all files to be deleted

  if [ -z "$config" ]; then

    if [ $wipe != true ]; then

      files=$(find "${projectsdir}" -maxdepth 1 -type f | grep -E "^.+\.(includes|files|config|creator|cflags|cxxflags)$")

    else

      files=$(find "${projectsdir}" -maxdepth 1 -type f | grep -E "^.+\.(includes|files|config|creator|cflags|cxxflags|creator(\.user(\..+)?)?)$")

    fi

  else

    if [ $wipe != true ]; then

      files=$(find "${projectsdir}" -maxdepth 1 -type f | grep -E "^${config}_.+\.(includes|files|config|creator|cflags|cxxflags)$")

    else

      files=$(find "${projectsdir}" -maxdepth 1 -type f | grep -E "^${config}_.+\.(includes|files|config|creator|cflags|cxxflags|creator(\.user(\..+)?)?)$")

    fi

  if [ ! -z "$files" ]; then

    printInfo "Deleting the following files:\n"

    while read line; do

      printInfo "\t$(basename ${line})\n"

      rm ${line} 2>&1 | tee -a $LOG_FILE

    done <<< "${files}"

  else

    printInfo "No project files found\n"

    eval $outvar="$projectsdir"

# Creates, deletes and wipes QtCreator project files.

  # detect available configurations and inform user

  local configurations=()

  detectConfigurations configurations

  case "${#configurations[@]}" in

    0)

      printInfo "no configuration has been detected\n";;

    1)

      printInfo "1 configuration has been detected:\n";;

    *)

      printInfo "${#configurations[@]} configurations have been detected:\n";;

  esac

  for (( idx=0; idx<${#configurations[@]}; ++idx )); do

    printInfo "  - ${configurations[$idx]}\n"

  done

  printf "\n"

        -p=*|--project=*)

          createConfigProjects configurations[@] --configuration="${1#*=}"; printf "\n"; shift 1;;

        -p|--project)

          createConfigProjects configurations[@] --configuration="${2}"; printf "\n"; shift 2;;

        -a|--all)

          createAllProjects configurations[@]; shift 1;;

    printf "  [P] - create projects for a single configuration\n"

    printf "  [A] - create projects for all configurations\n"

    readUserInput "PpAaCcWwQq" userinput

      P|p)

        createConfigProjects configurations[@]; printf "\n";;

      A|a)

        createAllProjects configurations[@]; printf "\n";;

        deleteProjects; printf "\n";;

        deleteProjects --wipe; printf "\n";;