Statistics
| Branch: | Tag: | Revision:

amiro-os / core / src / aos_shell.c @ 10fd7ac9

History | View | Annotate | Download (54.8 KB)

1
/*
2
AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.
3
Copyright (C) 2016..2019  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   Event mask to be set on OS related events.
39
 */
40
#define AOS_SHELL_EVENTMASK_OS                  EVENT_MASK(0)
41

    
42
/**
43
 * @brief   Event mask to be set on a input event.
44
 */
45
#define AOS_SHELL_EVENTMASK_INPUT               EVENT_MASK(1)
46

    
47
/******************************************************************************/
48
/* EXPORTED VARIABLES                                                         */
49
/******************************************************************************/
50

    
51
/******************************************************************************/
52
/* LOCAL TYPES                                                                */
53
/******************************************************************************/
54

    
55
/*
56
 * forward declarations
57
 */
58
static size_t _channelwrite(void *instance, const uint8_t *bp, size_t n);
59
static size_t _channelread(void *instance, uint8_t *bp, size_t n);
60
static msg_t _channelput(void *instance, uint8_t b);
61
static msg_t _channelget(void *instance);
62
static msg_t _channelputt(void *instance, uint8_t b, sysinterval_t time);
63
static msg_t _channelgett(void *instance, sysinterval_t time);
64
static size_t _channelwritet(void *instance, const uint8_t *bp, size_t n, sysinterval_t time);
65
static size_t _channelreadt(void *instance, uint8_t *bp, size_t n, sysinterval_t time);
66
static msg_t _channelctl(void *instance, unsigned int operation, void *arg);
67
static size_t _streamwrite(void *instance, const uint8_t *bp, size_t n);
68
static size_t _stremread(void *instance, uint8_t *bp, size_t n);
69
static msg_t _streamput(void *instance, uint8_t b);
70
static msg_t _streamget(void *instance);
71

    
72
static const struct AosShellChannelVMT _channelvmt = {
73
  (size_t) 0,
74
  _channelwrite,
75
  _channelread,
76
  _channelput,
77
  _channelget,
78
  _channelputt,
79
  _channelgett,
80
  _channelwritet,
81
  _channelreadt,
82
  _channelctl,
83
};
84

    
85
static const struct AosShellStreamVMT _streamvmt = {
86
  (size_t) 0,
87
  _streamwrite,
88
  _stremread,
89
  _streamput,
90
  _streamget,
91
};
92

    
93
/**
94
 * @brief   Enumerator of special keyboard keys.
95
 */
96
typedef enum special_key {
97
  KEY_UNKNOWN,          /**< any/unknow key */
98
  KEY_AMBIGUOUS,        /**< key is ambiguous */
99
  KEY_TAB,              /**< tabulator key */
100
  KEY_ESCAPE,           /**< escape key */
101
  KEY_BACKSPACE,        /**< backspace key */
102
  KEY_INSERT,           /**< insert key */
103
  KEY_DELETE,           /**< delete key */
104
  KEY_HOME,             /**< home key */
105
  KEY_END,              /**< end key */
106
  KEY_PAGE_UP,          /**< page up key */
107
  KEY_PAGE_DOWN,        /**< page down key */
108
  KEY_ARROW_UP,         /**< arrow up key */
109
  KEY_ARROW_DOWN,       /**< arrow down key */
110
  KEY_ARROW_LEFT,       /**< arrow left key */
111
  KEY_ARROW_RIGHT,      /**< arrow right key */
112
  KEY_CTRL_ARROW_UP,    /**< CTRL + arrow up key */
113
  KEY_CTRL_ARROW_DOWN,  /**< CTRL + arrow down key */
114
  KEY_CTRL_ARROW_LEFT,  /**< CTRL + arrow left key */
115
  KEY_CTRL_ARROW_RIGHT, /**< CTRL + arrow right key */
116
} special_key_t;
117

    
118
/**
119
 * @brief   Enumerator for case (in)sensitive character matching.
120
 */
121
typedef enum charmatch {
122
  CHAR_MATCH_NOT    = 0,  /**< Characters do not match at all. */
123
  CHAR_MATCH_NCASE  = 1,  /**< Characters would match case insensitive. */
124
  CHAR_MATCH_CASE   = 2,  /**< Characters do match with case. */
125
} charmatch_t;
126

    
127
/******************************************************************************/
128
/* LOCAL VARIABLES                                                            */
129
/******************************************************************************/
130

    
131
/******************************************************************************/
132
/* LOCAL FUNCTIONS                                                            */
133
/******************************************************************************/
134

    
135
/**
136
 * @brief   Implementation of the BaseAsynchronous write() method (inherited from BaseSequentialStream).
137
 */
138
static size_t _channelwrite(void *instance, const uint8_t *bp, size_t n)
139
{
140
  if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_OUTPUT_ENABLED) {
141
    return streamWrite(((AosShellChannel*)instance)->asyncchannel, bp, n);
142
  } else {
143
    return 0;
144
  }
145
}
146

    
147
/**
148
 * @brief   Implementation of the BaseAsynchronous read() method (inherited from BaseSequentialStream).
149
 */
150
static size_t _channelread(void *instance, uint8_t *bp, size_t n)
151
{
152
  if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_INPUT_ENABLED) {
153
    return streamRead(((AosShellChannel*)instance)->asyncchannel, bp, n);
154
  } else {
155
    return 0;
156
  }
157
}
158

    
159
/**
160
 * @brief   Implementation of the BaseAsynchronous put() method (inherited from BaseSequentialStream).
161
 */
162
static msg_t _channelput(void *instance, uint8_t b)
163
{
164
  if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_OUTPUT_ENABLED) {
165
    return streamPut(((AosShellChannel*)instance)->asyncchannel, b);
166
  } else {
167
    return MSG_RESET;
168
  }
169
}
170

    
171
/**
172
 * @brief   Implementation of the BaseAsynchronous get() method (inherited from BaseSequentialStream).
173
 */
174
static msg_t _channelget(void *instance)
175
{
176
  if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_INPUT_ENABLED) {
177
    return streamGet(((AosShellChannel*)instance)->asyncchannel);
178
  } else {
179
    return MSG_RESET;
180
  }
181
}
182

    
183
/**
184
 * @brief   Implementation of the BaseAsynchronous putt() method.
185
 */
186
static msg_t _channelputt(void *instance, uint8_t b, sysinterval_t time)
187
{
188
  if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_OUTPUT_ENABLED) {
189
    return chnPutTimeout(((AosShellChannel*)instance)->asyncchannel, b, time);
190
  } else {
191
    return MSG_RESET;
192
  }
193
}
194

    
195
/**
196
 * @brief   Implementation of the BaseAsynchronous gett() method.
197
 */
198
static msg_t _channelgett(void *instance, sysinterval_t time)
199
{
200
  if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_INPUT_ENABLED) {
201
    return chnGetTimeout(((AosShellChannel*)instance)->asyncchannel, time);
202
  } else {
203
    return MSG_RESET;
204
  }
205
}
206

    
207
/**
208
 * @brief   Implementation of the BaseAsynchronous writet() method.
209
 */
210
static size_t _channelwritet(void *instance, const uint8_t *bp, size_t n, sysinterval_t time)
211
{
212
  if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_OUTPUT_ENABLED) {
213
    return chnWriteTimeout(((AosShellChannel*)instance)->asyncchannel, bp, n, time);
214
  } else {
215
    return 0;
216
  }
217
}
218

    
219
/**
220
 * @brief   Implementation of the BaseAsynchronous readt() method.
221
 */
222
static size_t _channelreadt(void *instance, uint8_t *bp, size_t n, sysinterval_t time)
223
{
224
  if (((AosShellChannel*)instance)->flags & AOS_SHELLCHANNEL_INPUT_ENABLED) {
225
    return chnReadTimeout(((AosShellChannel*)instance)->asyncchannel, bp, n, time);
226
  } else {
227
    return 0;
228
  }
229
}
230

    
231
/**
232
 * @brief   Implementation of the BaseAsynchronousChannel ctl() method.
233
 */
234
static msg_t _channelctl(void *instance, unsigned int operation, void *arg)
235
{
236
  (void) instance;
237

    
238
  switch (operation) {
239
  case CHN_CTL_NOP:
240
    osalDbgCheck(arg == NULL);
241
    break;
242
  case CHN_CTL_INVALID:
243
    osalDbgAssert(false, "invalid CTL operation");
244
    break;
245
  default:
246
    break;
247
  }
248
  return MSG_OK;
249
}
250

    
251
static size_t _streamwrite(void *instance, const uint8_t *bp, size_t n)
252
{
253
  aosDbgCheck(instance != NULL);
254

    
255
  // local variables
256
  AosShellChannel* channel = ((AosShellStream*)instance)->channel;
257
  size_t bytes;
258
  size_t maxbytes = 0;
259

    
260
  // iterate through the list of channels
261
  while (channel != NULL) {
262
    bytes = streamWrite(channel, bp, n);
263
    maxbytes = (bytes > maxbytes) ? bytes : maxbytes;
264
    channel = channel->next;
265
  }
266

    
267
  return maxbytes;
268
}
269

    
270
static size_t _stremread(void *instance, uint8_t *bp, size_t n)
271
{
272
  (void)instance;
273
  (void)bp;
274
  (void)n;
275

    
276
  return 0;
277
}
278

    
279
static msg_t _streamput(void *instance, uint8_t b)
280
{
281
  aosDbgCheck(instance != NULL);
282

    
283
  // local variables
284
  AosShellChannel* channel = ((AosShellStream*)instance)->channel;
285
  msg_t ret = MSG_OK;
286

    
287
  // iterate through the list of channels
288
  while (channel != NULL) {
289
    msg_t ret_ = streamPut(channel, b);
290
    ret = (ret_ < ret) ? ret_ : ret;
291
    channel = channel->next;
292
  }
293

    
294
  return ret;
295
}
296

    
297
static msg_t _streamget(void *instance)
298
{
299
  (void)instance;
300

    
301
  return 0;
302
}
303

    
304
/**
305
 * @brief   Print the shell prompt
306
 * @details Depending on the configuration flags, the system uptime is printed before the prompt string.
307
 *
308
 * @param[in] shell   Pointer to the shell object.
309
 */
310
static void _printPrompt(aos_shell_t* shell)
311
{
312
  aosDbgCheck(shell != NULL);
313

    
314
  // print some time informattion before prompt if configured
315
  if (shell->config & (AOS_SHELL_CONFIG_PROMPT_UPTIME | AOS_SHELL_CONFIG_PROMPT_DATETIME)) {
316
    // printf the system uptime
317
    if ((shell->config & (AOS_SHELL_CONFIG_PROMPT_UPTIME | AOS_SHELL_CONFIG_PROMPT_DATETIME)) == AOS_SHELL_CONFIG_PROMPT_UPTIME) {
318
      // get current system uptime
319
      aos_timestamp_t uptime;
320
      aosSysGetUptime(&uptime);
321

    
322
      chprintf((BaseSequentialStream*)&shell->stream, "[%01u:%02u:%02u:%02u:%03u:%03u] ",
323
               (uint32_t)(uptime / MICROSECONDS_PER_DAY),
324
               (uint8_t)(uptime % MICROSECONDS_PER_DAY / MICROSECONDS_PER_HOUR),
325
               (uint8_t)(uptime % MICROSECONDS_PER_HOUR / MICROSECONDS_PER_MINUTE),
326
               (uint8_t)(uptime % MICROSECONDS_PER_MINUTE / MICROSECONDS_PER_SECOND),
327
               (uint16_t)(uptime % MICROSECONDS_PER_SECOND / MICROSECONDS_PER_MILLISECOND),
328
               (uint16_t)(uptime % MICROSECONDS_PER_MILLISECOND / MICROSECONDS_PER_MICROSECOND));
329
    }
330
#if (HAL_USE_RTC == TRUE)
331
    else if ((shell->config & (AOS_SHELL_CONFIG_PROMPT_UPTIME | AOS_SHELL_CONFIG_PROMPT_DATETIME)) == AOS_SHELL_CONFIG_PROMPT_DATETIME) {
332
      // get current RTC time
333
      struct tm dt;
334
      aosSysGetDateTime(&dt);
335
      chprintf((BaseSequentialStream*)&shell->stream, "[%02u-%02u-%04u|%02u:%02u:%02u] ",
336
               dt.tm_mday,
337
               dt.tm_mon + 1,
338
               dt.tm_year + 1900,
339
               dt.tm_hour,
340
               dt.tm_min,
341
               dt.tm_sec);
342
    }
343
#endif /* (HAL_USE_RTC == TRUE) */
344
    else {
345
      aosDbgAssert(false);
346
    }
347
  }
348

    
349
  // print the actual prompt string
350
  if (shell->prompt && !(shell->config & AOS_SHELL_CONFIG_PROMPT_MINIMAL)) {
351
    chprintf((BaseSequentialStream*)&shell->stream, "%s$ ", shell->prompt);
352
  } else {
353
    chprintf((BaseSequentialStream*)&shell->stream, "%>$ ");
354
  }
355

    
356
  return;
357
}
358

    
359
/**
360
 * @brief   Interprete a escape sequence
361
 * @details This function interpretes escape sequences (starting with ASCII
362
 *          "Escape" character 0x1B) according to the VT100 / VT52 ANSI escape
363
 *          sequence definitions.
364
 * @note    Only the most important escape sequences are implemented yet.
365
 *
366
 * @param[in] seq   Character sequence to interprete.
367
 *                  Must be terminated by NUL byte.
368
 *
369
 * @return          A @p special_key value.
370
 */
371
static special_key_t _interpreteEscapeSequence(const char seq[])
372
{
373
  // local variables
374
  char str[AOS_SHELL_ESCSEQUENCE_LENGTH];
375
  unsigned long strl = 0;
376
  const unsigned long seql = strlen(seq);
377
  bool ambiguous = false;
378

    
379
  // TAB
380
  /* not supported yet; use "\x09" instead */
381

    
382
  // BACKSPACE
383
  /* not supported yet; use "\x08" instead */
384

    
385
  // ESCAPE
386
  strncpy(str, "\x1B", AOS_SHELL_ESCSEQUENCE_LENGTH);
387
  strl = strlen(str);
388
  if (seql == strl && strncmp(seq, str, seql) == 0) {
389
    return KEY_ESCAPE;
390
  } else if(seql < strl && strncmp(seq, str, seql) == 0) {
391
    ambiguous = true;
392
  }
393

    
394
  // INSERT
395
  strncpy(str, "\x1B\x5B\x32\x7E", AOS_SHELL_ESCSEQUENCE_LENGTH);
396
  strl = strlen(str);
397
  if (seql == strl && strncmp(seq, str, seql) == 0) {
398
    return KEY_INSERT;
399
  } else if(seql < strl && strncmp(seq, str, seql) == 0) {
400
    ambiguous = true;
401
  }
402

    
403
  // DELETE
404
  strncpy(str, "\x1B\x5B\x33\x7E", AOS_SHELL_ESCSEQUENCE_LENGTH);
405
  strl = strlen(str);
406
  if (seql == strl && strncmp(seq, str, seql) == 0) {
407
    return KEY_DELETE;
408
  } else if(seql < strl && strncmp(seq, str, seql) == 0) {
409
    ambiguous = true;
410
  }
411

    
412
  // HOME
413
  strncpy(str, "\x1B\x5B\x48", AOS_SHELL_ESCSEQUENCE_LENGTH);
414
  strl = strlen(str);
415
  if (seql == strl && strncmp(seq, str, seql) == 0) {
416
    return KEY_HOME;
417
  } else if(seql < strl && strncmp(seq, str, seql) == 0) {
418
    ambiguous = true;
419
  }
420

    
421
  // END
422
  strncpy(str, "\x1B\x5B\x46", AOS_SHELL_ESCSEQUENCE_LENGTH);
423
  strl = strlen(str);
424
  if (seql == strl && strncmp(seq, str, seql) == 0) {
425
    return KEY_END;
426
  } else if(seql < strl && strncmp(seq, str, seql) == 0) {
427
    ambiguous = true;
428
  }
429

    
430
  // PAGE UP
431
  strncpy(str, "\x1B\x5B\x35\x7E", AOS_SHELL_ESCSEQUENCE_LENGTH);
432
  strl = strlen(str);
433
  if (seql == strl && strncmp(seq, str, seql) == 0) {
434
    return KEY_PAGE_UP;
435
  } else if(seql < strl && strncmp(seq, str, seql) == 0) {
436
    ambiguous = true;
437
  }
438

    
439
  // PAGE DOWN
440
  strncpy(str, "\x1B\x5B\x36\x7E", AOS_SHELL_ESCSEQUENCE_LENGTH);
441
  strl = strlen(str);
442
  if (seql == strl && strncmp(seq, str, seql) == 0) {
443
    return KEY_PAGE_DOWN;
444
  } else if(seql < strl && strncmp(seq, str, seql) == 0) {
445
    ambiguous = true;
446
  }
447

    
448
  // ARROW UP
449
  strncpy(str, "\x1B\x5B\x41", AOS_SHELL_ESCSEQUENCE_LENGTH);
450
  strl = strlen(str);
451
  if (seql == strl && strncmp(seq, str, seql) == 0) {
452
    return KEY_ARROW_UP;
453
  } else if(seql < strl && strncmp(seq, str, seql) == 0) {
454
    ambiguous = true;
455
  }
456

    
457
  // ARROW DOWN
458
  strncpy(str, "\x1B\x5B\x42", AOS_SHELL_ESCSEQUENCE_LENGTH);
459
  strl = strlen(str);
460
  if (seql == strl && strncmp(seq, str, seql) == 0) {
461
    return KEY_ARROW_DOWN;
462
  } else if (seql < strl && strncmp(seq, str, seql) == 0) {
463
    ambiguous = true;
464
  }
465

    
466
  // ARROW LEFT
467
  strncpy(str, "\x1B\x5B\x44", AOS_SHELL_ESCSEQUENCE_LENGTH);
468
  strl = strlen(str);
469
  if (seql == strl && strncmp(seq, str, seql) == 0) {
470
    return KEY_ARROW_LEFT;
471
  } else if (seql < strl && strncmp(seq, str, seql) == 0) {
472
    ambiguous = true;
473
  }
474

    
475
  // ARROW RIGHT
476
  strncpy(str, "\x1B\x5B\x43", AOS_SHELL_ESCSEQUENCE_LENGTH);
477
  strl = strlen(str);
478
  if (seql == strl && strncmp(seq, str, seql) == 0) {
479
    return KEY_ARROW_RIGHT;
480
  } else if (seql < strl && strncmp(seq, str, seql) == 0) {
481
    ambiguous = true;
482
  }
483

    
484
  // CTRL + ARROW UP
485
  strncpy(str, "\x1B\x5B\x31\x3B\x35\x41", AOS_SHELL_ESCSEQUENCE_LENGTH);
486
  strl = strlen(str);
487
  if (seql == strl && strncmp(seq, str, seql) == 0) {
488
    return KEY_CTRL_ARROW_UP;
489
  } else if(seql < strl && strncmp(seq, str, seql) == 0) {
490
    ambiguous = true;
491
  }
492

    
493
  // CTRL + ARROW DOWN
494
  strncpy(str, "\x1B\x5B\x31\x3B\x35\x42", AOS_SHELL_ESCSEQUENCE_LENGTH);
495
  strl = strlen(str);
496
  if (seql == strl && strncmp(seq, str, seql) == 0) {
497
    return KEY_CTRL_ARROW_DOWN;
498
  } else if(seql < strl && strncmp(seq, str, seql) == 0) {
499
    ambiguous = true;
500
  }
501

    
502
  // CTRL + ARROW LEFT
503
  strncpy(str, "\x1B\x5B\x31\x3B\x35\x44", AOS_SHELL_ESCSEQUENCE_LENGTH);
504
  strl = strlen(str);
505
  if (seql == strl && strncmp(seq, str, seql) == 0) {
506
    return KEY_CTRL_ARROW_LEFT;
507
  } else if(seql < strl && strncmp(seq, str, seql) == 0) {
508
    ambiguous = true;
509
  }
510

    
511
  // CTRL + ARROW RIGHT
512
  strncpy(str, "\x1B\x5B\x31\x3B\x35\x43", AOS_SHELL_ESCSEQUENCE_LENGTH);
513
  strl = strlen(str);
514
  if (seql == strl && strncmp(seq, str, seql) == 0) {
515
    return KEY_CTRL_ARROW_RIGHT;
516
  } else if(seql < strl && strncmp(seq, str, seql) == 0) {
517
    ambiguous = true;
518
  }
519

    
520
  return ambiguous ? KEY_AMBIGUOUS : KEY_UNKNOWN;
521
}
522

    
523
/**
524
 * @brief   Move the cursor in the terminal
525
 *
526
 * @param[in] shell   Pointer to the shell object.
527
 * @param[in] from    Starting position of the cursor.
528
 * @param[in] to      Target position to move the cursor to.
529
 *
530
 * @return            The number of positions moved.
531
 */
532
static int _moveCursor(aos_shell_t* shell, const size_t from, const size_t to)
533
{
534
  aosDbgCheck(shell != NULL);
535

    
536
  // local variables
537
  size_t pos = from;
538

    
539
  // move cursor left by printing backspaces
540
  while (pos > to) {
541
    streamPut(&shell->stream, '\b');
542
    --pos;
543
  }
544

    
545
  // move cursor right by printing line content
546
  while (pos < to) {
547
    streamPut(&shell->stream, (uint8_t)shell->input.line[pos]);
548
    ++pos;
549
  }
550

    
551
  return (int)pos - (int)from;
552
}
553

    
554
/**
555
 * @brief   Print content of the shell line
556
 *
557
 * @param[in] shell   Pointer to the shell object.
558
 * @param[in] from    First position to start printing from.
559
 * @param[in] to      Position after the last character to print.
560
 *
561
 * @return            Number of characters printed.
562
 */
563
static inline size_t _printLine(aos_shell_t* shell, const size_t from, const size_t to)
564
{
565
  aosDbgCheck(shell != NULL);
566

    
567
  // local variables
568
  size_t cnt;
569

    
570
  for (cnt = 0; from + cnt < to; ++cnt) {
571
    streamPut(&shell->stream, (uint8_t)shell->input.line[from + cnt]);
572
  }
573

    
574
  return cnt;
575
}
576

    
577
static int _readChar(aos_shell_t* shell, const char c) {
578
  aosDbgCheck(shell != NULL);
579

    
580
  // check whether input line is already full
581
  if (shell->inputdata.lineend + 1 >= shell->input.length) {
582
    return 0;
583
  } else {
584
    // clear old line content on first input
585
    if (shell->inputdata.noinput) {
586
      memset(shell->input.line, '\0', shell->input.length);
587
      shell->inputdata.noinput = false;
588
    }
589
    // overwrite content
590
    if (shell->config & AOS_SHELL_CONFIG_INPUT_OVERWRITE) {
591
      shell->input.line[shell->inputdata.cursorpos] = c;
592
      ++shell->inputdata.cursorpos;
593
      shell->inputdata.lineend = (shell->inputdata.cursorpos > shell->inputdata.lineend) ? shell->inputdata.cursorpos : shell->inputdata.lineend;
594
      streamPut(&shell->stream, (uint8_t)c);
595
    }
596
    // insert character
597
    else {
598
      memmove(&(shell->input.line[shell->inputdata.cursorpos+1]), &(shell->input.line[shell->inputdata.cursorpos]), shell->inputdata.lineend - shell->inputdata.cursorpos);
599
      shell->input.line[shell->inputdata.cursorpos] = c;
600
      ++shell->inputdata.lineend;
601
      _printLine(shell, shell->inputdata.cursorpos, shell->inputdata.lineend);
602
      ++shell->inputdata.cursorpos;
603
      _moveCursor(shell, shell->inputdata.lineend, shell->inputdata.cursorpos);
604
    }
605
    return 1;
606
  }
607
}
608

    
609
/**
610
 * @brief   Compare two characters.
611
 *
612
 * @param[in] lhs       First character to compare.
613
 * @param[in] rhs       Second character to compare.
614
 *
615
 * @return              How well the characters match.
616
 */
617
static inline charmatch_t _charcmp(char lhs, char rhs)
618
{
619
  // if lhs is a upper case letter and rhs is a lower case letter
620
  if (lhs >= 'A' && lhs <= 'Z' && rhs >= 'a' && rhs <= 'z') {
621
    return (lhs == (rhs - 'a' + 'A')) ? CHAR_MATCH_NCASE : CHAR_MATCH_NOT;
622
  }
623
  // if lhs is a lower case letter and rhs is a upper case letter
624
  else if (lhs >= 'a' && lhs <= 'z' && rhs >= 'A' && rhs <= 'Z') {
625
    return ((lhs - 'a' + 'A') == rhs) ? CHAR_MATCH_NCASE : CHAR_MATCH_NOT;
626
  }
627
  // default
628
  else {
629
    return (lhs == rhs) ? CHAR_MATCH_CASE : CHAR_MATCH_NOT;
630
  }
631
}
632

    
633
/**
634
 * @brief   Maps an character from ASCII to a modified custom encoding.
635
 * @details The custom character encoding is very similar to ASCII and has the following structure:
636
 *          0x00=NULL ... 0x40='@' (identically to ASCII)
637
 *          0x4A='a'; 0x4B='A'; 0x4C='b'; 0x4D='B' ... 0x73='z'; 0x74='Z' (custom letter order)
638
 *          0x75='[' ... 0x7A='`' (0x5B..0x60 is ASCII)
639
 *          0x7B='{' ... 0x7F=DEL (identically to ASCII)
640
 *
641
 * @param[in] c   Character to map to the custom encoding.
642
 *
643
 * @return    The customly encoded character.
644
 */
645
static inline char _mapAscii2Custom(const char c)
646
{
647
  if (c >= 'A' && c <= 'Z') {
648
    return ((c - 'A') * 2) + 'A' + 1;
649
  } else if (c > 'Z' && c < 'a') {
650
    return c + ('z' - 'a') + 1;
651
  } else if (c >= 'a' && c <= 'z') {
652
    return ((c - 'a') * 2) + 'A';
653
  } else {
654
    return c;
655
  }
656
}
657

    
658
/**
659
 * @brief   Compares two strings wrt letter case.
660
 * @details Comparisson uses a custom character encoding or mapping.
661
 *          See @p _mapAscii2Custom for details.
662
 *
663
 * @param[in] str1    First string to compare.
664
 * @param[in] str2    Second string to compare.
665
 * @param[in] cs      Flag indicating whether comparison shall be case sensitive.
666
 * @param[in,out] n   Maximum number of character to compare (in) and number of matching characters (out).
667
 *                    If a null pointer is specified, this parameter is ignored.
668
 *                    If the value pointed to is zero, comarison will not be limited.
669
 * @param[out] m      Optional indicator whether there was at least one case mismatch.
670
 *
671
 * @return      Integer value indicating the relationship between the strings.
672
 * @retval <0   The first character that does not match has a lower value in str1 than in str2.
673
 * @retval  0   The contents of both strings are equal.
674
 * @retval >0   The first character that does not match has a greater value in str1 than in str2.
675
 */
676
static int _strccmp(const char *str1, const char *str2, bool cs, size_t* n, charmatch_t* m)
677
{
678
  aosDbgCheck(str1 != NULL);
679
  aosDbgCheck(str2 != NULL);
680

    
681
  // initialize variables
682
  if (m) {
683
    *m = CHAR_MATCH_NOT;
684
  }
685
  size_t i = 0;
686

    
687
  // iterate through the strings
688
  while ((n == NULL) || (*n == 0) || (*n > 0 && i < *n)) {
689
    // break on NUL
690
    if (str1[i] == '\0' || str2[i] == '\0') {
691
      if (n) {
692
        *n = i;
693
      }
694
      break;
695
    }
696
    // compare character
697
    const charmatch_t match = _charcmp(str1[i], str2[i]);
698
    if ((match == CHAR_MATCH_CASE) || (!cs && match == CHAR_MATCH_NCASE)) {
699
      if (m != NULL && *m != CHAR_MATCH_NCASE) {
700
        *m = match;
701
      }
702
      ++i;
703
    } else {
704
      if (n) {
705
        *n = i;
706
      }
707
      break;
708
    }
709
  }
710

    
711
  return _mapAscii2Custom(str1[i]) - _mapAscii2Custom(str2[i]);
712
}
713

    
714
/**
715
 * @brief   Read input from a channel as long as there is data available.
716
 *
717
 * @param[in]   shell     Pointer to the shell object.
718
 * @param[in]   channel   The channel to read from.
719
 * @param[out]  n         Pointer to a variable to store the number of read characters to.
720
 *
721
 * @return
722
 */
723
static aos_status_t _readChannel(aos_shell_t* shell, AosShellChannel* channel, size_t* n)
724
{
725
  aosDbgCheck(shell != NULL);
726
  aosDbgCheck(channel != NULL);
727
  aosDbgCheck(n != NULL);
728

    
729
  // local variables
730
  aos_shellaction_t action = AOS_SHELL_ACTION_NONE;
731
  char c;
732
  special_key_t key;
733

    
734
  // initialize output variables
735
  *n = 0;
736

    
737
  // read character by character from the channel
738
  while (chnReadTimeout(channel, (uint8_t*)&c, 1, TIME_IMMEDIATE)) {
739
    key = KEY_UNKNOWN;
740

    
741
    // parse escape sequence
742
    if (strlen(shell->inputdata.escseq) > 0) {
743
      shell->inputdata.escseq[strlen(shell->inputdata.escseq)] = c;
744
      key = _interpreteEscapeSequence(shell->inputdata.escseq);
745
      switch (key) {
746
        case KEY_AMBIGUOUS:
747
          // read next byte to resolve ambiguity
748
          continue;
749
        case KEY_UNKNOWN:
750
          // do nothing here, but handle the unknown sequence below
751
          break;
752
        default:
753
          // reset the sequence variable and buffer
754
          memset(shell->inputdata.escseq, '\0', sizeof(shell->inputdata.escseq)*sizeof(shell->inputdata.escseq[0]));
755
          break;
756
      }
757
    }
758

    
759
    /* interprete keys or character */
760
    {
761
      // default
762
      action = AOS_SHELL_ACTION_NONE;
763

    
764
      // printable character
765
      if (key == KEY_UNKNOWN && strlen(shell->inputdata.escseq) == 0 && c >= '\x20' && c <= '\x7E') {
766
        action = AOS_SHELL_ACTION_READCHAR;
767
      }
768

    
769
      // tab key or character
770
      else if (key == KEY_TAB || c == '\x09') {
771
        /*
772
         * pressing tab once applies auto fill
773
         * pressing tab a second time prints suggestions
774
         */
775
        if (shell->inputdata.lastaction == AOS_SHELL_ACTION_AUTOFILL || shell->inputdata.lastaction == AOS_SHELL_ACTION_SUGGEST) {
776
          action = AOS_SHELL_ACTION_SUGGEST;
777
        } else {
778
          action = AOS_SHELL_ACTION_AUTOFILL;
779
        }
780
      }
781

    
782
      // INS key
783
      else if (key == KEY_INSERT) {
784
        action = AOS_SHELL_ACTION_INSERTTOGGLE;
785
      }
786

    
787
      // DEL key or character
788
      else if (key == KEY_DELETE || c == '\x7F') {
789
        // ignore if cursor is at very right
790
        if (shell->inputdata.cursorpos < shell->inputdata.lineend) {
791
          action = AOS_SHELL_ACTION_DELETEFORWARD;
792
        }
793
      }
794

    
795
      // backspace key or character
796
      else if (key == KEY_BACKSPACE || c == '\x08') {
797
        // ignore if cursor is at very left
798
        if (shell->inputdata.cursorpos > 0) {
799
          action = AOS_SHELL_ACTION_DELETEBACKWARD;
800
        }
801
      }
802

    
803
      // 'page up', 'arrow up', or key or CTRL + 'arrow up' key combination
804
      else if (key == KEY_PAGE_UP || key == KEY_ARROW_UP || key == KEY_CTRL_ARROW_UP) {
805
        // ignore if there was some input
806
        if (shell->inputdata.noinput) {
807
          action = AOS_SHELL_ACTION_RECALLLAST;
808
        }
809
      }
810

    
811
      // 'page down' key, 'arrow down' key, 'end of test' character or 'end of transmission' character, or CTRL + 'arrow down' key combination
812
      else if (key == KEY_PAGE_DOWN || key == KEY_ARROW_DOWN || c == '\x03' || c == '\x03' || key == KEY_CTRL_ARROW_DOWN) {
813
        // ignore if line is empty
814
        if (shell->inputdata.lineend > 0) {
815
          action = AOS_SHELL_ACTION_CLEAR;
816
        }
817
      }
818

    
819
      // 'home' key
820
      else if (key == KEY_HOME) {
821
        // ignore if cursor is very left
822
        if (shell->inputdata.cursorpos > 0) {
823
          action = AOS_SHELL_ACTION_CURSOR2START;
824
        }
825
      }
826

    
827
      // 'end' key
828
      else if (key == KEY_END) {
829
        // ignore if cursos is very right
830
        if (shell->inputdata.cursorpos < shell->inputdata.lineend) {
831
          action = AOS_SHELL_ACTION_CURSOR2END;
832
        }
833
      }
834

    
835
      // 'arrow left' key
836
      else if (key == KEY_ARROW_LEFT) {
837
        // ignore if cursor is very left
838
        if (shell->inputdata.cursorpos > 0) {
839
          action = AOS_SHELL_ACTION_CURSORLEFT;
840
        }
841
      }
842

    
843
      // 'arrow right' key
844
      else if (key == KEY_ARROW_RIGHT) {
845
        // ignore if cursor is very right
846
        if (shell->inputdata.cursorpos < shell->inputdata.lineend) {
847
          action = AOS_SHELL_ACTION_CURSORRIGHT;
848
        }
849
      }
850

    
851
      // CTRL + 'arrow left' key combination
852
      else if (key == KEY_CTRL_ARROW_LEFT) {
853
        // ignore if cursor is very left
854
        if (shell->inputdata.cursorpos > 0) {
855
          action = AOS_SHELL_ACTION_CURSORWORDLEFT;
856
        }
857
      }
858

    
859
      // CTRL + 'arrow right' key combination
860
      else if (key == KEY_CTRL_ARROW_RIGHT) {
861
        // ignore if cursor is very right
862
        if (shell->inputdata.cursorpos < shell->inputdata.lineend) {
863
          action = AOS_SHELL_ACTION_CURSORWORDRIGHT;
864
        }
865
      }
866

    
867
      // carriage return ('\r') or line feed ('\n') character
868
      else if (c == '\x0D' || c == '\x0A') {
869
        action = AOS_SHELL_ACTION_EXECUTE;
870
      }
871

    
872
      // ESC key or [ESCAPE] character
873
      else if (key == KEY_ESCAPE || c == '\x1B') {
874
        action = AOS_SHELL_ACTION_ESCSTART;
875
      }
876

    
877
      // unknown escape sequence
878
      else if (key == KEY_UNKNOWN && strlen(shell->inputdata.escseq) > 0) {
879
        action = AOS_SHELL_ACTION_PRINTUNKNOWNSEQUENCE;
880
      }
881
    }
882

    
883
    /* handle function */
884
    switch (action) {
885
      case AOS_SHELL_ACTION_READCHAR:
886
      {
887
        if (_readChar(shell, c) == 0) {
888
          // line is full
889
          _moveCursor(shell, shell->inputdata.cursorpos, shell->inputdata.lineend);
890
          chprintf((BaseSequentialStream*)&shell->stream, "\n\tmaximum line width reached\n");
891
          _printPrompt(shell);
892
          _printLine(shell, 0, shell->inputdata.lineend);
893
          _moveCursor(shell, shell->inputdata.lineend, shell->inputdata.cursorpos);
894
        }
895
        break;
896
      }
897

    
898
      case AOS_SHELL_ACTION_AUTOFILL:
899
      {
900
        const char* fill = shell->input.line;
901
        size_t cmatch = shell->inputdata.cursorpos;
902
        charmatch_t matchlevel = CHAR_MATCH_NOT;
903
        size_t n;
904
        // iterate through command list
905
        for (aos_shellcommand_t* cmd = shell->commands; cmd != NULL; cmd = cmd->next) {
906
          // compare current match with command
907
          n = cmatch;
908
          charmatch_t mlvl = CHAR_MATCH_NOT;
909
          _strccmp(fill, cmd->name, shell->config & AOS_SHELL_CONFIG_MATCH_CASE, (n == 0) ? NULL : &n, &mlvl);
910
          const int cmp = (n < cmatch) ?
911
                            ((int)n - (int)cmatch) :
912
                            (cmd->name[n] != '\0') ?
913
                              (int)strlen(cmd->name) - (int)n :
914
                              0;
915
          // if an exact match was found
916
          if ((size_t)((int)cmatch + cmp) == shell->inputdata.cursorpos) {
917
            cmatch = shell->inputdata.cursorpos;
918
            fill = cmd->name;
919
            // break the loop only if there are no case mismatches with the input
920
            n = shell->inputdata.cursorpos;
921
            _strccmp(fill, shell->input.line, false, &n, &mlvl);
922
            if (mlvl == CHAR_MATCH_CASE) {
923
              break;
924
            }
925
          }
926
          // if a not exact match was found
927
          else if ((size_t)((int)cmatch + cmp) > shell->inputdata.cursorpos) {
928
            // if this is the first one
929
            if (fill == shell->input.line) {
930
              cmatch = (size_t)((int)cmatch + cmp);
931
              fill = cmd->name;
932
            }
933
            // if this is a worse one
934
            else if ((cmp < 0) || (cmp == 0 && mlvl == CHAR_MATCH_CASE)) {
935
              cmatch = (size_t)((int)cmatch + cmp);
936
            }
937
          }
938
          // non matching commands are ignored
939
          else {}
940
        }
941
        // evaluate if there are case mismatches
942
        n = cmatch;
943
        _strccmp(shell->input.line, fill, shell->config & AOS_SHELL_CONFIG_MATCH_CASE, &n, &matchlevel);
944
        // print the auto fill if any
945
        if (cmatch > shell->inputdata.cursorpos || (cmatch == shell->inputdata.cursorpos && matchlevel == CHAR_MATCH_NCASE)) {
946
          shell->inputdata.noinput = false;
947
          // limit auto fill so it will not overflow the line width
948
          if (shell->inputdata.lineend + (cmatch - shell->inputdata.cursorpos) > shell->input.length) {
949
            cmatch = shell->input.length - shell->inputdata.lineend + shell->inputdata.cursorpos;
950
          }
951
          // move trailing memory further in the line
952
          memmove(&(shell->input.line[cmatch]), &(shell->input.line[shell->inputdata.cursorpos]), shell->inputdata.lineend - shell->inputdata.cursorpos);
953
          shell->inputdata.lineend += cmatch - shell->inputdata.cursorpos;
954
          // if there was no incorrect case when matching
955
          if (matchlevel == CHAR_MATCH_CASE) {
956
            // insert fill command name to line
957
            memcpy(&(shell->input.line[shell->inputdata.cursorpos]), &(fill[shell->inputdata.cursorpos]), cmatch - shell->inputdata.cursorpos);
958
            // print the output
959
            _printLine(shell, shell->inputdata.cursorpos, shell->inputdata.lineend);
960
          } else {
961
            // overwrite line with fill command name
962
            memcpy(shell->input.line, fill, cmatch);
963
            // reprint the whole line
964
            _moveCursor(shell, shell->inputdata.cursorpos, 0);
965
            _printLine(shell, 0, shell->inputdata.lineend);
966
          }
967
          // move cursor to the end of the matching sequence
968
          shell->inputdata.cursorpos = cmatch;
969
          _moveCursor(shell, shell->inputdata.lineend, shell->inputdata.cursorpos);
970
        }
971
        break;
972
      }
973

    
974
      case AOS_SHELL_ACTION_SUGGEST:
975
      {
976
        unsigned int matches = 0;
977
        // iterate through command list
978
        for (aos_shellcommand_t* cmd = shell->commands; cmd != NULL; cmd = cmd->next) {
979
          // compare line content with command, excpet if cursorpos=0
980
          size_t i = shell->inputdata.cursorpos;
981
          if (shell->inputdata.cursorpos > 0) {
982
            _strccmp(shell->input.line, cmd->name, true, &i, NULL);
983
          }
984
          const int cmp = (i < shell->inputdata.cursorpos) ?
985
                            (int)(i - shell->inputdata.cursorpos) :
986
                            (cmd->name[i] != '\0') ?
987
                              (int)strlen(cmd->name) - (int)i :
988
                              0;
989
          // if a match was found
990
          if (cmp > 0) {
991
            // if this is the first one
992
            if (matches == 0) {
993
              _moveCursor(shell, shell->inputdata.cursorpos, shell->inputdata.lineend);
994
              streamPut(&shell->stream, '\n');
995
            }
996
            // print the command
997
            chprintf((BaseSequentialStream*)&shell->stream, "\t%s\n", cmd->name);
998
            ++matches;
999
          }
1000
        }
1001
        // reprint the prompt and line if any matches have been found
1002
        if (matches > 0) {
1003
          _printPrompt(shell);
1004
          _printLine(shell, 0, shell->inputdata.lineend);
1005
          _moveCursor(shell, shell->inputdata.lineend, shell->inputdata.cursorpos);
1006
          shell->inputdata.noinput = false;
1007
        }
1008
        break;
1009
      }
1010

    
1011
      case AOS_SHELL_ACTION_INSERTTOGGLE:
1012
      {
1013
        if (shell->config & AOS_SHELL_CONFIG_INPUT_OVERWRITE) {
1014
          shell->config &= ~AOS_SHELL_CONFIG_INPUT_OVERWRITE;
1015
        } else {
1016
          shell->config |= AOS_SHELL_CONFIG_INPUT_OVERWRITE;
1017
        }
1018
        break;
1019
      }
1020

    
1021
      case AOS_SHELL_ACTION_DELETEFORWARD:
1022
      {
1023
        --shell->inputdata.lineend;
1024
        memmove(&(shell->input.line[shell->inputdata.cursorpos]), &(shell->input.line[shell->inputdata.cursorpos+1]), shell->inputdata.lineend - shell->inputdata.cursorpos);
1025
        _printLine(shell, shell->inputdata.cursorpos, shell->inputdata.lineend);
1026
        streamPut(&shell->stream, ' ');
1027
        _moveCursor(shell, shell->inputdata.lineend + 1, shell->inputdata.cursorpos);
1028
        break;
1029
      }
1030

    
1031
      case AOS_SHELL_ACTION_DELETEBACKWARD:
1032
      {
1033
        --shell->inputdata.cursorpos;
1034
        memmove(&(shell->input.line[shell->inputdata.cursorpos]), &(shell->input.line[shell->inputdata.cursorpos+1]), shell->inputdata.lineend - shell->inputdata.cursorpos);
1035
        --shell->inputdata.lineend;
1036
        shell->input.line[shell->inputdata.lineend] = '\0';
1037
        _moveCursor(shell, shell->inputdata.cursorpos + 1, shell->inputdata.cursorpos);
1038
        _printLine(shell, shell->inputdata.cursorpos, shell->inputdata.lineend);
1039
        streamPut(&shell->stream, ' ');
1040
        _moveCursor(shell, shell->inputdata.lineend+1, shell->inputdata.cursorpos);
1041
        break;
1042
      }
1043

    
1044
      case AOS_SHELL_ACTION_RECALLLAST:
1045
      {
1046
        // replace any intermediate NUL bytes with spaces
1047
        shell->inputdata.lineend = 0;
1048
        size_t nul_start = 0;
1049
        size_t nul_end = 0;
1050
        // search line for a NUL byte
1051
        while (nul_start < shell->input.length) {
1052
          if (shell->input.line[nul_start] == '\0') {
1053
            nul_end = nul_start + 1;
1054
            // keep searcjing for a byte that is not NUL
1055
            while (nul_end < shell->input.length) {
1056
              if (shell->input.line[nul_end] != '\0') {
1057
                // an intermediate NUL sequence was found
1058
                memset(&(shell->input.line[nul_start]), ' ', nul_end - nul_start);
1059
                shell->inputdata.lineend = nul_end + 1;
1060
                break;
1061
              } else {
1062
                ++nul_end;
1063
              }
1064
            }
1065
            nul_start = nul_end + 1;
1066
          } else {
1067
            ++shell->inputdata.lineend;
1068
            ++nul_start;
1069
          }
1070
        }
1071
        shell->inputdata.cursorpos = shell->inputdata.lineend;
1072
        // print the line
1073
        shell->inputdata.noinput = _printLine(shell, 0, shell->inputdata.lineend) == 0;
1074
        break;
1075
      }
1076

    
1077
      case AOS_SHELL_ACTION_CLEAR:
1078
      {
1079
        // clear output
1080
        _moveCursor(shell, shell->inputdata.cursorpos, 0);
1081
        for (shell->inputdata.cursorpos = 0; shell->inputdata.cursorpos < shell->inputdata.lineend; ++shell->inputdata.cursorpos) {
1082
          streamPut(&shell->stream, ' ');
1083
        }
1084
        _moveCursor(shell, shell->inputdata.lineend, 0);
1085
        shell->inputdata.cursorpos = 0;
1086
        shell->inputdata.lineend = 0;
1087
        shell->inputdata.noinput = true;
1088
        break;
1089
      }
1090

    
1091
      case AOS_SHELL_ACTION_CURSOR2START:
1092
      {
1093
        _moveCursor(shell, shell->inputdata.cursorpos, 0);
1094
        shell->inputdata.cursorpos = 0;
1095
        break;
1096
      }
1097

    
1098
      case AOS_SHELL_ACTION_CURSOR2END:
1099
      {
1100
        _moveCursor(shell, shell->inputdata.cursorpos, shell->inputdata.lineend);
1101
        shell->inputdata.cursorpos = shell->inputdata.lineend;
1102
        break;
1103
      }
1104

    
1105
      case AOS_SHELL_ACTION_CURSORLEFT:
1106
      {
1107
        _moveCursor(shell, shell->inputdata.cursorpos, shell->inputdata.cursorpos-1);
1108
        --shell->inputdata.cursorpos;
1109
        break;
1110
      }
1111

    
1112
      case AOS_SHELL_ACTION_CURSORRIGHT:
1113
      {
1114
        _moveCursor(shell, shell->inputdata.cursorpos, shell->inputdata.cursorpos+1);
1115
        ++shell->inputdata.cursorpos;
1116
        break;
1117
      }
1118

    
1119
      case AOS_SHELL_ACTION_CURSORWORDLEFT:
1120
      {
1121
        size_t cpos = shell->inputdata.cursorpos;
1122
        while (cpos > 0 && shell->input.line[cpos-1] == ' ') {
1123
          --cpos;
1124
        }
1125
        while (cpos > 0 && shell->input.line[cpos-1] != ' ') {
1126
          --cpos;
1127
        }
1128
        _moveCursor(shell, shell->inputdata.cursorpos, cpos);
1129
        shell->inputdata.cursorpos = cpos;
1130
        break;
1131
      }
1132

    
1133
      case AOS_SHELL_ACTION_CURSORWORDRIGHT:
1134
      {
1135
        size_t cpos = shell->inputdata.cursorpos;
1136
        while (cpos < shell->inputdata.lineend && shell->input.line[cpos] != ' ') {
1137
          ++cpos;
1138
        }
1139
        while (cpos < shell->inputdata.lineend && shell->input.line[cpos] == ' ') {
1140
          ++cpos;
1141
        }
1142
        _moveCursor(shell, shell->inputdata.cursorpos, cpos);
1143
        shell->inputdata.cursorpos = cpos;
1144
        break;
1145
      }
1146

    
1147
      case AOS_SHELL_ACTION_EXECUTE:
1148
      {
1149
        streamPut(&shell->stream, '\n');
1150
        // set the number of read bytes and return
1151
        if (!shell->inputdata.noinput) {
1152
          *n = shell->input.length - shell->inputdata.lineend;
1153
          // fill the remainder of the line with NUL bytes
1154
          memset(&(shell->input.line[shell->inputdata.lineend]), '\0', *n);
1155
          // reset static variables
1156
          shell->inputdata.noinput = true;
1157
        }
1158
        return AOS_SUCCESS;
1159
      }
1160

    
1161
      case AOS_SHELL_ACTION_ESCSTART:
1162
      {
1163
        shell->inputdata.escseq[0] = c;
1164
        break;
1165
      }
1166

    
1167
      case AOS_SHELL_ACTION_PRINTUNKNOWNSEQUENCE:
1168
      {
1169
        size_t seqc = 1; // element 0 would be unprintible ESC character
1170
        while (shell->inputdata.escseq[seqc] != '\0') {
1171
          _readChar(shell, shell->inputdata.escseq[seqc]);
1172
          ++seqc;
1173
        }
1174
        memset(shell->inputdata.escseq, '\0', sizeof(shell->inputdata.escseq)*sizeof(shell->inputdata.escseq[0]));
1175
        break;
1176
      }
1177

    
1178
      case AOS_SHELL_ACTION_NONE:
1179
      {
1180
        // do nothing (ignore input) and read next byte
1181
        continue;
1182
      }
1183
    } /* end of switch */
1184

    
1185
    shell->inputdata.lastaction = action;
1186
  } /* end of while */
1187

    
1188
  // no more data could be read from the channel
1189
  return AOS_WARNING;
1190
}
1191

    
1192
/**
1193
 * @brief   Parses the content of the input buffer (line) to separate arguments.
1194
 *
1195
 * @param[in]   shell   Pointer to the shell object.
1196
 * @param[out]  argbuf  Buffer to store argument pointers to.
1197
 *
1198
 * @return            Number of arguments found.
1199
 */
1200
static size_t _parseArguments(aos_shell_t* shell, char** argbuf)
1201
{
1202
  aosDbgCheck(shell != NULL);
1203
  aosDbgCheck(argbuf != NULL);
1204

    
1205
  /*
1206
   * States for a very small FSM.
1207
   */
1208
  typedef enum {
1209
    START,
1210
    SPACE,
1211
    TEXT,
1212
    END,
1213
  } state_t;
1214

    
1215
  // local variables
1216
  state_t state = START;
1217
  size_t nargs = 0;
1218

    
1219
  // iterate through the line
1220
  for (char* c = shell->input.line; c < shell->input.line + shell->input.length; ++c) {
1221
    // terminate at first NUL byte
1222
    if (*c == '\0') {
1223
      state = END;
1224
      break;
1225
    }
1226
    // spaces become NUL bytes
1227
    else if (*c == ' ') {
1228
      *c = '\0';
1229
      state = SPACE;
1230
    }
1231
    // handle non-NUL bytes
1232
    else {
1233
      switch (state) {
1234
        case START:
1235
        case SPACE:
1236
          // ignore too many arguments
1237
          if (nargs < shell->input.nargs) {
1238
            argbuf[nargs] = c;
1239
          }
1240
          ++nargs;
1241
          break;
1242
        case TEXT:
1243
        case END:
1244
          break;
1245
      }
1246
      state = TEXT;
1247
    }
1248
  }
1249

    
1250
  // set all remaining argument pointers to NULL
1251
  for (size_t a = nargs; a < shell->input.nargs; ++a) {
1252
    argbuf[a] = NULL;
1253
  }
1254

    
1255
  return nargs;
1256
}
1257

    
1258
/******************************************************************************/
1259
/* EXPORTED FUNCTIONS                                                         */
1260
/******************************************************************************/
1261

    
1262
/**
1263
 * @brief   Initializes a shell object with the specified parameters.
1264
 *
1265
 * @param[in] shell         Pointer to the shell object.
1266
 * @param[in] stream        I/O stream to use.
1267
 * @param[in] prompt        Prompt line to print (NULL = use default prompt).
1268
 * @param[in] line          Pointer to the input buffer.
1269
 * @param[in] linesize      Size of the input buffer.
1270
 * @param[in] numargs       Maximum number of arguments (defines size of internal buffer).
1271
 */
1272
void aosShellInit(aos_shell_t* shell, event_source_t* oseventsource, const char* prompt, char* line, size_t linesize, size_t numargs)
1273
{
1274
  aosDbgCheck(shell != NULL);
1275
  aosDbgCheck(oseventsource != NULL);
1276
  aosDbgCheck(line != NULL);
1277

    
1278
  // set parameters
1279
  shell->thread = NULL;
1280
  chEvtObjectInit(&shell->eventSource);
1281
  shell->os.eventSource = oseventsource;
1282
  aosShellStreamInit(&shell->stream);
1283
  shell->prompt = prompt;
1284
  shell->commands = NULL;
1285
  shell->execstatus.command = NULL;
1286
  shell->execstatus.retval = 0;
1287
  shell->input.line = line;
1288
  shell->input.length = linesize;
1289
  shell->inputdata.lastaction = AOS_SHELL_ACTION_NONE;
1290
  memset(shell->inputdata.escseq, '\0', sizeof(shell->inputdata.escseq)*sizeof(shell->inputdata.escseq[0]));
1291
  shell->inputdata.cursorpos = 0;
1292
  shell->inputdata.lineend = 0;
1293
  shell->inputdata.noinput = true;
1294
  shell->input.nargs= numargs;
1295
  shell->config = 0x00;
1296

    
1297
  // initialize buffers
1298
  memset(shell->input.line, '\0', shell->input.length);
1299

    
1300
  return;
1301
}
1302

    
1303
/**
1304
 * @brief   Initialize an AosShellStream object.
1305
 *
1306
 * @param[in] stream  The AosShellStrem to initialize.
1307
 */
1308
void aosShellStreamInit(AosShellStream* stream)
1309
{
1310
  aosDbgCheck(stream != NULL);
1311

    
1312
  stream->vmt = &_streamvmt;
1313
  stream->channel = NULL;
1314

    
1315
  return;
1316
}
1317

    
1318
/**
1319
 * @brief   Initialize an AosShellChannel object with the specified parameters.
1320
 *
1321
 * @param[in] channel       The AosShellChannel to initialize.
1322
 * @param[in] asyncchannel  An BaseAsynchronousChannel this AosShellChannel is associated with.
1323
 */
1324
void aosShellChannelInit(AosShellChannel* channel, BaseAsynchronousChannel* asyncchannel)
1325
{
1326
  aosDbgCheck(channel != NULL);
1327
  aosDbgCheck(asyncchannel != NULL);
1328

    
1329
  channel->vmt = &_channelvmt;
1330
  channel->asyncchannel = asyncchannel;
1331
  channel->listener.wflags = 0;
1332
  channel->next = NULL;
1333
  channel->flags = 0;
1334

    
1335
  return;
1336
}
1337

    
1338
/**
1339
 * @brief   Inserts a command to the shells list of commands.
1340
 *
1341
 * @param[in] shell   Pointer to the shell object.
1342
 * @param[in] cmd     Pointer to the command to add.
1343
 *
1344
 * @return            A status value.
1345
 * @retval AOS_SUCCESS  The command was added successfully.
1346
 * @retval AOS_ERROR    Another command with identical name already exists.
1347
 */
1348
aos_status_t aosShellAddCommand(aos_shell_t *shell, aos_shellcommand_t *cmd)
1349
{
1350
  aosDbgCheck(shell != NULL);
1351
  aosDbgCheck(cmd != NULL);
1352
  aosDbgCheck(cmd->name != NULL && strlen(cmd->name) > 0 && strchr(cmd->name, ' ') == NULL && strchr(cmd->name, '\t') == NULL);
1353
  aosDbgCheck(cmd->callback != NULL);
1354
  aosDbgCheck(cmd->next == NULL);
1355

    
1356
  aos_shellcommand_t* prev = NULL;
1357
  aos_shellcommand_t** curr = &(shell->commands);
1358

    
1359
  // insert the command to the list wrt lexographical order (exception: lower case characters preceed upper their uppercase counterparts)
1360
  while (*curr != NULL) {
1361
    // iterate through the list as long as the command names are 'smaller'
1362
    const int cmp = _strccmp((*curr)->name, cmd->name, true, NULL, NULL);
1363
    if (cmp < 0) {
1364
      prev = *curr;
1365
      curr = &((*curr)->next);
1366
      continue;
1367
    }
1368
    // error if the command already exists
1369
    else if (cmp == 0) {
1370
      return AOS_ERROR;
1371
    }
1372
    // insert the command as soon as a 'larger' name was found
1373
    else /* if (cmpval > 0) */ {
1374
      cmd->next = *curr;
1375
      // special case: the first command is larger
1376
      if (prev == NULL) {
1377
        shell->commands = cmd;
1378
      } else {
1379
        prev->next = cmd;
1380
      }
1381
      return AOS_SUCCESS;
1382
    }
1383
  }
1384
  // the end of the list has been reached
1385

    
1386
  // append the command
1387
  *curr = cmd;
1388
  return AOS_SUCCESS;
1389
}
1390

    
1391
/**
1392
 * @brief   Removes a command from the shells list of commands.
1393
 *
1394
 * @param[in] shell     Pointer to the shell object.
1395
 * @param[in] cmd       Name of the command to removde.
1396
 * @param[out] removed  Optional pointer to the command that was removed.
1397
 *
1398
 * @return              A status value.
1399
 * @retval AOS_SUCCESS  The command was removed successfully.
1400
 * @retval AOS_ERROR    The command name was not found.
1401
 */
1402
aos_status_t aosShellRemoveCommand(aos_shell_t *shell, char *cmd, aos_shellcommand_t **removed)
1403
{
1404
  aosDbgCheck(shell != NULL);
1405
  aosDbgCheck(cmd != NULL && strlen(cmd) > 0);
1406

    
1407
  aos_shellcommand_t* prev = NULL;
1408
  aos_shellcommand_t** curr = &(shell->commands);
1409

    
1410
  // iterate through the list and seach for the specified command name
1411
  while (curr != NULL) {
1412
    const int cmpval = strcmp((*curr)->name, cmd);
1413
    // iterate through the list as long as the command names are 'smaller'
1414
    if (cmpval < 0) {
1415
      prev = *curr;
1416
      curr = &((*curr)->next);
1417
      continue;
1418
    }
1419
    // remove the command when found
1420
    else if (cmpval == 0) {
1421
      // special case: the first command matches
1422
      if (prev == NULL) {
1423
        shell->commands = (*curr)->next;
1424
      } else {
1425
        prev->next = (*curr)->next;
1426
      }
1427
      (*curr)->next = NULL;
1428
      // set the optional output argument
1429
      if (removed != NULL) {
1430
        *removed = *curr;
1431
      }
1432
      return AOS_SUCCESS;
1433
    }
1434
    // break the loop if the command names are 'larger'
1435
    else /* if (cmpval > 0) */ {
1436
      break;
1437
    }
1438
  }
1439

    
1440
  // if the command was not found, return an error
1441
  return AOS_ERROR;
1442
}
1443

    
1444
/**
1445
 * @brief   Count the number of commands assigned to the shell.
1446
 *
1447
 * @param[in] shell   The shell to count the commands for.
1448
 *
1449
 * @return  The number of commands associated to the shell.
1450
 */
1451
unsigned int aosShellCountCommands(aos_shell_t* shell)
1452
{
1453
  aosDbgCheck(shell != NULL);
1454

    
1455
  unsigned int count = 0;
1456
  aos_shellcommand_t* cmd = shell->commands;
1457
  while (cmd != NULL) {
1458
    ++count;
1459
    cmd = cmd->next;
1460
  }
1461

    
1462
  return count;
1463
}
1464

    
1465
/**
1466
 * @brief   Add a channel to a AosShellStream.
1467
 *
1468
 * @param[in] stream    The AosShellStream to extend.
1469
 * @param[in] channel   The channel to be added to the stream.
1470
 */
1471
void aosShellStreamAddChannel(AosShellStream* stream, AosShellChannel* channel)
1472
{
1473
  aosDbgCheck(stream != NULL);
1474
  aosDbgCheck(channel != NULL && channel->asyncchannel != NULL && channel->next == NULL && (channel->flags & AOS_SHELLCHANNEL_ATTACHED) == 0);
1475

    
1476
  // prepend the new channel
1477
  chSysLock();
1478
  channel->flags |= AOS_SHELLCHANNEL_ATTACHED;
1479
  channel->next = stream->channel;
1480
  stream->channel = channel;
1481
  chSysUnlock();
1482

    
1483
  return;
1484
}
1485

    
1486
/**
1487
 * @brief   Remove a channel from an AosShellStream.
1488
 *
1489
 * @param[in] stream    The AosShellStream to modify.
1490
 * @param[in] channel   The channel to remove.
1491
 *
1492
 * @return              A status value.
1493
 * @retval AOS_SUCCESS  The channel was removed successfully.
1494
 * @retval AOS_ERROR    The specified channel was not found to be associated with the shell.
1495
 */
1496
aos_status_t aosShellStreamRemoveChannel(AosShellStream* stream, AosShellChannel* channel)
1497
{
1498
  aosDbgCheck(stream != NULL);
1499
  aosDbgCheck(channel != NULL && channel->asyncchannel != NULL && channel->flags & AOS_SHELLCHANNEL_ATTACHED);
1500

    
1501
  // local varibales
1502
  AosShellChannel* prev = NULL;
1503
  AosShellChannel* curr = stream->channel;
1504

    
1505
  // iterate through the list and search for the specified channel
1506
  while (curr != NULL) {
1507
    // if the channel was found
1508
    if (curr == channel) {
1509
      chSysLock();
1510
      // special case: the first channel matches (prev is NULL)
1511
      if (prev == NULL) {
1512
        stream->channel = curr->next;
1513
      } else {
1514
        prev->next = channel->next;
1515
      }
1516
      curr->next = NULL;
1517
      curr->flags &= ~AOS_SHELLCHANNEL_ATTACHED;
1518
      chSysUnlock();
1519
      return AOS_SUCCESS;
1520
    }
1521
  }
1522

    
1523
  // if the channel was not found, return an error
1524
  return AOS_ERROR;
1525
}
1526

    
1527
/**
1528
 * @brief   Enable a AosShellChannel as input.
1529
 *
1530
 * @param[in] channel   The channel to enable as input.
1531
 */
1532
void aosShellChannelInputEnable(AosShellChannel* channel)
1533
{
1534
  aosDbgCheck(channel != NULL && channel->asyncchannel != NULL);
1535

    
1536
  chSysLock();
1537
  channel->listener.wflags |= CHN_INPUT_AVAILABLE;
1538
  channel->flags |= AOS_SHELLCHANNEL_INPUT_ENABLED;
1539
  chSysUnlock();
1540

    
1541
  return;
1542
}
1543

    
1544
/**
1545
 * @brief   Disable a AosShellChannel as input.
1546
 *
1547
 * @param[in] channel   The channel to disable as input.
1548
 */
1549
void aosShellChannelInputDisable( AosShellChannel* channel)
1550
{
1551
  aosDbgCheck(channel != NULL && channel->asyncchannel != NULL);
1552

    
1553
  chSysLock();
1554
  channel->listener.wflags &= ~CHN_INPUT_AVAILABLE;
1555
  channel->flags &= ~AOS_SHELLCHANNEL_INPUT_ENABLED;
1556
  chSysUnlock();
1557

    
1558
  return;
1559
}
1560

    
1561
/**
1562
 * @brief   Enable a AosShellChannel as output.
1563
 *
1564
 * @param[in] channel   The channel to enable as output.
1565
 */
1566
void aosShellChannelOutputEnable(AosShellChannel* channel)
1567
{
1568
  aosDbgCheck(channel != NULL && channel->asyncchannel != NULL);
1569

    
1570
  channel->flags |= AOS_SHELLCHANNEL_OUTPUT_ENABLED;
1571

    
1572
  return;
1573
}
1574

    
1575
/**
1576
 * @brief   Disable a AosShellChannel as output.
1577
 *
1578
 * @param[in] channel   The channel to disable as output.
1579
 */
1580
void aosShellChannelOutputDisable(AosShellChannel* channel)
1581
{
1582
  aosDbgCheck(channel != NULL && channel->asyncchannel != NULL);
1583

    
1584
  channel->flags &= ~AOS_SHELLCHANNEL_OUTPUT_ENABLED;
1585

    
1586
  return;
1587
}
1588

    
1589
/**
1590
 * @brief   Thread main function.
1591
 *
1592
 * @param[in] aosShellThread    Name of the function;
1593
 * @param[in] shell             Pointer to the shell object.
1594
 */
1595
void aosShellThread(void* shell)
1596
{
1597
  aosDbgCheck(shell != NULL);
1598

    
1599
  // local variables
1600
  eventmask_t eventmask;
1601
  eventflags_t eventflags;
1602
  AosShellChannel* channel;
1603
  aos_status_t readeval;
1604
  size_t nchars = 0;
1605
  char* args[((aos_shell_t*)shell)->input.nargs];
1606
  size_t nargs = 0;
1607
  aos_shellcommand_t* cmd;
1608

    
1609
  // initialize variables
1610
  for (size_t arg = 0; arg < ((aos_shell_t*)shell)->input.nargs; ++arg) {
1611
    args[arg] = NULL;
1612
  }
1613

    
1614
  // register OS related events
1615
  chEvtRegisterMask(((aos_shell_t*)shell)->os.eventSource, &(((aos_shell_t*)shell)->os.eventListener), AOS_SHELL_EVENTMASK_OS);
1616
  // register events to all input channels
1617
  for (channel = ((aos_shell_t*)shell)->stream.channel; channel != NULL; channel = channel->next) {
1618
    chEvtRegisterMaskWithFlags(&(channel->asyncchannel->event), &(channel->listener), AOS_SHELL_EVENTMASK_INPUT, channel->listener.wflags);
1619
  }
1620

    
1621
  // fire start event
1622
  chEvtBroadcastFlags(&(((aos_shell_t*)shell)->eventSource), AOS_SHELL_EVTFLAG_START);
1623

    
1624
  // print the prompt for the first time
1625
  _printPrompt((aos_shell_t*)shell);
1626

    
1627
  // enter thread loop
1628
  while (!chThdShouldTerminateX()) {
1629
    // wait for event and handle it accordingly
1630
    eventmask = chEvtWaitOne(ALL_EVENTS);
1631

    
1632
    // handle event
1633
    switch (eventmask) {
1634

    
1635
      // OS related events
1636
      case AOS_SHELL_EVENTMASK_OS:
1637
      {
1638
        eventflags = chEvtGetAndClearFlags(&((aos_shell_t*)shell)->os.eventListener);
1639
        // handle shutdown/restart events
1640
        if (eventflags & AOS_SYSTEM_EVENTFLAGS_SHUTDOWN_MASK) {
1641
          chThdTerminate(((aos_shell_t*)shell)->thread);
1642
        } else {
1643
          // print an error message
1644
          chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "\nERROR: unknown OS event received (0x%08X)\n", eventflags);
1645
        }
1646
        break;
1647
      }
1648

    
1649
      // input events
1650
      case AOS_SHELL_EVENTMASK_INPUT:
1651
      {
1652
        // check and handle all channels
1653
        channel = ((aos_shell_t*)shell)->stream.channel;
1654
        while (channel != NULL) {
1655
          eventflags = chEvtGetAndClearFlags(&channel->listener);
1656
          // if there is new input
1657
          if (eventflags & CHN_INPUT_AVAILABLE) {
1658
            // read input from channel
1659
            readeval = _readChannel((aos_shell_t*)shell, channel, &nchars);
1660
            // parse input line to argument list only if the input shall be executed
1661
            nargs = (readeval == AOS_SUCCESS && nchars > 0) ? _parseArguments((aos_shell_t*)shell, args) : 0;
1662
            // check number of arguments
1663
            if (nargs > ((aos_shell_t*)shell)->input.nargs) {
1664
              // error too many arguments
1665
              chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "\ttoo many arguments\n");
1666
            } else if (nargs > 0) {
1667
              // search command list for arg[0] and execute callback
1668
              cmd = ((aos_shell_t*)shell)->commands;
1669
              while (cmd != NULL) {
1670
                if (strcmp(args[0], cmd->name) == 0) {
1671
                  ((aos_shell_t*)shell)->execstatus.command = cmd;
1672
                  chEvtBroadcastFlags(&(((aos_shell_t*)shell)->eventSource), AOS_SHELL_EVTFLAG_EXEC);
1673
                  ((aos_shell_t*)shell)->execstatus.retval = cmd->callback((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, (int)nargs, args);
1674
                  chEvtBroadcastFlags(&(((aos_shell_t*)shell)->eventSource), AOS_SHELL_EVTFLAG_DONE);
1675
                  // notify if the command was not successful
1676
                  if (((aos_shell_t*)shell)->execstatus.retval != 0) {
1677
                    chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "command returned exit status %d\n", ((aos_shell_t*)shell)->execstatus.retval);
1678
                  }
1679
                  break;
1680
                }
1681
                cmd = cmd->next;
1682
              } /* end of while */
1683

    
1684
              // if no matching command was found, print an error
1685
              if (cmd == NULL) {
1686
                chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "\tcommand '%s' not found\n", args[0]);
1687
              }
1688
            }
1689

    
1690
            // reset some internal variables and eprint a new prompt
1691
            if (readeval == AOS_SUCCESS && !chThdShouldTerminateX()) {
1692
              ((aos_shell_t*)shell)->inputdata.cursorpos = 0;
1693
              ((aos_shell_t*)shell)->inputdata.lineend = 0;
1694
              _printPrompt((aos_shell_t*)shell);
1695
            }
1696
          }
1697

    
1698
          // iterate to next channel
1699
          channel = channel->next;
1700
        }
1701
        break;
1702
      }
1703

    
1704
      // other events
1705
      default:
1706
      {
1707
        // print an error message
1708
        chprintf((BaseSequentialStream*)&((aos_shell_t*)shell)->stream, "\nSHELL: ERROR: unknown event received (0x%08X)\n", eventmask);
1709
        break;
1710
      }
1711

    
1712
    } /* end of switch */
1713

    
1714
  } /* end of while */
1715

    
1716
  // fire event and exit the thread
1717
  chSysLock();
1718
  chEvtBroadcastFlagsI(&(((aos_shell_t*)shell)->eventSource), AOS_SHELL_EVTFLAG_EXIT);
1719
  chThdExitS(MSG_OK);
1720
  // no chSysUnlock() required since the thread has been terminated an all waiting threads have been woken up
1721
}
1722

    
1723
#endif /* (AMIROOS_CFG_SHELL_ENABLE == true) */
1724

    
1725
/** @} */