Statistics
| Branch: | Tag: | Revision:

amiro-os / tools / ide / QtCreator / QtCreatorSetup.sh @ 8516dad6

History | View | Annotate | Download (25.9 KB)

1
################################################################################
2
# AMiRo-OS is an operating system designed for the Autonomous Mini Robot       #
3
# (AMiRo) platform.                                                            #
4
# Copyright (C) 2016..2020  Thomas Schöpping et al.                            #
5
#                                                                              #
6
# This program is free software: you can redistribute it and/or modify         #
7
# it under the terms of the GNU General Public License as published by         #
8
# the Free Software Foundation, either version 3 of the License, or            #
9
# (at your option) any later version.                                          #
10
#                                                                              #
11
# This program is distributed in the hope that it will be useful,              #
12
# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
13
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #
14
# GNU General Public License for more details.                                 #
15
#                                                                              #
16
# You should have received a copy of the GNU General Public License            #
17
# along with this program.  If not, see <http://www.gnu.org/licenses/>.        #
18
#                                                                              #
19
# This research/work was supported by the Cluster of Excellence Cognitive      #
20
# Interaction Technology 'CITEC' (EXC 277) at Bielefeld University, which is   #
21
# funded by the German Research Foundation (DFG).                              #
22
################################################################################
23

    
24
#!/bin/bash
25

    
26
# load library
27
source "$(dirname ${BASH_SOURCE[0]})/../../bash/setuplib.sh"
28

    
29
### print welcome text #########################################################
30
# Prints a welcome message to standard out.
31
#
32
# usage:      printWelcomeText
33
# arguments:  n/a
34
# return:     n/a
35
#
36
function printWelcomeText {
37
  printf "######################################################################\n"
38
  printf "#                                                                    #\n"
39
  printf "#                  Welcome to the QtCreator setup!                   #\n"
40
  printf "#                                                                    #\n"
41
  printf "######################################################################\n"
42
  printf "#                                                                    #\n"
43
  printf "# Copyright (c) 2016..2020  Thomas Schöpping                         #\n"
44
  printf "#                                                                    #\n"
45
  printf "# This is free software; see the source for copying conditions.      #\n"
46
  printf "# There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR  #\n"
47
  printf "# A PARTICULAR PURPOSE. The development of this software was         #\n"
48
  printf "# supported by the Excellence Cluster EXC 227 Cognitive Interaction  #\n"
49
  printf "# Technology. The Excellence Cluster EXC 227 is a grant of the       #\n"
50
  printf "# Deutsche Forschungsgemeinschaft (DFG) in the context of the German #\n"
51
  printf "# Excellence Initiative.                                             #\n"
52
  printf "#                                                                    #\n"
53
  printf "######################################################################\n"
54
}
55

    
56
### print help #################################################################
57
# Prints a help text to standard out.
58
#
59
# usage:      printHelp
60
# arguments:  n/a
61
# return:     n/a
62
#
63
function printHelp {
64
  printInfo "printing help text\n"
65
  printf "usage:    $(basename ${BASH_SOURCE[0]}) [-h|--help] [--module=<module>] [-a|--all] [-c|--clean] [-w|--wipe] [-q|--quit] [--log=<file>]\n"
66
  printf "\n"
67
  printf "options:  -h, --help\n"
68
  printf "              Print this help text.\n"
69
  printf "          --module=<module>\n"
70
  printf "              Create project for a single module.\n"
71
  printf "          -a, --all\n"
72
  printf "              Create projects for all modules.\n"
73
  printf "          -c, --clean\n"
74
  printf "              Delete project files.\n"
75
  printf "          -w, --wipe\n"
76
  printf "              Delete project and .user files.\n"
77
  printf "          -q, --quit\n"
78
  printf "              Quit the script.\n"
79
  printf "          --log=<file>\n"
80
  printf "              Specify a log file.\n"
81
}
82

    
83
### read directory where to create/delete projects #############################
84
# Read the directory where to create/delete project files from user.
85
#
86
# usage:      getProjectDir <pathvar>
87
# arguments:  <pathvar>
88
#                 Variable to store the selected path to.
89
# return:     n/a
90
#
91
function getProjectDir {
92
  printLog "reading path for project files from user...\n"
93
  local amiroosdir=$(realpath $(dirname $(realpath ${BASH_SOURCE[0]}))/../../../)
94
  local input=""
95
  read -p "Path where to create/delete project files: " -i $amiroosdir -e input
96
  printLog "user selected path $(realpath $input)\n"
97
  eval $1="$(realpath $input)"
98
}
99

    
100
### retrieves the ARM-NONE-EABI-GCC include directory ##########################
101
# Retrieves the include directory of the currently set arm-none-eabi-gcc.
102
#
103
# usage:      retrieveGccIncludeDir <path>
104
# arguments:  <path>
105
#                 Variable to store the path to.
106
# return:    0
107
#                 No error or warning occurred.
108
#            -1
109
#                 Error: Command 'arm-none-eabi-gcc' not found.
110
#            -2
111
#                 Error: include directory could not be resolved
112
#
113
function retrieveGccIncludeDir {
114
  # retrieve binary path or link
115
  local binpath=$(which arm-none-eabi-gcc)
116
  local gccincpath=""
117
  if [ -z "$binpath" ]; then
118
    printError "command 'arm-none-eabi-gcc' not found\n"
119
    return -1
120
  else 
121

    
122
    # traverse any links
123
    while [ -L "$binpath" ]; do
124
      binpath=$(realpath $(dirname $binpath)/$(readlink $binpath))
125
    done
126
    printInfo "gcc-arm-none-eabi detected: $binpath\n"
127

    
128
    # return include path
129
    gccincpath=$(realpath $(dirname ${binpath})/../arm-none-eabi/include/)
130
    if [ ! -d "$gccincpath" ]; then
131
      printWarning "$gccincpath does not exist\n"
132
      return -2
133
    else
134
      eval $1="$gccincpath"
135
      return 0
136
    fi
137
  fi
138
}
139

    
140
### detect available modules ###################################################
141
# Detect all avalable modules supported by AMiRo-OS.
142
#
143
# usage:      detectModules <modulearray>
144
# arguments:  <modulearray>
145
#                 Array variable to store all detected modules to.
146
# return:     n/a
147
#
148
function detectModules {
149
  local modulesdir=$(realpath $(dirname $(realpath ${BASH_SOURCE[0]}))/../../../modules)
150
  local modules_detected=()
151

    
152
  # detect all available modules (via directories)
153
  for dir in $(ls -d ${modulesdir}/*/); do
154
    modules_detected[${#modules_detected[@]}]=$(basename $dir)
155
  done
156

    
157
  # set the output variable
158
  eval "$1=(${modules_detected[*]})"
159
}
160

    
161
### create project files for a single module ###################################
162
# Create project files for a single module.
163
#
164
# usage:      createModuleProject <modules> [-m|--module=<module>] [-p|--path=<path>] [--gcc=<path>] [-o|--out=<var>] [--gccout=<var>]
165
# arguments:  <modules>
166
#                 Array containing all modules available.
167
#             -m, --module <module>
168
#                 Name (folder name) of the module for which project files shall be generated.
169
#             -p, --path <path>
170
#                 Path where to create the project files.
171
#             --gcc=<path>
172
#                 Path to the GCC include directory.
173
#             -o, --out <var>
174
#                 Variable to store the path to.
175
#             --gccout=<var>
176
#                 Variable to store the path to the GCC include directory to.
177
#                 If this optional arguments is absent, ths function will ask for user input.
178
# return:     0
179
#                 No error or warning occurred.
180
#             1
181
#                 Aborted by user.
182
#             -1
183
#                 No modules available.
184
#             -2
185
#                 The specified <module> could not be found.
186
#             -3
187
#                 Parsing the project for the specified module failed.
188
#             -4
189
#                 Missing dependencies.
190
#
191
function createModuleProject {
192
  local userdir=$(pwd)
193
  local modulesdir=$(realpath $(dirname $(realpath ${BASH_SOURCE[0]}))/../../../modules)
194
  local modules=("${!1}")
195
  local module=""
196
  local moduleidx=""
197
  local projectdir=""
198
  local gccincludedir=""
199
  local outvar=""
200
  local gccoutvar=""
201

    
202
  # check dependencies
203
  checkCommands make
204
  if [ $? -ne 0 ]; then
205
    printError "Missing dependencies detected.\n"
206
    return -4
207
  fi
208

    
209
  # parse arguments
210
  local otherargs=()
211
  while [ $# -gt 0 ]; do
212
    if ( parseIsOption $1 ); then
213
      case "$1" in
214
        -m=*|--module=*)
215
          module="${1#*=}"; shift 1;;
216
        -m|--module)
217
          module="$2"; shift 2;;
218
        -p=*|--path=*)
219
          projectdir=$(realpath "${1#*=}"); shift 1;;
220
        -p|--path)
221
          projectdir=$(realpath "$2"); shift 2;;
222
        --gcc=*)
223
          gccincludedir=$(realpath "${1#*=}"); shift 1;;
224
        --gcc)
225
          gccincludedir=$(realpath "$2"); shift 2;;
226
        -o=*|--out=*)
227
          outvar=${1#*=}; shift 1;;
228
        -o|--out)
229
          outvar=$2; shift 2;;
230
        --gccout=*)
231
          gccoutvar=$(realpath "${1#*=}"); shift 1;;
232
        --gccout)
233
          gccoutvar=$(realpath "$2"); shift 2;;
234
        *)
235
          printError "invalid option: $1\n"; shift 1;;
236
      esac
237
    else
238
      otherargs+=("$1")
239
      shift 1
240
    fi
241
  done
242

    
243
  # sanity check for the modules variable
244
  if [ -z "${modules[*]}" ]; then
245
    printError "no modules available\n"
246
    return -1
247
  fi
248

    
249
  # select module
250
  if [ -z $module ]; then
251
    # list all available modules
252
    printInfo "choose a module or type 'A' to abort:\n"
253
    for (( idx=0; idx<${#modules[@]}; ++idx )); do
254
      printf "%4u: %s\n" $(($idx + 1)) "${modules[$idx]}"
255
    done
256
    # read user input
257
    printLog "read user selection\n"
258
    local userinput=""
259
    while [[ ! "$userinput" =~ ^[0-9]+$ ]] || [ ! "$userinput" -gt 0 ] || [ ! "$userinput" -le ${#modules[@]} ] && [[ ! "$userinput" =~ ^[Aa]$ ]]; do
260
      read -p "your selection: " -e userinput
261
      printLog "user selection: $userinput\n"
262
      if [[ ! "$userinput" =~ ^[0-9]+$ ]] || [ ! "$userinput" -gt 0 ] || [ ! "$userinput" -le ${#modules[@]} ] && [[ ! "$userinput" =~ ^[Aa]$ ]]; then
263
        printWarning "Please enter an integer between 1 and ${#modules[@]} or 'A' to abort.\n"
264
      fi
265
    done
266
    if [[ "$userinput" =~ ^[Aa]$ ]]; then
267
      printWarning "aborted by user\n"
268
      return 1
269
    fi
270
    # store selection
271
    moduleidx=$(($userinput - 1))
272
    module="${modules[$moduleidx]}"
273
    printf "\n"
274
  else
275
    # search all modules for the selected one
276
    for (( idx=0; idx<${#modules[@]}; ++idx )); do
277
      if [ "${modules[$idx]}" = "$module" ]; then
278
        moduleidx=$idx
279
        break
280
      fi
281
    done
282
    # error if the module could not be found
283
    if [ -z $moduleidx ]; then
284
      printError "module ($module) not available\n"
285
      return -2
286
    fi
287
  fi
288

    
289
  # read absolute project directory if required
290
  if [ -z "$projectdir" ]; then
291
    getProjectDir projectdir
292
    printf "\n"
293
  fi
294

    
295
  # check for existing project files
296
  local projectfiles="$(find ${projectdir} -maxdepth 1 -type f | grep -E "${module}\.(includes|files|config|creator)$")"
297
  IFS=$'\n'; projectfiles=($projectfiles); unset IFS
298
  if [ ! -z "${projectfiles[*]}" ]; then
299
    printWarning "The following files will be overwritten:\n"
300
    for pfile in ${projectfiles[@]}; do
301
      printWarning "\t$(basename $pfile)\n"
302
    done
303
    local userinput=""
304
    printInfo "Continue and overwrite? [y/n]\n"
305
    readUserInput "YyNn" userinput
306
    case "$userinput" in
307
      Y|y)
308
        ;;
309
      N|n)
310
        printWarning "Project generation for ${module} module aborted by user\n"
311
        return 1
312
        ;;
313
      *)
314
        printError "unexpected input: ${userinput}\n"; return -999;;
315
    esac
316
    printf "\n"
317
  fi
318

    
319
  # print message
320
  printInfo "generating QtCreator project files for the $module module...\n"
321

    
322
  # retrieve absolute GCC include path
323
  if [ -z "$gccincludedir" ]; then
324
    retrieveGccIncludeDir gccincludedir
325
  fi
326

    
327
  # change to project directory
328
  local amiroosrootdir=$(realpath $(dirname ${BASH_SOURCE[0]})/../../..)
329
  cd "$projectdir"
330

    
331
  # run make, but only run the GCC preprocessor and produce no binaries
332
  local sourcefiles=()
333
  local sourcefile=""
334
  local parse_state="WAIT_FOR_INCLUDE_OR_COMPILE"
335
  # capture all output from make and GCC and append the return value of make as last line
336
  printInfo "processing project (this may take a while)...\n"
337
  local rawout=$(make --directory ${amiroosrootdir}/modules/${module} --always-make USE_OPT="-v -E -H" USE_VERBOSE_COMPILE="no" OUTFILES="" 2>&1 && echo $?)
338
  # check whether the make call was successfull
339
  if [[ $(echo "${rawout}" | tail -n 1) != "0" ]]; then
340
    printError "executing 'make' in module directory failed\n"
341
    cd "$userdir"
342
    return -3
343
  else
344
    # cleanup
345
    make --directory ${amiroosrootdir}/modules/${module} clean &>/dev/null
346
  fi
347
  # extract file names from raw output
348
  IFS=$'\n'; rawout=($rawout); unset IFS
349
  for line in "${rawout[@]}"; do
350
    case $parse_state in
351
      WAIT_FOR_INCLUDE_OR_COMPILE)
352
        # lines stating included files look like:
353
        # ... <../relative/path/to/file>
354
        if [[ "$line" =~ ^\.+[[:blank:]].+\..+$ ]]; then
355
          sourcefile=${line##* }
356
          if [[ ! "$sourcefile" =~ ^/ ]]; then
357
            sourcefile=$(realpath ${amiroosrootdir}/modules/${module}/${sourcefile})
358
          fi
359
          sourcefiles[${#sourcefiles[@]}]="$sourcefile"
360
        # whenever the next source file is processed, a message appears like:
361
        # Compining <filnemame>
362
        elif [[ "$line" =~ ^Compiling[[:blank:]](.+\..+)$ ]]; then
363
          printf "."
364
          sourcefile=${BASH_REMATCH[1]}
365
          parse_state="WAIT_FOR_COMPILERCALL"
366
        fi;;
367
      WAIT_FOR_COMPILERCALL)
368
        # wait for the actual call of the compiler to retrieve the full path to the source file
369
        if [[ "$line" == *${sourcefile}* ]]; then
370
          line="${line%%${sourcefile}*}${sourcefile}"
371
          sourcefile=$(realpath ${amiroosrootdir}/modules/${module}/${line##* })
372
          sourcefiles[${#sourcefiles[@]}]="$sourcefile"
373
          parse_state="WAIT_FOR_INCLUDE_OR_COMPILE"
374
        fi;;
375
    esac
376
  done
377
  unset rawout
378
  printf "\n"
379
  # sort and remove duplicates
380
  IFS=$'\n'; sourcefiles=($(sort --unique <<< "${sourcefiles[*]}")); unset IFS
381

    
382
  # extract include paths
383
  local includes=()
384
  for source in ${sourcefiles[*]}; do
385
    includes[${#includes[@]}]="$(dirname ${source})"
386
  done
387
  # sort and remove duplicates
388
  IFS=$'\n'; includes=($(sort --unique <<< "${includes[*]}")); unset IFS
389

    
390
  # generate the .files file, containing all source files
391
  echo "" > ${projectdir}/${module}.includes
392
  for inc in ${includes[*]}; do
393
    echo "$inc" >> ${projectdir}/${module}.includes
394
  done
395
  # generate the .incldues file, containing all include paths
396
  echo "" > ${projectdir}/${module}.files
397
  for source in ${sourcefiles[*]}; do
398
    # skip GCC files
399
    if [[ ! "$source" =~ .*/gcc.* ]]; then
400
      echo "$source" >> ${projectdir}/${module}.files
401
    fi
402
  done
403
  # generate a default project configuration file if it doesn't exist yet
404
  if [ ! -f ${projectdir}/${module}.config ]; then
405
    echo "// Add predefined macros for your project here. For example:" > ${projectdir}/${module}.config
406
    echo "// #define YOUR_CONFIGURATION belongs here" >> ${projectdir}/${module}.config
407
  fi
408
  # generate a default .creator file if it doesn't exist yet
409
  if [ ! -f ${projectdir}/${module}.creator ]; then
410
    echo "[general]" > ${projectdir}/${module}.creator
411
  fi
412

    
413
  # go back to user directory
414
  cd $userdir
415

    
416
  # fill the output variables
417
  if [ ! -z "$outvar" ]; then
418
    eval $outvar="$projectdir"
419
  fi
420
  if [ ! -z "$gccoutvar" ]; then
421
    eval $gccoutvar="$gccincludedir"
422
  fi
423

    
424
  return 0
425
}
426

    
427
### create project files for all modules #######################################
428
# Create project files for all modules.
429
#
430
# usage:      createAllProjects <modules> [-p|--path=<path>] [--gcc=<path>] [-o|--out=<var>] [--gccout=<var>]
431
# arguments:  <modules>
432
#                 Array containing all modules available.
433
#             -p, --path <path>
434
#                 Path where to create the project files.
435
#             --gcc=<path>
436
#                 Path to the GCC include directory.
437
#             -o, --out <var>
438
#                 Variable to store the path to.
439
#             --gccout=<var>
440
#                 Variable to store the path to the GCC include directory to.
441
#                 If this optional arguments is absent, ths function will ask for user input.
442
# return:     0
443
#                 No error or warning occurred.
444
#             1
445
#                 Aborted by user.
446
#             -1
447
#                 No modules available.
448
#
449
function createAllProjects {
450
  local modules=("${!1}")
451
  local projectdir=""
452
  local gccincludedir=""
453
  local outvar=""
454
  local gccoutvar=""
455

    
456
  # parse arguments
457
  local otherargs=()
458
  while [ $# -gt 0 ]; do
459
    if ( parseIsOption $1 ); then
460
      case "$1" in
461
        -p=*|--path=*)
462
          projectdir=$(realpath "${1#*=}"); shift 1;;
463
        -p|--path)
464
          projectdir=$(realpath "$2"); shift 2;;
465
        --gcc=*)
466
          gccincludedir=$(realpath "${1#*=}"); shift 1;;
467
        --gcc)
468
          gccincludedir=$(realpath "$2"); shift 2;;
469
        -o=*|--out=*)
470
          outvar=${1#*=}; shift 1;;
471
        -o|--out)
472
          outvar=$2; shift 2;;
473
        --gccout=*)
474
          gccoutvar=$(realpath "${1#*=}"); shift 1;;
475
        --gccout)
476
          gccoutvar=$(realpath "$2"); shift 2;;
477
        *)
478
          printError "invalid option: $1\n"; shift 1;;
479
      esac
480
    else
481
      otherargs+=("$1")
482
      shift 1
483
    fi
484
  done
485

    
486
  # sanity check for the modules variable
487
  if [ -z "${modules[*]}" ]; then
488
    printError "no modules available\n"
489
    return -1
490
  fi
491

    
492
  # read absolute project directory if required
493
  if [ -z "$projectdir" ]; then
494
    getProjectDir projectdir
495
  fi
496

    
497
  # check for existing project files
498
  local projectfiles=()
499
  for module in ${modules[@]}; do
500
    local pfiles="$(find ${projectdir} -maxdepth 1 -type f | grep -E "${module}\.(includes|files|config|creator)$")"
501
    IFS=$'\n'; pfiles=($pfiles); unset IFS
502
    projectfiles=( ${projectfiles[*]} ${pfiles[*]} )
503
  done
504
  if [ ! -z "${projectfiles[*]}" ]; then
505
    printWarning "The following files will be removed:\n"
506
    for pfile in ${projectfiles[@]}; do
507
      printWarning "\t$(basename $pfile)\n"
508
    done
509
    local userinput=""
510
    printInfo "Continue and overwrite? [y/n]\n"
511
    readUserInput "YyNn" userinput
512
    case "${userinput}" in
513
      Y|y)
514
        for pfile in ${projectfiles[*]}; do
515
          rm "$pfile"
516
        done
517
        ;;
518
      N|n)
519
        printWarning "Project generation aborted by user\n"
520
        return 1
521
        ;;
522
      *)
523
        printError "unexpected input: ${userinput}\n"
524
        return 999
525
        ;;
526
    esac
527
  fi
528

    
529
  # print message
530
  printf "\n"
531
  printInfo "generating QtCreator project files for all modules...\n"
532

    
533
  # retrieve absolute GCC include path
534
  if [ -z "$gccincludedir" ]; then
535
    retrieveGccIncludeDir gccincludedir
536
  fi
537

    
538
  # iterate over all modules
539
  local retval=1
540
  for module in ${modules[@]}; do
541
    if [ $retval != 0 ]; then
542
      printf "\n"
543
    fi
544
    createModuleProject modules[@] --module="$module" --path="$projectdir" --gcc="$gccincludedir"
545
    retval=$?
546
  done
547

    
548
  return 0
549
}
550

    
551
### delete project files #######################################################
552
# Deletes all project files and optionally .user files, too.
553
#
554
# usage:      deleteProjects [-p|--path=<path>] [-m|--module=<module>] [-o|--out=<var>] [-w|-wipe]
555
# arguments:  -p, --path <path>
556
#                 Path where to delete the project files.
557
#             -m, --module <module>
558
#                 Module name for which the project files shall be deleted.
559
#             -o, --out <var>
560
#                 Variable to store the path to.
561
#             -w, --wipe
562
#                 Delete .user files as well.
563
# return:
564
#  -  0: no error
565
#
566
function deleteProjects {
567
  local modulename=""
568
  local projectdir=""
569
  local outvar=""
570
  local wipe=false
571
  local files=""
572

    
573
  # parse arguments
574
  local otherargs=()
575
  while [ $# -gt 0 ]; do
576
    if ( parseIsOption $1 ); then
577
      case "$1" in
578
        -p=*|--path=*)
579
          projectdir=$(realpath "${1#*=}"); shift 1;;
580
        -p|--path)
581
          projectdir=$(realpath "$2"); shift 2;;
582
        -m=*|--module=*)
583
          modulename="${1#*=}"; shift 1;;
584
        -m|--module)
585
          modulename="${2}"; shift 2;;
586
        -o=*|--out=*)
587
          outvar=${1#*=}; shift 1;;
588
        -o|--out)
589
          outvar=$2; shift 2;;
590
        -w|--wipe)
591
          wipe=true; shift 1;;
592
        *)
593
          printError "invalid option: $1\n"; shift 1;;
594
      esac
595
    else
596
      otherargs+=("$1")
597
      shift 1
598
    fi
599
  done
600

    
601
  # read absolute project directory if required
602
  if [ -z "$projectdir" ]; then
603
    getProjectDir projectdir
604
  fi
605

    
606
  # list all files to be deleted
607
  if [ -z "$modulename" ]; then
608
    if [ $wipe != true ]; then
609
      files=$(find "${projectdir}" -maxdepth 1 -type f | grep -E "^.+\.(includes|files|config|creator|cflags|cxxflags)$")
610
    else
611
      files=$(find "${projectdir}" -maxdepth 1 -type f | grep -E "^.+\.(includes|files|config|creator|cflags|cxxflags|creator(\.user(\..+)?)?)$")
612
    fi
613
  else
614
    if [ $wipe != true ]; then
615
      files=$(find "${projectdir}" -maxdepth 1 -type f | grep -E "^${modulename}\.(includes|files|config|creator|cflags|cxxflags)$")
616
    else
617
      files=$(find "${projectdir}" -maxdepth 1 -type f | grep -E "^${modulename}\.(includes|files|config|creator|cflags|cxxflags|creator(\.user(\..+)?)?)$")
618
    fi
619
  fi
620
  if [ ! -z "$files" ]; then
621
    printInfo "Deleting the following files:\n"
622
    while read line; do
623
      printInfo "\t$(basename ${line})\n"
624
      rm ${line} 2>&1 | tee -a $LOG_FILE
625
    done <<< "${files}"
626
  else
627
    printInfo "No project files found\n"
628
  fi
629

    
630
  # store the path to the output variable, if required
631
  if [ ! -z "$outvar" ]; then
632
    eval $outvar="$projectdir"
633
  fi
634

    
635
  return 0
636
}
637

    
638
### main function of this script ###############################################
639
# Creates, deletes and wipes QtCreator project files for the three AMiRo base modules.
640
#
641
# usage:      see function printHelp
642
# arguments:  see function printHelp
643
# return:     0
644
#                 No error or warning ocurred.
645
#
646
function main {
647
# print welcome/info text if not suppressed
648
  if [[ $@ != *"--noinfo"* ]]; then
649
    printWelcomeText
650
  else
651
    printf "######################################################################\n"
652
  fi
653
  printf "\n"
654

    
655
  # if --help or -h was specified, print the help text and exit
656
  if [[ $@ == *"--help"* || $@ == *"-h"* ]]; then
657
    printHelp
658
    printf "\n"
659
    quitScript
660
  fi
661

    
662
  # set log file if specified
663
  if [[ $@ == *"--log"* ]] || [[ $@ == *"--LOG"* ]]; then
664
    # get the parameter (file name)
665
    local cmdidx=1
666
    while [[ ! "${!cmdidx}" = "--log"* ]] && [[ ! "${!cmdidx}" = "--LOG"* ]]; do
667
      cmdidx=$[cmdidx + 1]
668
    done
669
    local cmd="${!cmdidx}"
670
    local logfile=""
671
    if [[ "$cmd" = "--log="* ]] || [[ "$cmd" = "--LOG="* ]]; then
672
      logfile=${cmd#*=}
673
    else
674
      local filenameidx=$((cmdidx + 1))
675
      logfile="${!filenameidx}"
676
    fi
677
    # optionally force silent appending
678
    if [[ "$cmd" = "--LOG"* ]]; then
679
      setLogFile --option=c --quiet "$logfile" LOG_FILE
680
    else
681
      setLogFile "$logfile" LOG_FILE
682
      printf "\n"
683
    fi
684
  fi
685
  # log script name
686
  printLog "this is $(realpath ${BASH_SOURCE[0]})\n"
687

    
688
  # detect available modules and inform user
689
  local modules=()
690
  detectModules modules
691
  case "${#modules[@]}" in
692
    0)
693
      printInfo "no module has been detected\n";;
694
    1)
695
      printInfo "1 module has been detected:\n";;
696
    *)
697
      printInfo "${#modules[@]} modules have been detected:\n"
698
  esac
699
  for (( idx=0; idx<${#modules[@]}; ++idx )); do
700
    printInfo "  - ${modules[$idx]}\n"
701
  done
702
  printf "\n"
703

    
704
  # parse arguments
705
  local otherargs=()
706
  while [ $# -gt 0 ]; do
707
    if ( parseIsOption $1 ); then
708
      case "$1" in
709
        -h|--help) # already handled; ignore
710
          shift 1;;
711
        -m=*|--module=*)
712
          createModuleProject modules[@] --module="${1#*=}"; printf "\n"; shift 1;;
713
        -m|--module)
714
          createModuleProject modules[@] --module="${2}"; printf "\n"; shift 2;;
715
        -a|--all)
716
          createAllProjects modules[@]; shift 1;;
717
        -c|--clean)
718
          deleteProjects; printf "\n"; shift 1;;
719
        -w|--wipe)
720
          deleteProjects --wipe; printf "\n"; shift 1;;
721
        -q|--quit)
722
          quitScript; shift 1;;
723
        --log=*|--LOG=*) # already handled; ignore
724
          shift 1;;
725
        --log|--LOG) # already handled; ignore
726
          shift 2;;
727
        --noinfo) # already handled; ignore
728
          shift 1;;
729
        *)
730
          printError "invalid option: $1\n"; shift 1;;
731
      esac
732
    else
733
      otherargs+=("$1")
734
      shift 1
735
    fi
736
  done
737

    
738
  # interactive menu
739
  while ( true ); do
740
    # main menu info prompt and selection
741
    printInfo "QtCreator setup main menu\n"
742
    printf "Please select one of the following actions:\n"
743
    printf "  [M] - create a project for a single module\n"
744
    printf "  [A] - create a project for all modules\n"
745
    printf "  [C] - clean all project files\n"
746
    printf "  [W] - wipe all project and .user files\n"
747
    printf "  [Q] - quit this setup\n"
748
    local userinput=""
749
    readUserInput "MmAaCcWwQq" userinput
750
    printf "\n"
751

    
752
    # evaluate user selection
753
    case "$userinput" in
754
      M|m)
755
        createModuleProject modules[@]; printf "\n";;
756
      A|a)
757
        createAllProjects modules[@]; printf "\n";;
758
      C|c)
759
        deleteProjects; printf "\n";;
760
      W|w)
761
        deleteProjects --wipe; printf "\n";;
762
      Q|q)
763
        quitScript;;
764
      *) # sanity check (exit with error)
765
        printError "unexpected argument: $userinput\n";;
766
    esac
767
  done
768

    
769
  exit 0
770
}
771

    
772
################################################################################
773
# SCRIPT ENTRY POINT                                                           #
774
################################################################################
775

    
776
main "$@"
777