Statistics
| Branch: | Tag: | Revision:

amiro-os / core / src / aos_shell.c @ 3da12676

History | View | Annotate | Download (73.6 KB)

1
/*
2
AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.
3
Copyright (C) 2016..2020  Thomas Schöpping et al.
4

5
This program is free software: you can redistribute it and/or modify
6
it under the terms of the GNU General Public License as published by
7
the Free Software Foundation, either version 3 of the License, or
8
(at your option) any later version.
9

10
This program is distributed in the hope that it will be useful,
11
but WITHOUT ANY WARRANTY; without even the implied warranty of
12
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
GNU General Public License for more details.
14

15
You should have received a copy of the GNU General Public License
16
along with this program.  If not, see <http://www.gnu.org/licenses/>.
17
*/
18

    
19
/**
20
 * @file    aos_shell.c
21
 * @brief   Shell code.
22
 * @details Shell code as well as shell related channels and streams.
23
 *
24
 * @addtogroup aos_shell
25
 * @{
26
 */
27

    
28
#include <amiroos.h>
29
#include <string.h>
30

    
31
#if (AMIROOS_CFG_SHELL_ENABLE == true) || defined(__DOXYGEN__)
32

    
33
/******************************************************************************/
34
/* LOCAL DEFINITIONS                                                          */
35
/******************************************************************************/
36

    
37
/**
38
 * @brief   Size of the escape sequence buffer.
39
 */
40
#if !defined(AOS_SHELL_ESCSEQUENCE_LENGTH) || defined(__DOXYGEN__)
41
#define AOS_SHELL_ESCSEQUENCE_LENGTH            8
42
#endif
43

    
44
/**
45
 * @brief   The character the input buffer is initialized with.
46
 */
47
#define INBUF_INIT_CHAR                         '\x07'
48

    
49
/**
50
 * @brief   Event mask to be set on OS related events.
51
 */
52
#define EVENTMASK_OS                            EVENT_MASK(0)
53

    
54
/**
55
 * @brief   Event mask to be set on a input event.
56
 */
57
#define EVENTMASK_INPUT                         EVENT_MASK(1)
58

    
59
/**
60
 * @brief   String that defines the INSERT key as specified by VT100.
61
 */
62
#define KEYSTRING_INSERT                        "\x1B\x5B\x32\x7E"
63

    
64
/**
65
 * @brief   String that defines the DEL key as specified by VT100.
66
 */
67
#define KEYSTRING_DELETE                        "\x1B\x5B\x33\x7E"
68

    
69
/**
70
 * @brief   String that defines the HOME key as specified by VT100.
71
 */
72
#define KEYSTRING_HOME                          "\x1B\x5B\x48"
73

    
74
/**
75
 * @brief   String that defines the END key as specified by VT100.
76
 */
77
#define KEYSTRING_END                           "\x1B\x5B\x46"
78

    
79
/**
80
 * @brief   String that defines the PGUP key as specified by VT100.
81
 */
82
#define KEYSTRING_PAGEUP                        "\x1B\x5B\x35\x7E"
83

    
84
/**
85
 * @brief   String that defines the PGUP key as specified by VT100.
86
 */
87
#define KEYSTRING_PAGEDOWN                      "\x1B\x5B\x36\x7E"
88

    
89
/**
90
 * @brief   String that defines the 'arrow down' key as specified by VT100.
91
 */
92
#define KEYSTRING_ARROWUP                       "\x1B\x5B\x41"
93

    
94
/**
95
 * @brief   String that defines the 'arrow up' key as specified by VT100.
96
 */
97
#define KEYSTRING_ARROWDOWN                     "\x1B\x5B\x42"
98

    
99
/**
100
 * @brief   String that defines the 'arrow left' key as specified by VT100.
101
 */
102
#define KEYSTRING_ARROWLEFT                     "\x1B\x5B\x44"
103

    
104
/**
105
 * @brief   String that defines the 'arrow right' key as specified by VT100.
106
 */
107
#define KEYSTRING_ARROWRIGHT                    "\x1B\x5B\x43"
108

    
109
/**
110
 * @brief   String that defines the CRTL + 'arrow up' key combination as specified by VT100.
111
 */
112
#define KEYSTRING_CTRL_ARROWUP                  "\x1B\x5B\x31\x3B\x35\x41"
113

    
114
/**
115
 * @brief   String that defines the CRTL + 'arrow down' key combination as specified by VT100.
116
 */
117
#define KEYSTRING_CTRL_ARROWDOWN                "\x1B\x5B\x31\x3B\x35\x42"
118

    
119
/**
120
 * @brief   String that defines the CRTL + 'arrow left' key combination as specified by VT100.
121
 */
122
#define KEYSTRING_CTRL_ARROWLEFT                "\x1B\x5B\x31\x3B\x35\x44"
123

    
124
/**
125
 * @brief   String that defines the CRTL + 'arrow right' key combination as specified by VT100.
126
 */
127
#define KEYSTRING_CTRL_ARROWRIGHT               "\x1B\x5B\x31\x3B\x35\x43"
128

    
129
/******************************************************************************/
130
/* EXPORTED VARIABLES                                                         */
131
/******************************************************************************/
132

    
133
/******************************************************************************/
134
/* LOCAL TYPES                                                                */
135
/******************************************************************************/
136

    
137
/*
138
 * forward declarations
139
 */
140
static size_t _channelwrite(void *instance, const uint8_t *bp, size_t n);
141
static size_t _channelread(void *instance, uint8_t *bp, size_t n);
142
static msg_t _channelput(void *instance, uint8_t b);
143
static msg_t _channelget(void *instance);
144
static msg_t _channelputt(void *instance, uint8_t b, sysinterval_t time);
145
static msg_t _channelgett(void *instance, sysinterval_t time);
146
static size_t _channelwritet(void *instance, const uint8_t *bp, size_t n, sysinterval_t time);
147
static size_t _channelreadt(void *instance, uint8_t *bp, size_t n, sysinterval_t time);
148
static msg_t _channelctl(void *instance, unsigned int operation, void *arg);
149
static size_t _streamwrite(void *instance, const uint8_t *bp, size_t n);
150
static size_t _stremread(void *instance, uint8_t *bp, size_t n);
151
static msg_t _streamput(void *instance, uint8_t b);
152
static msg_t _streamget(void *instance);
153

    
154
static const struct AosShellChannelVMT _channelvmt = {
155
  (size_t) 0,
156
  _channelwrite,
157
  _channelread,
158
  _channelput,
159
  _channelget,
160
  _channelputt,
161
  _channelgett,
162
  _channelwritet,
163
  _channelreadt,
164
  _channelctl,
165
};
166

    
167
static const struct AosShellStreamVMT _streamvmt = {
168
  (size_t) 0,
169
  _streamwrite,
170
  _stremread,
171
  _streamput,
172
  _streamget,
173
};
174

    
175
/**
176
 * @brief   Enumerator of special keyboard keys.
177
 */
178
typedef enum special_key {
179
  KEY_UNKNOWN,          /**< any/unknow key */
180
  KEY_AMBIGUOUS,        /**< key is ambiguous */
181
  KEY_TAB,              /**< tabulator key */
182
  KEY_BACKSPACE,        /**< backspace key */
183
  KEY_INSERT,           /**< insert key */
184
  KEY_DELETE,           /**< delete key */
185
  KEY_ESCAPE,           /**< escape key */
186
  KEY_HOME,             /**< home key */
187
  KEY_END,              /**< end key */
188
  KEY_PAGEUP,           /**< page up key */
189
  KEY_PAGEDOWN,         /**< page down key */
190
  KEY_ARROWUP,          /**< arrow up key */
191
  KEY_ARROWDOWN,        /**< arrow down key */
192
  KEY_ARROWLEFT,        /**< arrow left key */
193
  KEY_ARROWRIGHT,       /**< arrow right key */
194
  KEY_CTRL_ARROWUP,     /**< CTRL + arrow up key */
195
  KEY_CTRL_ARROWDOWN,   /**< CTRL + arrow down key */
196
  KEY_CTRL_ARROWLEFT,   /**< CTRL + arrow left key */
197
  KEY_CTRL_ARROWRIGHT,  /**< CTRL + arrow right key */
198
  KEY_CTRL_C,           /**< CTRL + C key */
199
} special_key_t;
200

    
201
/**
202
 * @brief   Enumerator for case (in)sensitive character matching.
203
 */
204
typedef enum charmatch {
205
  CHAR_MATCH_NOT    = 0,  /**< Characters do not match at all. */
206
  CHAR_MATCH_NCASE  = 1,  /**< Characters would match case insensitive. */
207
  CHAR_MATCH_CASE   = 2,  /**< Characters do match with case. */
208
} charmatch_t;
209

    
210
/**
211
 * @brief   Enumerator to encode shell actions.
212
 */
213
typedef enum aos_shellaction {
214
  ACTION_NONE,                  /**< No action at all. */
215
  ACTION_READCHAR,              /**< Read a printable character. */
216
  ACTION_AUTOCOMPLETE,          /**< Automatically comlete input by using available command. */
217
  ACTION_SUGGEST,               /**< Suggest matching available commands. */
218
  ACTION_EXECUTE,               /**< Execute input. */
219
  ACTION_DELETEBACKWARD,        /**< Delete a single character backwards. */
220
  ACTION_DELETEFORWARD,         /**< Delete a single character forwards. */
221
  ACTION_CLEAR,                 /**< Clear the input. */
222
  ACTION_RECALLPREVIOUS,        /**< Recall the previous (older) entry in the history. */
223
  ACTION_RECALLNEXT,            /**< Recall the next (more recent) entry in the history. */
224
  ACTION_RECALLOLDEST,          /**< Recall the oldest entry in the history. */
225
  ACTION_RECALLCURRENT,         /**< Recall the current input. */
226
  ACTION_CURSORLEFT,            /**< Move cursor one character to the left. */
227
  ACTION_CURSORRIGHT,           /**< Move cursor one character to the right. */
228
  ACTION_CURSORWORDLEFT,        /**< Move cursor one word to the left. */
229
  ACTION_CURSORWORDRIGHT,       /**< Move cursor one word to the right. */
230
  ACTION_CURSOR2END,            /**< Move cursor to the very right. */
231
  ACTION_CURSOR2START,          /**< Move cursor to the very left. */
232
  ACTION_RESET,                 /**< Reset the current input. */
233
  ACTION_INSERTTOGGLE,          /**< Toggle insertion mode. */
234
  ACTION_ESCSTART,              /**< Start an escape sequence (special keys). */
235
  ACTION_PRINTUNKNOWNSEQUENCE,  /**< Print an unknown escape sequence. */
236
} action_t;
237

    
238
/**
239
 * @brief   Struct that holds most important runtime data for the shell.
240
 * @details The structure is to be used by the shell thread main function as some kind of structured stack, which can be easily passed to other functions.
241
 */
242
typedef struct runtimedata {
243
  /**
244
   * @brief   Data related to the current input.
245
   */
246
  struct {
247
    /**
248
     * @brief   Length of the input.
249
     */
250
    size_t length;
251

    
252
    /**
253
     * @brief   Current position of the cursor in the input line.
254
     */
255
    size_t cursorpos;
256

    
257
    /**
258
     * @brief   Buffer to store escape sequences, which describe special characters.
259
     */
260
    char escseq[AOS_SHELL_ESCSEQUENCE_LENGTH];
261
  } input;
262

    
263
  /**
264
   * @brief   Data related to the entry or history buffer.
265
   */
266
  struct {
267
    /**
268
     * @brief   Current entry to be filled and executed.
269
     */
270
    size_t current;
271

    
272
    /**
273
     * @brief   Selected entry in the 'history' as preview.
274
     * @details A value of 0 indicates, that the line is cleared as a preview.
275
     *          A value of 1 indicates, that the current entry is selected.
276
     *          A value of t>1 indicates, that the entry t-1 in the past is selected.
277
     *          The value must never be greater than the number of entries available, of course.
278
     */
279
    size_t selected;
280

    
281
    /**
282
     * @brief   Selected entry in the 'history' that has been edited by the user.
283
     *          A value of 0 indicates, that there was no modification by the user yet (i.e. charcters, deletions or autofill).
284
     *          A value of 1 indicates, that the current entry was edited.
285
     *          A value of t>1 indicated, that a history entry was recalled and then edited.
286
     */
287
    size_t edited;
288
  } buffer;
289

    
290
  /**
291
   * @brief   The last action executed by the shell.
292
   */
293
  action_t lastaction;
294
} runtimedata_t;
295

    
296
/******************************************************************************/
297
/* LOCAL VARIABLES                                                            */
298
/******************************************************************************/
299

    
300
/******************************************************************************/
301
/* LOCAL FUNCTIONS                                                            */
302
/******************************************************************************/
303

    
304
/**
305
 * @brief   Implementation of the BaseAsynchronous write() method (inherited from BaseSequentialStream).
306
 */
307
static size_t _channelwrite(void *instance, const uint8_t *bp, size_t n)
308
{
309
  if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_OUTPUT_ENABLED) {
310
    return streamWrite(((AosShellChannel*)instance)->asyncchannel, bp, n);
311
  } else {
312
    return 0;
313
  }
314
}
315

    
316
/**
317
 * @brief   Implementation of the BaseAsynchronous read() method (inherited from BaseSequentialStream).
318
 */
319
static size_t _channelread(void *instance, uint8_t *bp, size_t n)
320
{
321
  if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_INPUT_ENABLED) {
322
    return streamRead(((AosShellChannel*)instance)->asyncchannel, bp, n);
323
  } else {
324
    return 0;
325
  }
326
}
327

    
328
/**
329
 * @brief   Implementation of the BaseAsynchronous put() method (inherited from BaseSequentialStream).
330
 */
331
static msg_t _channelput(void *instance, uint8_t b)
332
{
333
  if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_OUTPUT_ENABLED) {
334
    return streamPut(((AosShellChannel*)instance)->asyncchannel, b);
335
  } else {
336
    return MSG_RESET;
337
  }
338
}
339

    
340
/**
341
 * @brief   Implementation of the BaseAsynchronous get() method (inherited from BaseSequentialStream).
342
 */
343
static msg_t _channelget(void *instance)
344
{
345
  if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_INPUT_ENABLED) {
346
    return streamGet(((AosShellChannel*)instance)->asyncchannel);
347
  } else {
348
    return MSG_RESET;
349
  }
350
}
351

    
352
/**
353
 * @brief   Implementation of the BaseAsynchronous putt() method.
354
 */
355
static msg_t _channelputt(void *instance, uint8_t b, sysinterval_t time)
356
{
357
  if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_OUTPUT_ENABLED) {
358
    return chnPutTimeout(((AosShellChannel*)instance)->asyncchannel, b, time);
359
  } else {
360
    return MSG_RESET;
361
  }
362
}
363

    
364
/**
365
 * @brief   Implementation of the BaseAsynchronous gett() method.
366
 */
367
static msg_t _channelgett(void *instance, sysinterval_t time)
368
{
369
  if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_INPUT_ENABLED) {
370
    return chnGetTimeout(((AosShellChannel*)instance)->asyncchannel, time);
371
  } else {
372
    return MSG_RESET;
373
  }
374
}
375

    
376
/**
377
 * @brief   Implementation of the BaseAsynchronous writet() method.
378
 */
379
static size_t _channelwritet(void *instance, const uint8_t *bp, size_t n, sysinterval_t time)
380
{
381
  if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_OUTPUT_ENABLED) {
382
    return chnWriteTimeout(((AosShellChannel*)instance)->asyncchannel, bp, n, time);
383
  } else {
384
    return 0;
385
  }
386
}
387

    
388
/**
389
 * @brief   Implementation of the BaseAsynchronous readt() method.
390
 */
391
static size_t _channelreadt(void *instance, uint8_t *bp, size_t n, sysinterval_t time)
392
{
393
  if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_INPUT_ENABLED) {
394
    return chnReadTimeout(((AosShellChannel*)instance)->asyncchannel, bp, n, time);
395
  } else {
396
    return 0;
397
  }
398
}
399

    
400
/**
401
 * @brief   Implementation of the BaseAsynchronousChannel ctl() method.
402
 */
403
static msg_t _channelctl(void *instance, unsigned int operation, void *arg)
404
{
405
  (void) instance;
406

    
407
  switch (operation) {
408
  case CHN_CTL_NOP:
409
    osalDbgCheck(arg == NULL);
410
    break;
411
  case CHN_CTL_INVALID:
412
    osalDbgAssert(false, "invalid CTL operation");
413
    break;
414
  default:
415
    break;
416
  }
417
  return MSG_OK;
418
}
419

    
420
/**
421
 * @brief   Implementation of the BaseSequentialStream write() method.
422
 */
423
static size_t _streamwrite(void *instance, const uint8_t *bp, size_t n)
424
{
425
  aosDbgCheck(instance != NULL);
426

    
427
  // local variables
428
  AosShellChannel* channel = ((AosShellStream*)instance)->channel;
429
  size_t bytes;
430
  size_t maxbytes = 0;
431

    
432
  // iterate through the list of channels
433
  while (channel != NULL) {
434
    bytes = streamWrite(channel, bp, n);
435
    maxbytes = (bytes > maxbytes) ? bytes : maxbytes;
436
    channel = channel->next;
437
  }
438

    
439
  return maxbytes;
440
}
441

    
442
/**
443
 * @brief   Implementation of the BaseSequentialStream read() method.
444
 */
445
static size_t _stremread(void *instance, uint8_t *bp, size_t n)
446
{
447
  (void)instance;
448
  (void)bp;
449
  (void)n;
450

    
451
  return 0;
452
}
453

    
454
/**
455
 * @brief   Implementation of the BaseSequentialStream put() method.
456
 */
457
static msg_t _streamput(void *instance, uint8_t b)
458
{
459
  aosDbgCheck(instance != NULL);
460

    
461
  // local variables
462
  AosShellChannel* channel = ((AosShellStream*)instance)->channel;
463
  msg_t ret = MSG_OK;
464

    
465
  // iterate through the list of channels
466
  while (channel != NULL) {
467
    msg_t ret_ = streamPut(channel, b);
468
    ret = (ret_ < ret) ? ret_ : ret;
469
    channel = channel->next;
470
  }
471

    
472
  return ret;
473
}
474

    
475
/**
476
 * @brief   Implementation of the BaseSequentialStream get() method.
477
 */
478
static msg_t _streamget(void *instance)
479
{
480
  (void)instance;
481

    
482
  return 0;
483
}
484

    
485
/**
486
 * @brief   Retreive a pointer to the string buffer of a specified entry in the input buffer.
487
 *
488
 * @param[in] shell   Pointer to a shell object.
489
 * @param[in] entry   Entry to be retrieved.
490
 *
491
 * @return  Pointer to the entry in the input buffer.
492
 */
493
static inline char* _getAbsoluteEntry(const aos_shell_t* shell, size_t entry)
494
{
495
  aosDbgCheck(shell != NULL);
496
  aosDbgCheck(entry < shell->input.nentries);
497

    
498
  return &(shell->input.buffer[entry * shell->input.linewidth * sizeof(char)]);
499
}
500

    
501
/**
502
 * @brief   Calculate absolute entry from history offset.
503
 *
504
 * @param[in] shell   Pointer to a shell object.
505
 * @param[in] rdata   Pointer to a runtime data object.
506
 * @param[in] offset  Relative offset of the entry to be retreived.
507
 *
508
 * @return  Absolute index of the historic entry.
509
 */
510
static inline size_t _historyOffset2EntryIndex(const aos_shell_t* shell, const runtimedata_t* rdata, size_t offset)
511
{
512
  aosDbgCheck(shell != NULL);
513
  aosDbgCheck(rdata != NULL);
514
  aosDbgCheck(offset < shell->input.nentries);
515

    
516
  return ((shell->input.nentries + rdata->buffer.current - offset) % shell->input.nentries);
517
}
518

    
519
/**
520
 * @brief   Retreive a pointer to the string buffer of a historic entry in the input buffer.
521
 *
522
 * @param[in] shell   Pointer to a shell object.
523
 * @param[in] rdata   Pointer to a runtime data object.
524
 * @param[in] offset  Relative offset of the entry to be retreived.
525
 *
526
 * @return  Pointer to the entry in the input buffer.
527
 */
528
static inline char* _getRelativeEntry(const aos_shell_t* shell, const runtimedata_t* rdata, size_t offset)
529
{
530
  aosDbgCheck(shell != NULL);
531
  aosDbgCheck(rdata != NULL);
532
  aosDbgCheck(offset < shell->input.nentries);
533

    
534
  return _getAbsoluteEntry(shell, _historyOffset2EntryIndex(shell, rdata, offset));
535
}
536

    
537
/**
538
 * @brief   Retreive a pointer to the current entry string in the input buffer.
539
 *
540
 * @param[in] shell   Pointer to a shell object.
541
 * @param[in] rdata   Pointer to a runtime data object.
542
 *
543
 * @return  Pointer to the string of the current entry in the input buffer.
544
 */
545
static inline char* _getCurrentEntry(const aos_shell_t* shell, const runtimedata_t* rdata)
546
{
547
  aosDbgCheck(shell != NULL);
548
  aosDbgCheck(rdata != NULL);
549

    
550
  return _getAbsoluteEntry(shell, rdata->buffer.current);
551
}
552

    
553
/**
554
 * @brief   Retreive a pointer to the currently selected entry.
555
 *
556
 * @param[in] shell   Pointer to a shell object.
557
 * @param[in] rdata   Pointer to a runtime data object.
558
 *
559
 * @return  Pointer to the currently selected entry or NULL if no entry is selected (cleared preview).
560
 */
561
static inline char* _getSelectedEntry(const aos_shell_t* shell, const runtimedata_t* rdata)
562
{
563
  aosDbgCheck(shell != NULL);
564
  aosDbgCheck(rdata != NULL);
565

    
566
  if (rdata->buffer.selected > 0) {
567
    return _getRelativeEntry(shell, rdata, rdata->buffer.selected - 1);
568
  } else {
569
    return NULL;
570
  }
571
}
572

    
573
/**
574
 * @brief   Retreive the currently visualized entry.
575
 *
576
 * @param[in] shell   Pointer to a shell object.
577
 * @param[in] rdata   Pointer to a runtime data object.
578
 *
579
 * @return  Pointer to the currently visualized entry or NULL if the input has been cleared (cleared preview).
580
 */
581
static inline char* _getVisualisedEntry(const aos_shell_t* shell, const runtimedata_t* rdata)
582
{
583
  aosDbgCheck(shell != NULL);
584
  aosDbgCheck(rdata != NULL);
585

    
586
  if (rdata->buffer.selected == 0) {
587
    // cleared preview, nothing visualized
588
    return NULL;
589
  } else {
590
    if (rdata->buffer.selected == 1 || rdata->buffer.selected == rdata->buffer.edited) {
591
      // the current or a modified entry is selected
592
      return _getCurrentEntry(shell, rdata);
593
    } else {
594
      // a historic, unmodified entry is selected
595
      return _getRelativeEntry(shell, rdata, rdata->buffer.selected - 1);
596
    }
597
  }
598
}
599

    
600
/**
601
 * @brief   Print the shell prompt
602
 * @details Depending on the configuration flags, the system uptime is printed before the prompt string.
603
 *
604
 * @param[in] shell   Pointer to the shell object.
605
 */
606
static void _printPrompt(aos_shell_t* shell)
607
{
608
  aosDbgCheck(shell != NULL);
609

    
610
  // print some time informattion before prompt if configured
611
  if (shell->config & (AOS_SHELL_CONFIG_PROMPT_UPTIME | AOS_SHELL_CONFIG_PROMPT_DATETIME)) {
612
    // printf the system uptime
613
    if ((shell->config & (AOS_SHELL_CONFIG_PROMPT_UPTIME | AOS_SHELL_CONFIG_PROMPT_DATETIME)) == AOS_SHELL_CONFIG_PROMPT_UPTIME) {
614
      // get current system uptime
615
      aos_timestamp_t uptime;
616
      aosSysGetUptime(&uptime);
617

    
618
      chprintf((BaseSequentialStream*)&shell->stream, "[%01u:%02u:%02u:%02u:%03u:%03u] ",
619
               (uint32_t)(uptime / MICROSECONDS_PER_DAY),
620
               (uint8_t)(uptime % MICROSECONDS_PER_DAY / MICROSECONDS_PER_HOUR),
621
               (uint8_t)(uptime % MICROSECONDS_PER_HOUR / MICROSECONDS_PER_MINUTE),
622
               (uint8_t)(uptime % MICROSECONDS_PER_MINUTE / MICROSECONDS_PER_SECOND),
623
               (uint16_t)(uptime % MICROSECONDS_PER_SECOND / MICROSECONDS_PER_MILLISECOND),
624
               (uint16_t)(uptime % MICROSECONDS_PER_MILLISECOND / MICROSECONDS_PER_MICROSECOND));
625
    }
626
#if (HAL_USE_RTC == TRUE)
627
    else if ((shell->config & (AOS_SHELL_CONFIG_PROMPT_UPTIME | AOS_SHELL_CONFIG_PROMPT_DATETIME)) == AOS_SHELL_CONFIG_PROMPT_DATETIME) {
628
      // get current RTC time
629
      struct tm dt;
630
      aosSysGetDateTime(&dt);
631
      chprintf((BaseSequentialStream*)&shell->stream, "[%02u-%02u-%04u|%02u:%02u:%02u] ",
632
               dt.tm_mday,
633
               dt.tm_mon + 1,
634
               dt.tm_year + 1900,
635
               dt.tm_hour,
636
               dt.tm_min,
637
               dt.tm_sec);
638
    }
639
#endif /* (HAL_USE_RTC == TRUE) */
640
    else {
641
      aosDbgAssert(false);
642
    }
643
  }
644

    
645
  // print the actual prompt string
646
  if (shell->prompt && !(shell->config & AOS_SHELL_CONFIG_PROMPT_MINIMAL)) {
647
    chprintf((BaseSequentialStream*)&shell->stream, "%s$ ", shell->prompt);
648
  } else {
649
    chprintf((BaseSequentialStream*)&shell->stream, "%>$ ");
650
  }
651

    
652
  return;
653
}
654

    
655
/**
656
 * @brief   Interprete a escape sequence
657
 * @details This function interpretes escape sequences (starting with ASCII
658
 *          "Escape" character 0x1B) according to the VT100 / VT52 ANSI escape
659
 *          sequence definitions.
660
 * @note    Only the most important escape sequences are implemented yet.
661
 *
662
 * @param[in] seq   Character sequence to interprete.
663
 *                  Must be terminated by NUL byte.
664
 *
665
 * @return          A @p special_key value.
666
 */
667
static special_key_t _interpreteEscapeSequence(const char seq[])
668
{
669
  // local variables
670
  unsigned long strl = 0;
671
  const unsigned long seql = strlen(seq);
672
  bool ambiguous = false;
673

    
674
  // TAB
675
  /* not supported yet; use '\x09' instead */
676

    
677
  // BACKSPACE
678
  /* not supported yet; use '\x08' instead */
679

    
680
  // ESCAPE
681
  /* not supported yes; use '\x1B' instead */
682

    
683
  // CTRL + C
684
  /* not defined yet; use '\x03' instead */
685

    
686
  // INSERT
687
  if (strncmp(seq, KEYSTRING_INSERT, seql) == 0) {
688
    strl = strlen(KEYSTRING_INSERT);
689
    if (seql == strl) {
690
      return KEY_INSERT;
691
    } else if (seql < strl) {
692
      ambiguous = true;
693
    }
694
  }
695

    
696
  // DELETE
697
  if (strncmp(seq, KEYSTRING_DELETE, seql) == 0) {
698
    strl = strlen(KEYSTRING_DELETE);
699
    if (seql == strl) {
700
      return KEY_DELETE;
701
    } else if (seql < strl) {
702
      ambiguous = true;
703
    }
704
  }
705

    
706
  // HOME
707
  if (strncmp(seq, KEYSTRING_HOME, seql) == 0) {
708
    strl = strlen(KEYSTRING_HOME);
709
    if (seql == strl) {
710
      return KEY_HOME;
711
    } else if (seql < strl) {
712
      ambiguous = true;
713
    }
714
  }
715

    
716
  // END
717
  if (strncmp(seq, KEYSTRING_END, seql) == 0) {
718
    strl = strlen(KEYSTRING_END);
719
    if (seql == strl) {
720
      return KEY_END;
721
    } else if (seql < strl) {
722
      ambiguous = true;
723
    }
724
  }
725

    
726
  // PAGE UP
727
  if (strncmp(seq, KEYSTRING_PAGEUP, seql) == 0) {
728
    strl = strlen(KEYSTRING_PAGEUP);
729
    if (seql == strl) {
730
      return KEY_PAGEUP;
731
    } else if (seql < strl) {
732
      ambiguous = true;
733
    }
734
  }
735

    
736
  // PAGE DOWN
737
  if (strncmp(seq, KEYSTRING_PAGEDOWN, seql) == 0) {
738
    strl = strlen(KEYSTRING_PAGEDOWN);
739
    if (seql == strl) {
740
      return KEY_PAGEDOWN;
741
    } else if (seql < strl) {
742
      ambiguous = true;
743
    }
744
  }
745

    
746
  // ARROW UP
747
  if (strncmp(seq, KEYSTRING_ARROWUP, seql) == 0) {
748
    strl = strlen(KEYSTRING_ARROWUP);
749
    if (seql == strl) {
750
      return KEY_ARROWUP;
751
    } else if (seql < strl) {
752
      ambiguous = true;
753
    }
754
  }
755

    
756
  // ARROW DOWN
757
  if (strncmp(seq, KEYSTRING_ARROWDOWN, seql) == 0) {
758
    strl = strlen(KEYSTRING_ARROWDOWN);
759
    if (seql == strl) {
760
      return KEY_ARROWDOWN;
761
    } else if (seql < strl) {
762
      ambiguous = true;
763
    }
764
  }
765

    
766
  // ARROW LEFT
767
  if (strncmp(seq, KEYSTRING_ARROWLEFT, seql) == 0) {
768
    strl = strlen(KEYSTRING_ARROWLEFT);
769
    if (seql == strl) {
770
      return KEY_ARROWLEFT;
771
    } else if (seql < strl) {
772
      ambiguous = true;
773
    }
774
  }
775

    
776
  // ARROW RIGHT
777
  if (strncmp(seq, KEYSTRING_ARROWRIGHT, seql) == 0) {
778
    strl = strlen(KEYSTRING_ARROWRIGHT);
779
    if (seql == strl) {
780
      return KEY_ARROWRIGHT;
781
    } else if (seql < strl) {
782
      ambiguous = true;
783
    }
784
  }
785

    
786
  // CTRL + ARROW UP
787
  if (strncmp(seq, KEYSTRING_CTRL_ARROWUP, seql) == 0) {
788
    strl = strlen(KEYSTRING_CTRL_ARROWUP);
789
    if (seql == strl) {
790
      return KEY_CTRL_ARROWUP;
791
    } else if (seql < strl) {
792
      ambiguous = true;
793
    }
794
  }
795

    
796
  // CTRL + ARROW DOWN
797
  if (strncmp(seq, KEYSTRING_CTRL_ARROWDOWN, seql) == 0) {
798
    strl = strlen(KEYSTRING_CTRL_ARROWDOWN);
799
    if (seql == strl) {
800
      return KEY_CTRL_ARROWDOWN;
801
    } else if (seql < strl) {
802
      ambiguous = true;
803
    }
804
  }
805

    
806
  // CTRL + ARROW LEFT
807
  if (strncmp(seq, KEYSTRING_CTRL_ARROWLEFT, seql) == 0) {
808
    strl = strlen(KEYSTRING_CTRL_ARROWLEFT);
809
    if (seql == strl) {
810
      return KEY_CTRL_ARROWLEFT;
811
    } else if (seql < strl) {
812
      ambiguous = true;
813
    }
814
  }
815

    
816
  // CTRL + ARROW RIGHT
817
  if (strncmp(seq, KEYSTRING_CTRL_ARROWRIGHT, seql) == 0) {
818
    strl = strlen(KEYSTRING_CTRL_ARROWRIGHT);
819
    if (seql == strl) {
820
      return KEY_CTRL_ARROWRIGHT;
821
    } else if (seql < strl) {
822
      ambiguous = true;
823
    }
824
  }
825

    
826
  return ambiguous ? KEY_AMBIGUOUS : KEY_UNKNOWN;
827
}
828

    
829
/**
830
 * @brief   Move the cursor in the terminal.
831
 *
832
 * @param[in] shell   Pointer to the shell object.
833
 * @param[in] line    Pointer to the current content of the line.
834
 * @param[in] from    Starting position of the cursor.
835
 * @param[in] to      Target position to move the cursor to.
836
 *
837
 * @return            The number of positions moved.
838
 */
839
static int _moveCursor(aos_shell_t* shell, const char* line, size_t from, size_t to)
840
{
841
  aosDbgCheck(shell != NULL);
842
  aosDbgCheck(line !=  NULL || from >= to);
843
  aosDbgCheck(from <= shell->input.linewidth);
844
  aosDbgCheck(to <= shell->input.linewidth);
845

    
846
  // local variables
847
  size_t pos = from;
848

    
849
  // move cursor left by printing backspaces
850
  while (pos > to) {
851
    streamPut(&shell->stream, '\b');
852
    --pos;
853
  }
854

    
855
  // move cursor right by printing line content
856
  while (pos < to) {
857
    streamPut(&shell->stream, (uint8_t)line[pos]);
858
    ++pos;
859
  }
860

    
861
  return (int)pos - (int)from;
862
}
863

    
864
/**
865
 * @brief   Print content of a given string to the shell output stream.
866
 *
867
 * @param[in] shell   Pointer to the shell object.
868
 * @param[in] line    Pointer to the line to be printed.
869
 * @param[in] from    First position to start printing from.
870
 * @param[in] to      Position after the last character to print.
871
 *
872
 * @return            Number of characters printed.
873
 */
874
static size_t _printString(aos_shell_t* shell, const char* line, size_t from, size_t to)
875
{
876
  aosDbgCheck(shell != NULL);
877
  aosDbgCheck(line != NULL || from >= to);
878
  aosDbgCheck(from < shell->input.linewidth);
879
  aosDbgCheck(to <= shell->input.linewidth);
880

    
881
  // local variables
882
  size_t cnt;
883

    
884
  for (cnt = 0; from + cnt < to; ++cnt) {
885
    streamPut(&shell->stream, (uint8_t)line[from + cnt]);
886
  }
887

    
888
  return cnt;
889
}
890

    
891
/**
892
 * @brief   Print a single character to the input buffer and to the output stream.
893
 *
894
 * @param[in] shell   Pointer to the shell object.
895
 * @param[in] rdata   Pointer to the runtim data object.
896
 * @param[in] c       Character to print.
897
 *
898
 * @return  Number of successfully handled characters.
899
 *          The return value can be interpreted as boolean (1 = sucess; 0 = error).
900
 */
901
static int _printChar(aos_shell_t* shell, runtimedata_t* rdata, char c)
902
{
903
  aosDbgCheck(shell != NULL);
904
  aosDbgCheck(rdata != NULL);
905

    
906
  // check whether input line is already full
907
  if (rdata->input.length + 1 >= shell->input.linewidth) {
908
    return 0;
909
  }
910

    
911
  // retreive entry in the input buffer
912
  char* line = _getCurrentEntry(shell, rdata);
913

    
914
  // overwrite content
915
  if (shell->config & AOS_SHELL_CONFIG_INPUT_OVERWRITE) {
916
    line[rdata->input.cursorpos] = c;
917
    ++rdata->input.cursorpos;
918
    rdata->input.length = (rdata->input.cursorpos > rdata->input.length) ? rdata->input.cursorpos : rdata->input.length;
919
    streamPut(&shell->stream, (uint8_t)c);
920
    return 1;
921
  }
922
  // insert character
923
  else {
924
    memmove(&line[rdata->input.cursorpos + 1], &line[rdata->input.cursorpos], rdata->input.length - rdata->input.cursorpos);
925
    line[rdata->input.cursorpos] = c;
926
    ++rdata->input.length;
927
    _printString(shell, line, rdata->input.cursorpos, rdata->input.length);
928
    ++rdata->input.cursorpos;
929
    _moveCursor(shell, line, rdata->input.length, rdata->input.cursorpos);
930
    return 1;
931
  }
932
}
933

    
934
/**
935
 * @brief   Overwrite the current output with a given line.
936
 * @details If the current output is longer than the string, the additional characters are cleared.
937
 *
938
 * @param[in] shell   Pointer to a shell object.
939
 * @param[in] rdata   Pointer to a runtime data object.
940
 * @param[in] line    The line to be printed.
941
 */
942
static void _overwriteOutput(aos_shell_t* shell, runtimedata_t* rdata, const char* line)
943
{
944
  aosDbgCheck(shell != NULL);
945
  aosDbgCheck(rdata != NULL);
946
  aosDbgCheck(line != NULL);
947

    
948
  // local variables
949
  const size_t oldlength = rdata->input.length;
950

    
951
  // print line (overwrite current output)
952
  _moveCursor(shell, line, rdata->input.cursorpos, 0);
953
  rdata->input.length = strlen(line);
954
  _printString(shell, line, 0, rdata->input.length);
955

    
956
  // clear any remaining symbols
957
  if (oldlength > rdata->input.length) {
958
    for (rdata->input.cursorpos = rdata->input.length; rdata->input.cursorpos < oldlength; ++rdata->input.cursorpos) {
959
      streamPut(&shell->stream, ' ');
960
    }
961
    _moveCursor(shell, line, oldlength, rdata->input.length);
962
  }
963

    
964
  rdata->input.cursorpos = rdata->input.length;
965

    
966
  return;
967
}
968

    
969
/**
970
 * @brief   Compare two characters.
971
 *
972
 * @param[in] lhs       First character to compare.
973
 * @param[in] rhs       Second character to compare.
974
 *
975
 * @return              How well the characters match.
976
 */
977
static inline charmatch_t _charcmp(char lhs, char rhs)
978
{
979
  // if lhs is a upper case letter and rhs is a lower case letter
980
  if (lhs >= 'A' && lhs <= 'Z' && rhs >= 'a' && rhs <= 'z') {
981
    return (lhs == (rhs - 'a' + 'A')) ? CHAR_MATCH_NCASE : CHAR_MATCH_NOT;
982
  }
983
  // if lhs is a lower case letter and rhs is a upper case letter
984
  else if (lhs >= 'a' && lhs <= 'z' && rhs >= 'A' && rhs <= 'Z') {
985
    return ((lhs - 'a' + 'A') == rhs) ? CHAR_MATCH_NCASE : CHAR_MATCH_NOT;
986
  }
987
  // default
988
  else {
989
    return (lhs == rhs) ? CHAR_MATCH_CASE : CHAR_MATCH_NOT;
990
  }
991
}
992

    
993
/**
994
 * @brief   Maps an character from ASCII to a modified custom encoding.
995
 * @details The custom character encoding is very similar to ASCII and has the following structure:
996
 *          0x00=NULL ... 0x40='@' (identically to ASCII)
997
 *          0x4A='a'; 0x4B='A'; 0x4C='b'; 0x4D='B' ... 0x73='z'; 0x74='Z' (custom letter order)
998
 *          0x75='[' ... 0x7A='`' (0x5B..0x60 is ASCII)
999
 *          0x7B='{' ... 0x7F=DEL (identically to ASCII)
1000
 *
1001
 * @param[in] c   Character to map to the custom encoding.
1002
 *
1003
 * @return    The customly encoded character.
1004
 */
1005
static inline char _mapAscii2Custom(char c)
1006
{
1007
  if (c >= 'A' && c <= 'Z') {
1008
    return ((c - 'A') * 2) + 'A' + 1;
1009
  } else if (c > 'Z' && c < 'a') {
1010
    return c + ('z' - 'a') + 1;
1011
  } else if (c >= 'a' && c <= 'z') {
1012
    return ((c - 'a') * 2) + 'A';
1013
  } else {
1014
    return c;
1015
  }
1016
}
1017

    
1018
/**
1019
 * @brief   Compares two strings wrt letter case.
1020
 * @details Comparisson uses a custom character encoding or mapping.
1021
 *          See @p _mapAscii2Custom for details.
1022
 *
1023
 * @param[in] str1    First string to compare.
1024
 * @param[in] str2    Second string to compare.
1025
 * @param[in] cs      Flag indicating whether comparison shall be case sensitive.
1026
 * @param[in,out] n   Maximum number of character to compare (in) and number of matching characters (out).
1027
 *                    If a null pointer is specified, this parameter is ignored.
1028
 *                    If the value pointed to is zero, comarison will not be limited.
1029
 * @param[out] m      Optional indicator whether there was at least one case mismatch.
1030
 *
1031
 * @return      Integer value indicating the relationship between the strings.
1032
 * @retval <0   The first character that does not match has a lower value in str1 than in str2.
1033
 * @retval  0   The contents of both strings are equal.
1034
 * @retval >0   The first character that does not match has a greater value in str1 than in str2.
1035
 */
1036
static int _strccmp(const char *str1, const char *str2, bool cs, size_t* n, charmatch_t* m)
1037
{
1038
  aosDbgCheck(str1 != NULL);
1039
  aosDbgCheck(str2 != NULL);
1040

    
1041
  // initialize variables
1042
  if (m) {
1043
    *m = CHAR_MATCH_NOT;
1044
  }
1045
  size_t i = 0;
1046

    
1047
  // iterate through the strings
1048
  while ((n == NULL) || (*n == 0) || (*n > 0 && i < *n)) {
1049
    // break on NUL
1050
    if (str1[i] == '\0' || str2[i] == '\0') {
1051
      if (n) {
1052
        *n = i;
1053
      }
1054
      break;
1055
    }
1056
    // compare character
1057
    const charmatch_t match = _charcmp(str1[i], str2[i]);
1058
    if ((match == CHAR_MATCH_CASE) || (!cs && match == CHAR_MATCH_NCASE)) {
1059
      if (m != NULL && *m != CHAR_MATCH_NCASE) {
1060
        *m = match;
1061
      }
1062
      ++i;
1063
    } else {
1064
      if (n) {
1065
        *n = i;
1066
      }
1067
      break;
1068
    }
1069
  }
1070

    
1071
  return _mapAscii2Custom(str1[i]) - _mapAscii2Custom(str2[i]);
1072
}
1073

    
1074
/**
1075
 * @brief   Alters all intermediate NUL bytes in a string to spaces.
1076
 *
1077
 * @param[in] string  The string to be handled.
1078
 * @param[in] length  Length of the string.
1079
 *
1080
 * @return  Detected Length of the actual content of the string.
1081
 */
1082
static size_t _restoreWhitespace(char* string, size_t length)
1083
{
1084
  aosDbgCheck(string != NULL || length == 0);
1085

    
1086
  // local variables
1087
  size_t c = length;
1088

    
1089
  // seach for first non-NUL byte from the back
1090
  while (c > 0) {
1091
    --c;
1092
    if (string[c] != '\0') {
1093
      // store the detected length of the content
1094
      length = ++c;
1095
      break;
1096
    }
1097
  }
1098

    
1099
  // iterate further and replace all encountered NUL bytes by spaces
1100
  while (c > 0) {
1101
    --c;
1102
    if (string[c] == '\0') {
1103
      string[c] = ' ';
1104
    }
1105
  }
1106

    
1107
  return length;
1108
}
1109

    
1110
/**
1111
 * @brief   Performs required actions before an imminent modiifcation (character input, deletion or autofill).
1112
 * @details This functions checks the current status and clears or copies entries in the input buffer as required.
1113
 *          Status information (runtime data) is altered accordingly as well.
1114
 *
1115
 * @param[in] shell   Pointer to a shell object.
1116
 * @param[in] rdata   Pointer to a runtime data object.
1117
 *
1118
 * @return    Pointer to the current entry in the input buffer.
1119
 */
1120
static char* _prepare4Modification(aos_shell_t* shell, runtimedata_t* rdata)
1121
{
1122
  aosDbgCheck(shell != NULL);
1123
  aosDbgCheck(rdata != NULL);
1124

    
1125
  char* line = _getCurrentEntry(shell, rdata);
1126

    
1127
  // cleared preview
1128
  if (rdata->buffer.selected == 0) {
1129
    // reset the current entry if required
1130
    if (rdata->buffer.edited != 0) {
1131
      memset(line, '\0', shell->input.linewidth * sizeof(char));
1132
    }
1133
    // set the current entry as the selected one and mark it as edited
1134
    rdata->buffer.selected = 1;
1135
    rdata->buffer.edited = 1;
1136
  }
1137
  // current entry
1138
  else if (rdata->buffer.selected == 1) {
1139
    // mark current entry as edited
1140
    rdata->buffer.edited = 1;
1141
  }
1142
  // preview of historic entry
1143
  else if (rdata->buffer.selected > 1) {
1144
    // copy the selected entry before modification if required
1145
    if (rdata->buffer.selected!= rdata->buffer.edited) {
1146
      memcpy(line, _getSelectedEntry(shell, rdata), shell->input.linewidth * sizeof(char));
1147
    }
1148
    // mark the selected entry as edited
1149
    rdata->buffer.edited = rdata->buffer.selected;
1150
  }
1151

    
1152
  return line;
1153
}
1154

    
1155
/**
1156
 * @brief   Read input from a channel as long as there is data available.
1157
 *
1158
 * @param[in]     shell     Pointer to the shell object.
1159
 * @param[in,out] rdata     Pointer to a runtime data object.
1160
 * @param[in]     channel   The channel to read from.
1161
 *
1162
 * @return  Number of characters read.
1163
 */
1164
static size_t _readChannel(aos_shell_t* shell, runtimedata_t* rdata, AosShellChannel* channel)
1165
{
1166
  aosDbgCheck(shell != NULL);
1167
  aosDbgCheck(rdata != NULL);
1168
  aosDbgCheck(channel != NULL);
1169

    
1170
  // local variables
1171
  size_t bytes = 0;
1172
  char c;
1173
  special_key_t key;
1174
  action_t action;
1175

    
1176
  // read character by character from the channel
1177
  while (chnReadTimeout(channel, (uint8_t*)&c, 1, TIME_IMMEDIATE)) {
1178
    // increment byte counter
1179
    ++bytes;
1180

    
1181
    // drop any further input after an execution request was detected
1182
    if (rdata->lastaction == ACTION_EXECUTE && bytes > 1) {
1183
      continue;
1184
    }
1185

    
1186
    // try to interprete escape sequence
1187
    {
1188
      // set default
1189
      key = KEY_UNKNOWN;
1190
      // only interprete, if there is an escape sequence at all
1191
      const size_t escl = strlen(rdata->input.escseq);
1192
      if (escl > 0) {
1193
        // append and 'consume' character
1194
        rdata->input.escseq[escl] = c;
1195
        c = '\0';
1196
        // try to interprete sequence
1197
        key = _interpreteEscapeSequence(rdata->input.escseq);
1198
        switch (key) {
1199
          // ambiguous key due to incomplete sequence
1200
          case KEY_AMBIGUOUS:
1201
            // read next byte to resolve ambiguity
1202
            continue;
1203
          // an unknown sequence has been encountered
1204
          case KEY_UNKNOWN:
1205
            // increment number of inputs but handle this unknown sequence below
1206
            break;
1207
          // a key was identified successfully
1208
          default:
1209
            // reset the sequence buffer
1210
            memset(rdata->input.escseq, '\0', AOS_SHELL_ESCSEQUENCE_LENGTH * sizeof(char));
1211
            break;
1212
        }
1213
      }
1214
    }
1215

    
1216
    /*
1217
     * Derive action to be executed from keypress.
1218
     * This step handles all sanity checks, so any required prerequisites for the selected action are fulfilled.
1219
     */
1220
    // set default
1221
    action = ACTION_NONE;
1222
    // if there is no escape sequence pending
1223
    if (rdata->input.escseq[0] == '\0') {
1224

    
1225
      // printable character
1226
      if (c >= '\x20' && c <= '\x7E') {
1227
        action = ACTION_READCHAR;
1228
      }
1229

    
1230
      // tab key or character
1231
      else if (c == '\x09' || key == KEY_TAB) {
1232
        /*
1233
         * pressing tab once applies auto fill
1234
         * pressing tab a second time (or more) prints suggestions
1235
         */
1236
        if (rdata->lastaction == ACTION_AUTOCOMPLETE || rdata->lastaction == ACTION_SUGGEST) {
1237
          action = ACTION_SUGGEST;
1238
        } else {
1239
          action = ACTION_AUTOCOMPLETE;
1240
        }
1241
      }
1242

    
1243
      // carriage return ('\r') or line feed ('\n') character
1244
      else if (c == '\x0D' || c == '\x0A') {
1245
        action = ACTION_EXECUTE;
1246
      }
1247

    
1248
      // backspace key or character
1249
      else if (c == '\x08' || key == KEY_BACKSPACE) {
1250
        // ignore if cursor is at very left
1251
        if (rdata->input.cursorpos > 0) {
1252
          action = ACTION_DELETEBACKWARD;
1253
        }
1254
      }
1255

    
1256
      // DEL key or character
1257
      else if (c == '\x7F' || key == KEY_DELETE) {
1258
        // ignore if cursor is at very right
1259
        if (rdata->input.cursorpos < rdata->input.length) {
1260
          action = ACTION_DELETEFORWARD;
1261
        }
1262
      }
1263

    
1264
      // 'arrow up' key
1265
      else if (key == KEY_ARROWUP) {
1266
        // recall previous input from history only if
1267
        // not the oldest entry is already selected and
1268
        // the previous entry has been set.
1269
        if (rdata->buffer.selected < shell->input.nentries &&
1270
            (_getRelativeEntry(shell, rdata, rdata->buffer.selected))[0] != INBUF_INIT_CHAR) {
1271
          action = ACTION_RECALLPREVIOUS;
1272
        }
1273
      }
1274

    
1275
      // 'arrow down' key
1276
      else if (key == KEY_ARROWDOWN) {
1277
        // clear the line if
1278
        // no historic entry is selected or
1279
        // the most recent entry is selected, but the current one is occupied by a moodfied version of a historic entry
1280
        if ((rdata->buffer.selected == 1) ||
1281
            (rdata->buffer.selected == 2 && rdata->buffer.edited > 1)) {
1282
          action = ACTION_CLEAR;
1283
        }
1284
        // if a historic entry is selected, recall the next input from history
1285
        else if (rdata->buffer.selected > 1) {
1286
          action = ACTION_RECALLNEXT;
1287
        }
1288
      }
1289

    
1290
      // 'arrow left' key
1291
      else if (key == KEY_ARROWLEFT) {
1292
        // ignore if cursor is very left
1293
        if (rdata->input.cursorpos > 0) {
1294
          action = ACTION_CURSORLEFT;
1295
        }
1296
      }
1297

    
1298
      // 'arrow right' key
1299
      else if (key == KEY_ARROWRIGHT) {
1300
        // ignore if cursor is very right
1301
        if (rdata->input.cursorpos < rdata->input.length) {
1302
          action = ACTION_CURSORRIGHT;
1303
        }
1304
      }
1305

    
1306
      // CTRL + 'arrow up' key combination or 'page up' key
1307
      else if (key == KEY_CTRL_ARROWUP || key == KEY_PAGEUP) {
1308
        // recall oldest input from history only if
1309
        // not the oldest entry is already selected and
1310
        // there is at least one history entry set
1311
        if (rdata->buffer.selected < shell->input.nentries &&
1312
            (_getRelativeEntry(shell, rdata, (rdata->buffer.selected > 0) ? 1 : 0))[0] != INBUF_INIT_CHAR) {
1313
          action = ACTION_RECALLOLDEST;
1314
        }
1315
      }
1316

    
1317
      // CTRL + 'arrow down' key combination or 'page down' key
1318
      else if (key == KEY_CTRL_ARROWDOWN || key == KEY_PAGEDOWN) {
1319
        // clear the line if
1320
        // no historic entry is selected or
1321
        // the most recent entry is selected, but the current one is occupied by a moodfied version of a historic entry
1322
        if ((rdata->buffer.selected == 1) ||
1323
            (rdata->buffer.selected > 1 && rdata->buffer.edited > 1)) {
1324
          action = ACTION_CLEAR;
1325
        }
1326
        // if a historic entry is selected, reset to the current input
1327
        else if (rdata->buffer.selected > 1) {
1328
          action = ACTION_RECALLCURRENT;
1329
        }
1330
      }
1331

    
1332
      // CTRL + 'arrow left' key combination
1333
      else if (key == KEY_CTRL_ARROWLEFT) {
1334
        // ignore if cursor is very left
1335
        if (rdata->input.cursorpos > 0) {
1336
          action = ACTION_CURSORWORDLEFT;
1337
        }
1338
      }
1339

    
1340
      // CTRL + 'arrow right' key combination
1341
      else if (key == KEY_CTRL_ARROWRIGHT) {
1342
        // ignore if cursor is very right
1343
        if (rdata->input.cursorpos < rdata->input.length) {
1344
          action = ACTION_CURSORWORDRIGHT;
1345
        }
1346
      }
1347

    
1348
      // 'end' key
1349
      else if (key == KEY_END) {
1350
        // ignore if cursos is very right
1351
        if (rdata->input.cursorpos < rdata->input.length) {
1352
          action = ACTION_CURSOR2END;
1353
        }
1354
      }
1355

    
1356
      // 'home' key
1357
      else if (key == KEY_HOME) {
1358
        // ignore if cursor is very left
1359
        if (rdata->input.cursorpos > 0) {
1360
          action = ACTION_CURSOR2START;
1361
        }
1362
      }
1363

    
1364
      // CTRL + C key combination
1365
      else if (c == '\x03' || key == KEY_CTRL_C) {
1366
        action = ACTION_RESET;
1367
      }
1368

    
1369
      // INS key
1370
      else if (key == KEY_INSERT) {
1371
        action = ACTION_INSERTTOGGLE;
1372
      }
1373

    
1374
      // ESC key or [ESCAPE] character
1375
      else if (c == '\x1B' || key == KEY_ESCAPE) {
1376
        action = ACTION_ESCSTART;
1377
      }
1378
    }
1379
    // ongoing escape sequence or interpretation failed
1380
    else /* if (rdata->input.escseq[0] != '\0') */ {
1381
      // unknown escape sequence (interpretation failed)
1382
      if (key == KEY_UNKNOWN) {
1383
        action = ACTION_PRINTUNKNOWNSEQUENCE;
1384
      }
1385
    } /* end of action selection */
1386

    
1387
    /*
1388
     * execute action
1389
     */
1390
    switch (action) {
1391
      case ACTION_NONE:
1392
      {
1393
        // do nothing (ignore input) and read next byte
1394
        break;
1395
      }
1396

    
1397
      case ACTION_READCHAR:
1398
      {
1399
        char* line = _prepare4Modification(shell, rdata);
1400
        if (_printChar(shell, rdata, c) == 0) {
1401
          // line is full
1402
          _moveCursor(shell, line, rdata->input.cursorpos, rdata->input.length);
1403
          chprintf((BaseSequentialStream*)&shell->stream, "\n\tmaximum line width reached\n");
1404
          _printPrompt(shell);
1405
          _printString(shell, line, 0, rdata->input.length);
1406
          _moveCursor(shell, line, rdata->input.length, rdata->input.cursorpos);
1407
        }
1408
        break;
1409
      }
1410

    
1411
      case ACTION_AUTOCOMPLETE:
1412
      {
1413
        // local variables
1414
        char* line = _getVisualisedEntry(shell, rdata);
1415
        const char* fill = line;
1416
        size_t cmatch = rdata->input.cursorpos;
1417
        charmatch_t matchlevel = CHAR_MATCH_NOT;
1418
        size_t n;
1419

    
1420
        // only execute autofill if the line is valid
1421
        if (line) {
1422
          _prepare4Modification(shell, rdata);
1423

    
1424
          // iterate through command list
1425
          for (aos_shellcommand_t* cmd = shell->commands; cmd != NULL; cmd = cmd->next) {
1426
            // compare current match with command
1427
            n = cmatch;
1428
            charmatch_t mlvl = CHAR_MATCH_NOT;
1429
            _strccmp(fill, cmd->name, shell->config & AOS_SHELL_CONFIG_MATCH_CASE, (n == 0) ? NULL : &n, &mlvl);
1430
            const int cmp = (n < cmatch) ?
1431
                  ((int)n - (int)cmatch) :
1432
                  (cmd->name[n] != '\0') ?
1433
                    (int)strlen(cmd->name) - (int)n :
1434
                    0;
1435
            // if an exact match was found
1436
            if ((size_t)((int)cmatch + cmp) == rdata->input.cursorpos) {
1437
              cmatch = rdata->input.cursorpos;
1438
              fill = cmd->name;
1439
              // break the loop only if there are no case mismatches with the input
1440
              n = rdata->input.cursorpos;
1441
              _strccmp(fill, line, false, &n, &mlvl);
1442
              if (mlvl == CHAR_MATCH_CASE) {
1443
                break;
1444
              }
1445
            }
1446
            // if a not exact match was found
1447
            else if ((size_t)((int)cmatch + cmp) > rdata->input.cursorpos) {
1448
              // if this is the first one
1449
              if (fill == line) {
1450
                cmatch = (size_t)((int)cmatch + cmp);
1451
                fill = cmd->name;
1452
              }
1453
              // if this is a worse one
1454
              else if ((cmp < 0) || (cmp == 0 && mlvl == CHAR_MATCH_CASE)) {
1455
                cmatch = (size_t)((int)cmatch + cmp);
1456
              }
1457
            }
1458
            // non matching commands are ignored
1459
            else {}
1460
          }
1461

    
1462
          // evaluate if there are case mismatches
1463
          n = cmatch;
1464
          _strccmp(line, fill, shell->config & AOS_SHELL_CONFIG_MATCH_CASE, &n, &matchlevel);
1465
          // print the auto fill if any
1466
          if ((cmatch > rdata->input.cursorpos) ||
1467
              (cmatch == rdata->input.cursorpos && matchlevel == CHAR_MATCH_NCASE && strlen(fill) == rdata->input.cursorpos)) {
1468
            // limit auto fill so it will not overflow the line width
1469
            if (rdata->input.length + (cmatch - rdata->input.cursorpos) > shell->input.linewidth) {
1470
              cmatch = shell->input.linewidth - rdata->input.length + rdata->input.cursorpos;
1471
            }
1472
            // move trailing memory further in the line
1473
            memmove(&line[cmatch], &line[rdata->input.cursorpos], (rdata->input.length - rdata->input.cursorpos) * sizeof(char));
1474
            rdata->input.length += cmatch - rdata->input.cursorpos;
1475
            // if there was no incorrect case when matching
1476
            if (matchlevel == CHAR_MATCH_CASE) {
1477
              // insert fill command name to line
1478
              memcpy(&line[rdata->input.cursorpos], &fill[rdata->input.cursorpos], (cmatch - rdata->input.cursorpos) * sizeof(char));
1479
              // print the output
1480
              _printString(shell, line, rdata->input.cursorpos, rdata->input.length);
1481
            } else {
1482
              // overwrite line with fill command name
1483
              memcpy(line, fill, cmatch * sizeof(char));
1484
              // reprint the whole line
1485
              _moveCursor(shell, line, rdata->input.cursorpos, 0);
1486
              _printString(shell, line, 0, rdata->input.length);
1487
            }
1488
            // move cursor to the end of the matching sequence
1489
            rdata->input.cursorpos = cmatch;
1490
            _moveCursor(shell, line, rdata->input.length, rdata->input.cursorpos);
1491
          }
1492
        }
1493
        break;
1494
      }
1495

    
1496
      case ACTION_SUGGEST:
1497
      {
1498
        // local variables
1499
        const char* line = _getVisualisedEntry(shell, rdata);
1500
        unsigned int matches = 0;
1501

    
1502
        // iterate through command list
1503
        for (aos_shellcommand_t* cmd = shell->commands; cmd != NULL; cmd = cmd->next) {
1504
          // compare line content with command, except if cursorpos is 0
1505
          size_t i = rdata->input.cursorpos;
1506
          if (rdata->input.cursorpos > 0) {
1507
            _strccmp(line, cmd->name, shell->config & AOS_SHELL_CONFIG_MATCH_CASE, &i, NULL);
1508
          }
1509
          const int cmp = (i < rdata->input.cursorpos) ?
1510
                ((int)i - (int)rdata->input.cursorpos) :
1511
                (cmd->name[i] != '\0') ?
1512
                  (int)strlen(cmd->name) - (int)i :
1513
                  0;
1514
          // if a match was found
1515
          if (cmp > 0) {
1516
            // if this is the first one
1517
            if (matches == 0) {
1518
              _moveCursor(shell, line, rdata->input.cursorpos, rdata->input.length);
1519
              streamPut(&shell->stream, '\n');
1520
            }
1521
            // print the command
1522
            chprintf((BaseSequentialStream*)&shell->stream, "\t%s\n", cmd->name);
1523
            ++matches;
1524
          }
1525
        }
1526
        // reprint the prompt and line if any matches have been found
1527
        if (matches > 0) {
1528
          _printPrompt(shell);
1529
          _printString(shell, line, 0, rdata->input.length);
1530
          _moveCursor(shell, line, rdata->input.length, rdata->input.cursorpos);
1531
        }
1532
        break;
1533
      }
1534

    
1535
      case ACTION_EXECUTE:
1536
      {
1537
        // if the input buffer can hold historic entries
1538
        if (shell->input.nentries > 1) {
1539
          _prepare4Modification(shell, rdata);
1540
        }
1541
        break;
1542
      }
1543

    
1544
      case ACTION_DELETEBACKWARD:
1545
      {
1546
        char* line = _prepare4Modification(shell, rdata);
1547
        --rdata->input.cursorpos;
1548
        memmove(&line[rdata->input.cursorpos], &line[rdata->input.cursorpos + 1], (rdata->input.length - rdata->input.cursorpos) * sizeof(char));
1549
        --rdata->input.length;
1550
        line[rdata->input.length] = '\0';
1551
        _moveCursor(shell, line, rdata->input.cursorpos + 1, rdata->input.cursorpos);
1552
        _printString(shell, line, rdata->input.cursorpos, rdata->input.length);
1553
        streamPut(&shell->stream, ' ');
1554
        _moveCursor(shell, line, rdata->input.length + 1, rdata->input.cursorpos);
1555
        break;
1556
      }
1557

    
1558
      case ACTION_DELETEFORWARD:
1559
      {
1560
        char* line = _prepare4Modification(shell, rdata);
1561
        --rdata->input.length;
1562
        memmove(&line[rdata->input.cursorpos], &line[rdata->input.cursorpos + 1], (rdata->input.length - rdata->input.cursorpos) * sizeof(char));
1563
        _printString(shell, line, rdata->input.cursorpos, rdata->input.length);
1564
        streamPut(&shell->stream, ' ');
1565
        _moveCursor(shell, line, rdata->input.length + 1, rdata->input.cursorpos);
1566
        break;
1567
      }
1568

    
1569
      case ACTION_CLEAR:
1570
      {
1571
        // clear visualization
1572
        _moveCursor(shell, NULL, rdata->input.cursorpos, 0);
1573
        for (size_t cpos = 0; cpos < rdata->input.length; ++cpos) {
1574
          streamPut(&shell->stream, ' ');
1575
        }
1576
        _moveCursor(shell, NULL, rdata->input.length, 0);
1577

    
1578
        // update metadata
1579
        rdata->input.cursorpos = 0;
1580
        rdata->input.length = 0;
1581
        rdata->buffer.selected = 0;
1582

    
1583
        break;
1584
      }
1585

    
1586
      case ACTION_RECALLPREVIOUS:
1587
      {
1588
        // if the input was cleared but the current entry is occupied by a modified copy of a history entry, skip the current entry
1589
        if (shell->input.nentries > 1 && rdata->buffer.selected == 0 && rdata->buffer.edited != 1) {
1590
          rdata->buffer.selected += 2;
1591
        } else {
1592
          ++rdata->buffer.selected;
1593
        }
1594
        _overwriteOutput(shell, rdata, _getVisualisedEntry(shell, rdata));
1595
        break;
1596
      }
1597

    
1598
      case ACTION_RECALLNEXT:
1599
      {
1600
        --rdata->buffer.selected;
1601
        _overwriteOutput(shell, rdata, _getVisualisedEntry(shell, rdata));
1602
        break;
1603
      }
1604

    
1605
      case ACTION_RECALLOLDEST:
1606
      {
1607
        // find oldest valid entry
1608
        rdata->buffer.selected = shell->input.nentries;
1609
        while (_getSelectedEntry(shell, rdata)[0] == INBUF_INIT_CHAR) {
1610
          --rdata->buffer.selected;
1611
        }
1612

    
1613
        _overwriteOutput(shell, rdata, _getVisualisedEntry(shell, rdata));
1614
        break;
1615
      }
1616

    
1617
      case ACTION_RECALLCURRENT:
1618
      {
1619
        rdata->buffer.selected = 1;
1620
        _overwriteOutput(shell, rdata, _getVisualisedEntry(shell, rdata));
1621
        break;
1622
      }
1623

    
1624
      case ACTION_CURSORLEFT:
1625
      {
1626
        _moveCursor(shell, NULL, rdata->input.cursorpos, rdata->input.cursorpos - 1);
1627
        --rdata->input.cursorpos;
1628
        break;
1629
      }
1630

    
1631
      case ACTION_CURSORRIGHT:
1632
      {
1633
        _moveCursor(shell, _getVisualisedEntry(shell, rdata), rdata->input.cursorpos, rdata->input.cursorpos + 1);
1634
        ++rdata->input.cursorpos;
1635
        break;
1636
      }
1637

    
1638
      case ACTION_CURSORWORDLEFT:
1639
      {
1640
        // local variables
1641
        const char* line = _getVisualisedEntry(shell, rdata);
1642
        size_t cpos = rdata->input.cursorpos;
1643

    
1644
        // skip spaces
1645
        while (cpos > 0) {
1646
          --cpos;
1647
          if (line[cpos] != ' ') {
1648
            break;
1649
          }
1650
        }
1651

    
1652
        // search for beginning of the word
1653
        while (cpos > 0) {
1654
          --cpos;
1655
          if (line[cpos] == ' ') {
1656
            // go back to first character of the word
1657
            ++cpos;
1658
            break;
1659
          }
1660
        }
1661

    
1662
        // move the cursor and set metadata
1663
        _moveCursor(shell, line, rdata->input.cursorpos, cpos);
1664
        rdata->input.cursorpos = cpos;
1665

    
1666
        break;
1667
      }
1668

    
1669
      case ACTION_CURSORWORDRIGHT:
1670
      {
1671
        // local variables
1672
        const char* line = _getVisualisedEntry(shell, rdata);
1673
        size_t cpos = rdata->input.cursorpos;
1674

    
1675
        // skip spaces
1676
        while (cpos < rdata->input.length && line[cpos] == ' ') {
1677
          ++cpos;
1678
        }
1679

    
1680
        // search for end of the word
1681
        while (cpos < rdata->input.length && line[cpos] != ' ') {
1682
          ++cpos;
1683
        }
1684

    
1685
        // move cursor and set metadata
1686
        _moveCursor(shell, line, rdata->input.cursorpos, cpos);
1687
        rdata->input.cursorpos = cpos;
1688

    
1689
        break;
1690
      }
1691

    
1692
      case ACTION_CURSOR2END:
1693
      {
1694
        _moveCursor(shell, _getVisualisedEntry(shell, rdata), rdata->input.cursorpos, rdata->input.length);
1695
        rdata->input.cursorpos = rdata->input.length;
1696
        break;
1697
      }
1698

    
1699
      case ACTION_CURSOR2START:
1700
      {
1701
        _moveCursor(shell, _getVisualisedEntry(shell, rdata), rdata->input.cursorpos, 0);
1702
        rdata->input.cursorpos = 0;
1703
        break;
1704
      }
1705

    
1706
      case ACTION_RESET:
1707
      {
1708
        // print reset indicator
1709
        chprintf((BaseSequentialStream*)&shell->stream, "^C");
1710
        if (!(shell->config & AOS_SHELL_CONFIG_INPUT_OVERWRITE)) {
1711
          _printString(shell, _getVisualisedEntry(shell, rdata), rdata->input.cursorpos, rdata->input.length);
1712
        }
1713
        chprintf((BaseSequentialStream*)&shell->stream, "\n");
1714

    
1715
        // reset buffers and metadata
1716
        if (rdata->buffer.edited != 0) {
1717
          memset(_getCurrentEntry(shell, rdata), '\0', shell->input.linewidth * sizeof(char));
1718
        }
1719
        rdata->input.length = 0;
1720
        rdata->input.cursorpos = 0;
1721
        rdata->buffer.selected = (shell->input.nentries > 1) ? 1 : 0;
1722
        rdata->buffer.edited = 0;
1723

    
1724
        // print a new prompt
1725
        _printPrompt(shell);
1726

    
1727
        break;
1728
      }
1729

    
1730
      case ACTION_INSERTTOGGLE:
1731
      {
1732
        if (shell->config & AOS_SHELL_CONFIG_INPUT_OVERWRITE) {
1733
          shell->config &= ~AOS_SHELL_CONFIG_INPUT_OVERWRITE;
1734
        } else {
1735
          shell->config |= AOS_SHELL_CONFIG_INPUT_OVERWRITE;
1736
        }
1737
        break;
1738
      }
1739

    
1740
      case ACTION_ESCSTART:
1741
      {
1742
        rdata->input.escseq[0] = c;
1743
        break;
1744
      }
1745

    
1746
      case ACTION_PRINTUNKNOWNSEQUENCE:
1747
      {
1748
        _prepare4Modification(shell, rdata);
1749
        for (size_t seqc = 1; rdata->input.escseq[seqc] != '\0'; ++seqc) {
1750
          // element 0 would be unprintable ESC character
1751
          _printChar(shell, rdata, rdata->input.escseq[seqc]);
1752
        }
1753
        memset(rdata->input.escseq, '\0', AOS_SHELL_ESCSEQUENCE_LENGTH * sizeof(char));
1754
        break;
1755
      }
1756
    }
1757

    
1758
    // update runtime data
1759
    rdata->lastaction = (action != ACTION_NONE) ? action : rdata->lastaction;
1760
  } /* end of while */
1761

    
1762
  return bytes;
1763
}
1764

    
1765
/**
1766
 * @brief   Parses the content of the given string to separate arguments.
1767
 *
1768
 * @param[in]   shell   Pointer to the shell object.
1769
 * @param[in]   str     String to be parsed.
1770
 * @param[out]  argbuf  Buffer to store argument pointers to.
1771
 *
1772
 * @return            Number of arguments found.
1773
 */
1774
static size_t _parseArguments(aos_shell_t* shell, char* str, char** argbuf)
1775
{
1776
  aosDbgCheck(shell != NULL);
1777
  aosDbgCheck(str != NULL);
1778
  aosDbgCheck(argbuf != NULL);
1779

    
1780
  /*
1781
   * States for a very small FSM.
1782
   */
1783
  typedef enum {
1784
    START,
1785
    SPACE,
1786
    TEXT,
1787
    END,
1788
  } state_t;
1789

    
1790
  // local variables
1791
  state_t state = START;
1792
  size_t nargs = 0;
1793

    
1794
  // iterate through the line
1795
  for (size_t c = 0; c < shell->input.linewidth; ++c) {
1796
    // terminate at first NUL byte
1797
    if (str[c] == '\0') {
1798
      state = END;
1799
      break;
1800
    }
1801
    // spaces become NUL bytes
1802
    else if (str[c] == ' ') {
1803
      str[c] = '\0';
1804
      state = SPACE;
1805
    }
1806
    // handle non-NUL bytes
1807
    else {
1808
      switch (state) {
1809
        case START:
1810
        case SPACE:
1811
          // ignore too many arguments
1812
          if (nargs < shell->input.nargs) {
1813
            argbuf[nargs] = &str[c];
1814
          }
1815
          ++nargs;
1816
          break;
1817
        case TEXT:
1818
        case END:
1819
          break;
1820
      }
1821
      state = TEXT;
1822
    }
1823
  }
1824

    
1825
  // set all remaining argument pointers to NULL
1826
  for (size_t a = nargs; a < shell->input.nargs; ++a) {
1827
    argbuf[a] = NULL;
1828
  }
1829

    
1830
  return nargs;
1831
}
1832

    
1833
/******************************************************************************/
1834
/* EXPORTED FUNCTIONS                                                         */
1835
/******************************************************************************/
1836

    
1837
/**
1838
 * @brief   Initializes a shell object with the specified parameters.
1839
 *
1840
 * @param[in,out] shell           Pointer to the shell object to be initialized.
1841
 * @param[in]     name            Name of the shell thread (may be NULL).
1842
 * @param[in]     prompt          Prompt line to print (NULL = use default prompt).
1843
 * @param[in]     inbuf           Two dimensional input buffer.
1844
 * @param[in]     entries         Number of entries in the input buffer (1st dimension).
1845
 * @param[in]     linewidth       Length of each entry in the input buffer (2nd dimension).
1846
 * @param[in]     numargs         Maximum number of arguments (defines size of internal buffer).
1847
 */
1848
void aosShellInit(aos_shell_t* shell, const char* name, const char* prompt, char inbuf[], size_t entries, size_t linewidth, size_t numargs)
1849
{
1850
  aosDbgCheck(shell != NULL);
1851
  aosDbgCheck(inbuf != NULL);
1852
  aosDbgCheck(entries > 0);
1853
  aosDbgCheck(linewidth > 0);
1854
  aosDbgCheck(numargs > 0);
1855

    
1856
  // set parameters
1857
  shell->thread = NULL;
1858
#if (CH_CFG_USE_REGISTRY == TRUE)
1859
  shell->name = name;
1860
#else /* (CH_CFG_USE_REGISTRY == TRUE) */
1861
  (void)name;
1862
#endif /* (CH_CFG_USE_REGISTRY == TRUE) */
1863
  chEvtObjectInit(&shell->eventSource);
1864
  aosShellStreamInit(&shell->stream);
1865
  shell->prompt = prompt;
1866
  shell->commands = NULL;
1867
  shell->execstatus.command = NULL;
1868
  shell->execstatus.retval = 0;
1869
  shell->input.buffer = inbuf;
1870
  shell->input.nentries = entries;
1871
  shell->input.linewidth = linewidth;
1872
  shell->input.nargs = numargs;
1873
  shell->config = 0x00;
1874

    
1875
  // initialize buffers
1876
  memset(shell->input.buffer, INBUF_INIT_CHAR, shell->input.nentries * shell->input.linewidth * sizeof(char));
1877

    
1878
  return;
1879
}
1880

    
1881
/**
1882
 * @brief   Initialize an AosShellStream object.
1883
 *
1884
 * @param[in] stream  The AosShellStrem to initialize.
1885
 */
1886
void aosShellStreamInit(AosShellStream* stream)
1887
{
1888
  aosDbgCheck(stream != NULL);
1889

    
1890
  stream->vmt = &_streamvmt;
1891
  stream->channel = NULL;
1892

    
1893
  return;
1894
}
1895

    
1896
/**
1897
 * @brief   Initialize an AosShellChannel object with the specified parameters.
1898
 *
1899
 * @param[in] channel       The AosShellChannel to initialize.
1900
 * @param[in] asyncchannel  An BaseAsynchronousChannel this AosShellChannel is associated with.
1901
 */
1902
void aosShellChannelInit(AosShellChannel* channel, BaseAsynchronousChannel* asyncchannel)
1903
{
1904
  aosDbgCheck(channel != NULL);
1905
  aosDbgCheck(asyncchannel != NULL);
1906

    
1907
  channel->vmt = &_channelvmt;
1908
  channel->asyncchannel = asyncchannel;
1909
  channel->listener.wflags = 0;
1910
  channel->next = NULL;
1911
  channel->flags = 0;
1912

    
1913
  return;
1914
}
1915

    
1916
/**
1917
 * @brief   Inserts a command to the shells list of commands.
1918
 *
1919
 * @param[in] shell   Pointer to the shell object.
1920
 * @param[in] cmd     Pointer to the command to add.
1921
 *
1922
 * @return            A status value.
1923
 * @retval AOS_SUCCESS  The command was added successfully.
1924
 * @retval AOS_ERROR    Another command with identical name already exists.
1925
 */
1926
aos_status_t aosShellAddCommand(aos_shell_t *shell, aos_shellcommand_t *cmd)
1927
{
1928
  aosDbgCheck(shell != NULL);
1929
  aosDbgCheck(cmd != NULL);
1930
  aosDbgCheck(cmd->name != NULL && strlen(cmd->name) > 0 && strchr(cmd->name, ' ') == NULL && strchr(cmd->name, '\t') == NULL);
1931
  aosDbgCheck(cmd->callback != NULL);
1932
  aosDbgCheck(cmd->next == NULL);
1933

    
1934
  aos_shellcommand_t* prev = NULL;
1935
  aos_shellcommand_t** curr = &(shell->commands);
1936

    
1937
  // insert the command to the list wrt lexographical order (exception: lower case characters preceed upper their uppercase counterparts)
1938
  while (*curr != NULL) {
1939
    // iterate through the list as long as the command names are 'smaller'
1940
    const int cmp = _strccmp((*curr)->name, cmd->name, true, NULL, NULL);
1941
    if (cmp < 0) {
1942
      prev = *curr;
1943
      curr = &((*curr)->next);
1944
      continue;
1945
    }
1946
    // error if the command already exists
1947
    else if (cmp == 0) {
1948
      return AOS_ERROR;
1949
    }
1950
    // insert the command as soon as a 'larger' name was found
1951
    else /* if (cmpval > 0) */ {
1952
      cmd->next = *curr;
1953
      // special case: the first command is larger
1954
      if (prev == NULL) {
1955
        shell->commands = cmd;
1956
      } else {
1957
        prev->next = cmd;
1958
      }
1959
      return AOS_SUCCESS;
1960
    }
1961
  }
1962
  // the end of the list has been reached
1963

    
1964
  // append the command
1965
  *curr = cmd;
1966
  return AOS_SUCCESS;
1967
}
1968

    
1969
/**
1970
 * @brief   Removes a command from the shells list of commands.
1971
 *
1972
 * @param[in] shell     Pointer to the shell object.
1973
 * @param[in] cmd       Name of the command to removde.
1974
 * @param[out] removed  Optional pointer to the command that was removed.
1975
 *
1976
 * @return              A status value.
1977
 * @retval AOS_SUCCESS  The command was removed successfully.
1978
 * @retval AOS_ERROR    The command name was not found.
1979
 */
1980
aos_status_t aosShellRemoveCommand(aos_shell_t *shell, char *cmd, aos_shellcommand_t **removed)
1981
{
1982
  aosDbgCheck(shell != NULL);
1983
  aosDbgCheck(cmd != NULL && strlen(cmd) > 0);
1984

    
1985
  aos_shellcommand_t* prev = NULL;
1986
  aos_shellcommand_t** curr = &(shell->commands);
1987

    
1988
  // iterate through the list and seach for the specified command name
1989
  while (curr != NULL) {
1990
    const int cmpval = strcmp((*curr)->name, cmd);
1991
    // iterate through the list as long as the command names are 'smaller'
1992
    if (cmpval < 0) {
1993
      prev = *curr;
1994
      curr = &((*curr)->next);
1995
      continue;
1996
    }
1997
    // remove the command when found
1998
    else if (cmpval == 0) {
1999
      // special case: the first command matches
2000
      if (prev == NULL) {
2001
        shell->commands = (*curr)->next;
2002
      } else {
2003
        prev->next = (*curr)->next;
2004
      }
2005
      (*curr)->next = NULL;
2006
      // set the optional output argument
2007
      if (removed != NULL) {
2008
        *removed = *curr;
2009
      }
2010
      return AOS_SUCCESS;
2011
    }
2012
    // break the loop if the command names are 'larger'
2013
    else /* if (cmpval > 0) */ {
2014
      break;
2015
    }
2016
  }
2017

    
2018
  // if the command was not found, return an error
2019
  return AOS_ERROR;
2020
}
2021

    
2022
/**
2023
 * @brief   Count the number of commands assigned to the shell.
2024
 *
2025
 * @param[in] shell   The shell to count the commands for.
2026
 *
2027
 * @return  The number of commands associated to the shell.
2028
 */
2029
unsigned int aosShellCountCommands(aos_shell_t* shell)
2030
{
2031
  aosDbgCheck(shell != NULL);
2032

    
2033
  unsigned int count = 0;
2034
  aos_shellcommand_t* cmd = shell->commands;
2035
  while (cmd != NULL) {
2036
    ++count;
2037
    cmd = cmd->next;
2038
  }
2039

    
2040
  return count;
2041
}
2042

    
2043
/**
2044
 * @brief   Add a channel to a AosShellStream.
2045
 *
2046
 * @param[in] stream    The AosShellStream to extend.
2047
 * @param[in] channel   The channel to be added to the stream.
2048
 */
2049
void aosShellStreamAddChannel(AosShellStream* stream, AosShellChannel* channel)
2050
{
2051
  aosDbgCheck(stream != NULL);
2052
  aosDbgCheck(channel != NULL && channel->asyncchannel != NULL && channel->next == NULL && (channel->flags & AOS_SHELLCHANNEL_ATTACHED) == 0);
2053

    
2054
  // prepend the new channel
2055
  chSysLock();
2056
  channel->flags |= AOS_SHELLCHANNEL_ATTACHED;
2057
  channel->next = stream->channel;
2058
  stream->channel = channel;
2059
  chSysUnlock();
2060

    
2061
  return;
2062
}
2063

    
2064
/**
2065
 * @brief   Remove a channel from an AosShellStream.
2066
 *
2067
 * @param[in] stream    The AosShellStream to modify.
2068
 * @param[in] channel   The channel to remove.
2069
 *
2070
 * @return              A status value.
2071
 * @retval AOS_SUCCESS  The channel was removed successfully.
2072
 * @retval AOS_ERROR    The specified channel was not found to be associated with the shell.
2073
 */
2074
aos_status_t aosShellStreamRemoveChannel(AosShellStream* stream, AosShellChannel* channel)
2075
{
2076
  aosDbgCheck(stream != NULL);
2077
  aosDbgCheck(channel != NULL && channel->asyncchannel != NULL && channel->flags & AOS_SHELLCHANNEL_ATTACHED);
2078

    
2079
  // local varibales
2080
  AosShellChannel* prev = NULL;
2081
  AosShellChannel* curr = stream->channel;
2082

    
2083
  // iterate through the list and search for the specified channel
2084
  while (curr != NULL) {
2085
    // if the channel was found
2086
    if (curr == channel) {
2087
      chSysLock();
2088
      // special case: the first channel matches (prev is NULL)
2089
      if (prev == NULL) {
2090
        stream->channel = curr->next;
2091
      } else {
2092
        prev->next = channel->next;
2093
      }
2094
      curr->next = NULL;
2095
      curr->flags &= ~AOS_SHELLCHANNEL_ATTACHED;
2096
      chSysUnlock();
2097
      return AOS_SUCCESS;
2098
    }
2099
  }
2100

    
2101
  // if the channel was not found, return an error
2102
  return AOS_ERROR;
2103
}
2104

    
2105
/**
2106
 * @brief   Enable a AosShellChannel as input.
2107
 *
2108
 * @param[in] channel   The channel to enable as input.
2109
 */
2110
void aosShellChannelInputEnable(AosShellChannel* channel)
2111
{
2112
  aosDbgCheck(channel != NULL && channel->asyncchannel != NULL);
2113

    
2114
  chSysLock();
2115
  channel->listener.wflags |= CHN_INPUT_AVAILABLE;
2116
  channel->flags |= AOS_SHELLCHANNEL_INPUT_ENABLED;
2117
  chSysUnlock();
2118

    
2119
  return;
2120
}
2121

    
2122
/**
2123
 * @brief   Disable a AosShellChannel as input.
2124
 *
2125
 * @param[in] channel   The channel to disable as input.
2126
 */
2127
void aosShellChannelInputDisable( AosShellChannel* channel)
2128
{
2129
  aosDbgCheck(channel != NULL && channel->asyncchannel != NULL);
2130

    
2131
  chSysLock();
2132
  channel->listener.wflags &= ~CHN_INPUT_AVAILABLE;
2133
  channel->flags &= ~AOS_SHELLCHANNEL_INPUT_ENABLED;
2134
  chSysUnlock();
2135

    
2136
  return;
2137
}
2138

    
2139
/**
2140
 * @brief   Enable a AosShellChannel as output.
2141
 *
2142
 * @param[in] channel   The channel to enable as output.
2143
 */
2144
void aosShellChannelOutputEnable(AosShellChannel* channel)
2145
{
2146
  aosDbgCheck(channel != NULL && channel->asyncchannel != NULL);
2147

    
2148
  channel->flags |= AOS_SHELLCHANNEL_OUTPUT_ENABLED;
2149

    
2150
  return;
2151
}
2152

    
2153
/**
2154
 * @brief   Disable a AosShellChannel as output.
2155
 *
2156
 * @param[in] channel   The channel to disable as output.
2157
 */
2158
void aosShellChannelOutputDisable(AosShellChannel* channel)
2159
{
2160
  aosDbgCheck(channel != NULL && channel->asyncchannel != NULL);
2161

    
2162
  channel->flags &= ~AOS_SHELLCHANNEL_OUTPUT_ENABLED;
2163

    
2164
  return;
2165
}
2166

    
2167
/**
2168
 * @brief   Thread main function.
2169
 *
2170
 * @param[in] aosShellThread    Name of the function;
2171
 * @param[in] shell             Pointer to the shell object.
2172
 */
2173
void aosShellThread(void* shell)
2174
{
2175
  aosDbgCheck(shell != NULL);
2176
  aosDbgCheck(((aos_shell_t*)shell)->input.nentries > 0);
2177

    
2178
  // local variables
2179
  eventmask_t eventmask;
2180
  eventflags_t eventflags;
2181
  AosShellChannel* channel;
2182
  runtimedata_t rdata;
2183
  char* args[((aos_shell_t*)shell)->input.nargs];
2184
  size_t nargs = 0;
2185
  aos_shellcommand_t* cmd;
2186

    
2187
  // initialize variables and buffers
2188
#if (CH_CFG_USE_REGISTRY == TRUE)
2189
  currp->name = ((aos_shell_t*)shell)->name;
2190
#endif /* (CH_CFG_USE_REGISTRY == TRUE) */
2191
  rdata.input.length = 0;
2192
  rdata.input.cursorpos = 0;
2193
  memset(rdata.input.escseq, '\0', AOS_SHELL_ESCSEQUENCE_LENGTH * sizeof(char));
2194
  rdata.buffer.current = 0;
2195
  rdata.buffer.selected = (((aos_shell_t*)shell)->input.nentries > 1) ? 1 : 0;
2196
  rdata.buffer.edited = 0;
2197
  rdata.lastaction = ACTION_NONE;
2198
  for (size_t arg = 0; arg < ((aos_shell_t*)shell)->input.nargs; ++arg) {
2199
    args[arg] = NULL;
2200
  }
2201
  memset(_getCurrentEntry((aos_shell_t*)shell, &rdata), '\0', ((aos_shell_t*)shell)->input.linewidth * sizeof(char));
2202

    
2203
  // register OS related events
2204
  chEvtRegisterMask(&aos.events.os, &(((aos_shell_t*)shell)->osEventListener), EVENTMASK_OS);
2205
  // register events to all input channels
2206
  for (channel = ((aos_shell_t*)shell)->stream.channel; channel != NULL; channel = channel->next) {
2207
    chEvtRegisterMaskWithFlags(&(channel->asyncchannel->event), &(channel->listener), EVENTMASK_INPUT, channel->listener.wflags);
2208
  }
2209

    
2210
  // fire start event
2211
  chEvtBroadcastFlags(&(((aos_shell_t*)shell)->eventSource), AOS_SHELL_EVTFLAG_START);
2212

    
2213
  // print the prompt for the first time
2214
  _printPrompt((aos_shell_t*)shell);
2215

    
2216
  // enter thread loop
2217
  while (!chThdShouldTerminateX()) {
2218
    // wait for event and handle it accordingly
2219
    eventmask = chEvtWaitOne(ALL_EVENTS);
2220

    
2221
    // handle event
2222
    switch (eventmask) {
2223

    
2224
      // OS related events
2225
      case EVENTMASK_OS:
2226
      {
2227
        eventflags = chEvtGetAndClearFlags(&((aos_shell_t*)shell)->osEventListener);
2228
        // handle shutdown/restart events
2229
        if (eventflags & AOS_SYSTEM_EVENTFLAGS_SHUTDOWN_MASK) {
2230
          chThdTerminate(((aos_shell_t*)shell)->thread);
2231
        } else {
2232
          // print an error message
2233
          chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "\nERROR: unknown OS event received (0x%08X)\n", eventflags);
2234
        }
2235
        break;
2236
      }
2237

    
2238
      // input events
2239
      case EVENTMASK_INPUT:
2240
      {
2241
        // check and handle all channels
2242
        channel = ((aos_shell_t*)shell)->stream.channel;
2243
        while (channel != NULL) {
2244
          eventflags = chEvtGetAndClearFlags(&channel->listener);
2245
          // if there is new input and a command shall be executed
2246
          if (eventflags & CHN_INPUT_AVAILABLE) {
2247
            _readChannel(shell, &rdata, channel);
2248

    
2249
            // if an execution request was detected
2250
            if (rdata.lastaction == ACTION_EXECUTE) {
2251
              streamPut(&((aos_shell_t*)shell)->stream, '\n');
2252
              char* line = _getVisualisedEntry((aos_shell_t*)shell, &rdata);
2253

    
2254
              // skip, if there is nothing to be executed
2255
              if (line) {
2256
                // parse arguments
2257
                nargs = _parseArguments(shell, line, args);
2258
                // check number of arguments found
2259
                if (nargs > ((aos_shell_t*)shell)->input.nargs) {
2260
                  chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "\ttoo many arguments\n");
2261
                } else if (nargs > 0) {
2262
                  // search command list for arg[0] and execute callback
2263
                  cmd = ((aos_shell_t*)shell)->commands;
2264
                  while (cmd != NULL) {
2265
                    // if the requested command has been found
2266
                    if (strcmp(args[0], cmd->name) == 0) {
2267
                      ((aos_shell_t*)shell)->execstatus.command = cmd;
2268
                      chEvtBroadcastFlags(&((aos_shell_t*)shell)->eventSource, AOS_SHELL_EVTFLAG_EXECUTE);
2269
                      ((aos_shell_t*)shell)->execstatus.retval = cmd->callback((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, (int)nargs, args);
2270
                      chEvtBroadcastFlags(&((aos_shell_t*)shell)->eventSource, AOS_SHELL_EVTFLAG_DONE);
2271
                      // notify user if execution of the command was not successful
2272
                      if (((aos_shell_t*)shell)->execstatus.retval != 0) {
2273
                        chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "command returned exit status %d\n", ((aos_shell_t*)shell)->execstatus.retval);
2274
                      }
2275
                      break;
2276
                    }
2277
                    // keep searching
2278
                    else {
2279
                      cmd = cmd->next;
2280
                    }
2281
                  } /* end of while */
2282

    
2283
                  // if no matching command was found, print a message
2284
                  if (cmd == NULL) {
2285
                    chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "\tcommand '%s' not found\n", args[0]);
2286
                  }
2287
                }
2288

    
2289
                // restore spaces in the current entry, which have been modified to NUL bytes due to argument parsing
2290
                _restoreWhitespace(line, rdata.input.length);
2291

    
2292
                // update internat variables
2293
                {
2294
                  rdata.input.length = 0;
2295
                  rdata.input.cursorpos = 0;
2296
                  rdata.buffer.edited = 0;
2297

    
2298
                  // if the input buffer can hold historic entries
2299
                  if (((aos_shell_t*)shell)->input.nentries > 1) {
2300
                    // iterate in the history only if
2301
                    // there was some valid input and
2302
                    // the user did not execute the exact previous command again
2303
                    if (nargs > 0 &&
2304
                        strcmp(line, _getRelativeEntry((aos_shell_t*)shell, &rdata, 1)) != 0) {
2305
                      rdata.buffer.current = (rdata.buffer.current + 1) % ((aos_shell_t*)shell)->input.nentries;
2306
                    }
2307
                    // clear and select next (now current) entry
2308
                    memset(_getCurrentEntry((aos_shell_t*)shell, &rdata), '\0', ((aos_shell_t*)shell)->input.linewidth * sizeof(char));
2309
                    rdata.buffer.selected = 1;
2310
                  }
2311
                  // if there is only a single entry in the input buffer
2312
                  else {
2313
                    // do not clear/reset the entry, but start off with a cleared preview
2314
                    rdata.buffer.selected = 0;
2315
                  }
2316
                }
2317
              }
2318

    
2319
              // print a new prompt
2320
              if (!chThdShouldTerminateX()) {
2321
                _printPrompt((aos_shell_t*)shell);
2322
              }
2323
            }
2324
          }
2325

    
2326
          // iterate to next channel
2327
          channel = channel->next;
2328
        }
2329
        break;
2330
      }
2331

    
2332
      // other events
2333
      default:
2334
      {
2335
        // print an error message
2336
        chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "\nSHELL: ERROR: unknown event received (0x%08X)\n", eventmask);
2337
        break;
2338
      }
2339

    
2340
    } /* end of switch */
2341

    
2342
  } /* end of while */
2343

    
2344
  // fire event and exit the thread
2345
  chSysLock();
2346
  chEvtBroadcastFlagsI(&(((aos_shell_t*)shell)->eventSource), AOS_SHELL_EVTFLAG_EXIT);
2347
  chThdExitS(MSG_OK);
2348
  // no chSysUnlock() required since the thread has been terminated an all waiting threads have been woken up
2349
}
2350

    
2351
#endif /* (AMIROOS_CFG_SHELL_ENABLE == true) */
2352

    
2353
/** @} */