AMiRo-OS

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

  printf "          -m, --module <module>\n"

  printf "              Create project for a single module.\n"

  printf "          -a, --all\n"

  printf "              Create projects for all modules.\n"

  printf "          -c, --clean\n"

  printf "              Delete project files.\n"

  printf "          -w, --wipe\n"

  printf "              Delete project and .user files.\n"

  printLog "reading path for project files from user...\n"

### create project files for a single module ###################################

# Create project files for a single module.

# usage:      createModuleProject <modules> [-m|--module=<module>] [-p|--path=<path>] [--gcc=<path>] [-o|--out=<var>] [--gccout=<var>]

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

function createModuleProject {

  local moduleidx=""

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

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

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

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

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

    # store selection

    moduleidx=$(($userinput - 1))

    module="${modules[$moduleidx]}"

    # search all modules for the selected one

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

      if [ "${modules[$idx]}" = "$module" ]; then

        moduleidx=$idx

        break

      fi

    done

    # error if the module could not be found

    if [ -z $moduleidx ]; then

      printError "module ($module) not available\n"

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

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

  # print message

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

  # change to project directory

  cd "$projectdir"

  # 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 makedir=""

  local makedirs=()

  local quotes="\'\"\´\`\„\“"

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

  printInfo "processing project (this may take a while)...\n"

  local rawout=$(make --directory ${modulesdir}/${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 module directory failed\n"

    cd "$userdir"

    return -3

  else

    # cleanup

    make --directory ${modulesdir}/${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 or a nested make call leaves the directory, a message appears like:

        # make[1]: Entering directory 'directory'

        # make[999]: Verzeichnis „directory“ wird verlassen

        elif [[ "$line" =~ ^make(\[[0-9]+\])?:([[:alnum:]]|[[:blank:]])*[$quotes].*[$quotes]([[:alnum:]]|[[:blank:]])*$ ]]; then

          # extract directory path

          makedir=$(echo ${line} | grep -oE "[${quotes}].*[${quotes}]" | grep -oE "[^${quotes}].*[^${quotes}]")

          # if the makedirs stack is empty or the directory does not mathc the last entry

          if [ ${#makedirs[@]} == 0 ] || [ "${makedir}" != "${makedirs[-1]}" ]; then

            # push the directory to the stack

            makedirs+=(${makedir})

          else

            # pop the directory from the stack

            unset makedirs[-1]

          fi

        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 "" > ${projectdir}/${module}.includes

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

    echo "$inc" >> ${projectdir}/${module}.includes

  done

  # generate the .files file, containing all source files

  echo "" > ${projectdir}/${module}.files

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

    # skip GCC files

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

      echo "$source" >> ${projectdir}/${module}.files

  done

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

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

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

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

  fi

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

  if [ ! -f ${projectdir}/${module}.creator ]; then

    echo "[general]" > ${projectdir}/${module}.creator

  fi

  # go back to user directory

  cd $userdir

### create project files for all modules #######################################

# Create project files for all modules.

#

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

# arguments:  <modules>

#                 Array containing all modules 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 modules available.

#

function createAllProjects {

  local modules=("${!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 modules variable

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

    printError "no modules available\n"

    return -1

  fi

  # read absolute project directory if required

  if [ -z "$projectsdir" ]; then

    getProjectDir projectsdir

  fi

  # check for existing project files

  local projectfiles=()

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

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

  done

  if [ ${#projectfiles[@]} != 0 ]; 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" 2>&1 | tee -a $LOG_FILE

        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 modules...\n"

  # retrieve absolute GCC include path

  if [ -z "$gccincludedir" ]; then

    retrieveGccIncludeDir gccincludedir

  fi

  # iterate over all modules

  local retval=1

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

    if [ $retval != 0 ]; then

      printf "\n"

    fi

    createModuleProject modules[@] --module="$module" --path="$projectsdir" --gcc="$gccincludedir"

    retval=$?

  done

  return 0

}

### delete project files #######################################################

# usage:      deleteProjects [-p|--path=<path>] [-m|--module=<module>] [-o|--out=<var>] [-w|-wipe]

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

#             -w, --wipe

#                 Delete .user files as well.

# return:

#  -  0: no error

function deleteProjects {

  local modulename=""

  local wipe=false

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

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

          wipe=true; shift 1;;

  # list all files to be deleted

  if [ -z "$modulename" ]; then

    if [ $wipe != true ]; then

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

    else

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

    if [ $wipe != true ]; then

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

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

  if [ ${#files[@]} != 0 ]; then

    printInfo "Deleting the following files:\n"

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

    printInfo "No project files found\n"

        -m=*|--module=*)

          createModuleProject modules[@] --module="${1#*=}"; printf "\n"; shift 1;;

        -m|--module)

          createModuleProject modules[@] --module="${2}"; printf "\n"; shift 2;;

        -a|--all)

          createAllProjects modules[@]; shift 1;;

        -c|--clean)

          deleteProjects; printf "\n"; shift 1;;

        -w|--wipe)

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

    printf "  [M] - create a project for a single module\n"

    printf "  [A] - create a project for all modules\n"

    printf "  [C] - clean all project files\n"

    printf "  [W] - wipe all project and .user files\n"

    readUserInput "MmAaCcWwQq" userinput

      M|m)

        createModuleProject modules[@]; printf "\n";;

      A|a)

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

      C|c)

        deleteProjects; printf "\n";;

      W|w)

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