Statistics
| Branch: | Tag: | Revision:

amiro-os / core / src / aos_shell.c @ cda14729

History | View | Annotate | Download (54.7 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, 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, 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.width) {
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.width);
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
                            (n - cmatch) :
912
                            (cmd->name[n] != '\0') ?
913
                              strlen(cmd->name) - n :
914
                              0;
915
          // if an exact match was found
916
          if (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 (cmatch + cmp > shell->inputdata.cursorpos) {
928
            // if this is the first one
929
            if (fill == shell->input.line) {
930
              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 += 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.width) {
949
            cmatch = shell->input.width - 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
                            (i - shell->inputdata.cursorpos) :
986
                            (cmd->name[i] != '\0') ?
987
                              strlen(cmd->name) - 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.width) {
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.width) {
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.width - 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
 *
1197
 * @return            Number of arguments found.
1198
 */
1199
static size_t _parseArguments(aos_shell_t* shell)
1200
{
1201
  aosDbgCheck(shell != NULL);
1202

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

    
1213
  // local variables
1214
  state_t state = START;
1215
  size_t arg = 0;
1216

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

    
1249
  // set all remaining argument pointers to NULL
1250
  for (size_t a = arg; a < shell->arglistsize; ++a) {
1251
    shell->arglist[a] = NULL;
1252
  }
1253

    
1254
  return arg;
1255
}
1256

    
1257
/******************************************************************************/
1258
/* EXPORTED FUNCTIONS                                                         */
1259
/******************************************************************************/
1260

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

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

    
1299
  // initialize buffers
1300
  memset(shell->input.line, '\0', shell->input.width);
1301
  for (size_t a = 0; a < shell->arglistsize; ++a) {
1302
    shell->arglist[a] = NULL;
1303
  }
1304

    
1305
  return;
1306
}
1307

    
1308
/**
1309
 * @brief   Initialize an AosShellStream object.
1310
 *
1311
 * @param[in] stream  The AosShellStrem to initialize.
1312
 */
1313
void aosShellStreamInit(AosShellStream* stream)
1314
{
1315
  aosDbgCheck(stream != NULL);
1316

    
1317
  stream->vmt = &_streamvmt;
1318
  stream->channel = NULL;
1319

    
1320
  return;
1321
}
1322

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

    
1334
  channel->vmt = &_channelvmt;
1335
  channel->asyncchannel = asyncchannel;
1336
  channel->listener.wflags = 0;
1337
  channel->next = NULL;
1338
  channel->flags = 0;
1339

    
1340
  return;
1341
}
1342

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

    
1361
  aos_shellcommand_t* prev = NULL;
1362
  aos_shellcommand_t** curr = &(shell->commands);
1363

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

    
1391
  // append the command
1392
  *curr = cmd;
1393
  return AOS_SUCCESS;
1394
}
1395

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

    
1412
  aos_shellcommand_t* prev = NULL;
1413
  aos_shellcommand_t** curr = &(shell->commands);
1414

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

    
1445
  // if the command was not found, return an error
1446
  return AOS_ERROR;
1447
}
1448

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

    
1460
  unsigned int count = 0;
1461
  aos_shellcommand_t* cmd = shell->commands;
1462
  while (cmd != NULL) {
1463
    ++count;
1464
    cmd = cmd->next;
1465
  }
1466

    
1467
  return count;
1468
}
1469

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

    
1481
  // prepend the new channel
1482
  chSysLock();
1483
  channel->flags |= AOS_SHELLCHANNEL_ATTACHED;
1484
  channel->next = stream->channel;
1485
  stream->channel = channel;
1486
  chSysUnlock();
1487

    
1488
  return;
1489
}
1490

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

    
1506
  // local varibales
1507
  AosShellChannel* prev = NULL;
1508
  AosShellChannel* curr = stream->channel;
1509

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

    
1528
  // if the channel was not found, return an error
1529
  return AOS_ERROR;
1530
}
1531

    
1532
/**
1533
 * @brief   Enable a AosShellChannel as input.
1534
 *
1535
 * @param[in] channel   The channel to enable as input.
1536
 */
1537
void aosShellChannelInputEnable(AosShellChannel* channel)
1538
{
1539
  aosDbgCheck(channel != NULL && channel->asyncchannel != NULL);
1540

    
1541
  chSysLock();
1542
  channel->listener.wflags |= CHN_INPUT_AVAILABLE;
1543
  channel->flags |= AOS_SHELLCHANNEL_INPUT_ENABLED;
1544
  chSysUnlock();
1545

    
1546
  return;
1547
}
1548

    
1549
/**
1550
 * @brief   Disable a AosShellChannel as input.
1551
 *
1552
 * @param[in] channel   The channel to disable as input.
1553
 */
1554
void aosShellChannelInputDisable( AosShellChannel* channel)
1555
{
1556
  aosDbgCheck(channel != NULL && channel->asyncchannel != NULL);
1557

    
1558
  chSysLock();
1559
  channel->listener.wflags &= ~CHN_INPUT_AVAILABLE;
1560
  channel->flags &= ~AOS_SHELLCHANNEL_INPUT_ENABLED;
1561
  chSysUnlock();
1562

    
1563
  return;
1564
}
1565

    
1566
/**
1567
 * @brief   Enable a AosShellChannel as output.
1568
 *
1569
 * @param[in] channel   The channel to enable as output.
1570
 */
1571
void aosShellChannelOutputEnable(AosShellChannel* channel)
1572
{
1573
  aosDbgCheck(channel != NULL && channel->asyncchannel != NULL);
1574

    
1575
  channel->flags |= AOS_SHELLCHANNEL_OUTPUT_ENABLED;
1576

    
1577
  return;
1578
}
1579

    
1580
/**
1581
 * @brief   Disable a AosShellChannel as output.
1582
 *
1583
 * @param[in] channel   The channel to disable as output.
1584
 */
1585
void aosShellChannelOutputDisable(AosShellChannel* channel)
1586
{
1587
  aosDbgCheck(channel != NULL && channel->asyncchannel != NULL);
1588

    
1589
  channel->flags &= ~AOS_SHELLCHANNEL_OUTPUT_ENABLED;
1590

    
1591
  return;
1592
}
1593

    
1594
/**
1595
 * @brief   Thread main function.
1596
 *
1597
 * @param[in] aosShellThread    Name of the function;
1598
 * @param[in] shell             Pointer to the shell object.
1599
 */
1600
void aosShellThread(void* shell)
1601
{
1602
  aosDbgCheck(shell != NULL);
1603

    
1604
  // local variables
1605
  eventmask_t eventmask;
1606
  eventflags_t eventflags;
1607
  AosShellChannel* channel;
1608
  aos_status_t readeval;
1609
  size_t nchars = 0;
1610
  size_t nargs = 0;
1611
  aos_shellcommand_t* cmd;
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) : 0;
1662
            // check number of arguments
1663
            if (nargs > ((aos_shell_t*)shell)->arglistsize) {
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(((aos_shell_t*)shell)->arglist[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, nargs, ((aos_shell_t*)shell)->arglist);
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", ((aos_shell_t*)shell)->arglist[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
/** @} */