subsys: shell rework

drivers/modem/modem_shell.c

@@ -14,7 +14,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <device.h>
-#include <shell/shell.h>
+#include <shell/legacy_shell.h>
 
 #include <misc/printk.h>
 

ext/Kconfig

@@ -14,6 +14,8 @@ source "ext/lib/crypto/Kconfig"
 
 source "ext/lib/encoding/Kconfig"
 
+source "ext/lib/fnmatch/Kconfig"
+
 source "ext/lib/ipc/open-amp/Kconfig"
 
 source "ext/lib/mgmt/Kconfig"

ext/lib/CMakeLists.txt

@@ -2,3 +2,4 @@ add_subdirectory(crypto)
 add_subdirectory(encoding)
 add_subdirectory(ipc)
 add_subdirectory(mgmt)
+add_subdirectory_ifdef(CONFIG_FNMATCH fnmatch)

ext/lib/fnmatch/CMakeLists.txt

@@ -0,0 +1,15 @@
+# Copyright (c) 2018 Nordic Semiconductor
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+zephyr_include_directories_ifdef(
+  CONFIG_FNMATCH
+  .
+)
+
+zephyr_sources_ifdef(
+  CONFIG_FNMATCH
+  fnmatch.c
+)
+

ext/lib/fnmatch/Kconfig

@@ -0,0 +1,12 @@
+#
+# Copyright (c) 2018 Nordic Semiconductor
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+config FNMATCH
+	bool
+	prompt "Fnmatch Support"
+	help
+	  This option enables the fnmatch library
+

ext/lib/fnmatch/fnmatch.c

@@ -0,0 +1,208 @@
+/*    $NetBSD: fnmatch.c,v 1.26 2014/10/12 22:32:33 christos Exp $    */
+
+/*
+ * Copyright (c) 1989, 1993, 1994
+ *    The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Guido van Rossum.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Function fnmatch() as specified in POSIX 1003.2-1992, section B.6.
+ * Compares a filename or pathname to a pattern.
+ */
+
+#include <ctype.h>
+#include "fnmatch.h"
+#include <string.h>
+
+#define EOS    '\0'
+
+static inline int foldcase(int ch, int flags)
+{
+
+    if ((flags & FNM_CASEFOLD) != 0 && isupper(ch))
+        return tolower(ch);
+    return ch;
+}
+
+#define    FOLDCASE(ch, flags)    foldcase((unsigned char)(ch), (flags))
+
+static const char * rangematch(const char *pattern, int test, int flags)
+{
+    int negate, ok, need;
+    char c, c2;
+
+    if (pattern == NULL)
+    {
+        return NULL;
+    }
+
+    /*
+     * A bracket expression starting with an unquoted circumflex
+     * character produces unspecified results (IEEE 1003.2-1992,
+     * 3.13.2).  This implementation treats it like '!', for
+     * consistency with the regular expression syntax.
+     * J.T. Conklin (conklin@ngai.kaleida.com)
+     */
+    if ((negate = (*pattern == '!' || *pattern == '^')) != 0)
+        ++pattern;
+
+    need = 1;
+    for (ok = 0; (c = FOLDCASE(*pattern++, flags)) != ']' || need;) {
+        need = 0;
+        if (c == '/')
+            return (void *)-1;
+        if (c == '\\' && !(flags & FNM_NOESCAPE))
+            c = FOLDCASE(*pattern++, flags);
+        if (c == EOS)
+            return NULL;
+        if (*pattern == '-' 
+            && (c2 = FOLDCASE(*(pattern + 1), flags)) != EOS &&
+                c2 != ']') {
+            pattern += 2;
+            if (c2 == '\\' && !(flags & FNM_NOESCAPE))
+                c2 = FOLDCASE(*pattern++, flags);
+            if (c2 == EOS)
+                return NULL;
+            if (c <= test && test <= c2)
+                ok = 1;
+        } else if (c == test)
+            ok = 1;
+    }
+    return ok == negate ? NULL : pattern;
+}
+
+
+static int fnmatchx(const char *pattern, const char *string, int flags, size_t recursion)
+{
+    const char *stringstart, *r;
+    char c, test;
+
+    if ((pattern == NULL) || (string == NULL))
+    {
+        return FNM_NOMATCH;
+    }
+
+    if (recursion-- == 0)
+        return FNM_NORES;
+
+    for (stringstart = string;;) {
+        switch (c = FOLDCASE(*pattern++, flags)) {
+        case EOS:
+            if ((flags & FNM_LEADING_DIR) && *string == '/')
+                return 0;
+            return *string == EOS ? 0 : FNM_NOMATCH;
+        case '?':
+            if (*string == EOS)
+                return FNM_NOMATCH;
+            if (*string == '/' && (flags & FNM_PATHNAME))
+                return FNM_NOMATCH;
+            if (*string == '.' && (flags & FNM_PERIOD) &&
+                (string == stringstart ||
+                ((flags & FNM_PATHNAME) && *(string - 1) == '/')))
+                return FNM_NOMATCH;
+            ++string;
+            break;
+        case '*':
+            c = FOLDCASE(*pattern, flags);
+            /* Collapse multiple stars. */
+            while (c == '*')
+                c = FOLDCASE(*++pattern, flags);
+
+            if (*string == '.' && (flags & FNM_PERIOD) &&
+                (string == stringstart ||
+                ((flags & FNM_PATHNAME) && *(string - 1) == '/')))
+                return FNM_NOMATCH;
+
+            /* Optimize for pattern with * at end or before /. */
+            if (c == EOS) {
+                if (flags & FNM_PATHNAME)
+                    return (flags & FNM_LEADING_DIR) ||
+                        strchr(string, '/') == NULL ?
+                        0 : FNM_NOMATCH;
+                else
+                    return 0;
+            } else if (c == '/' && flags & FNM_PATHNAME) {
+                if ((string = strchr(string, '/')) == NULL)
+                    return FNM_NOMATCH;
+                break;
+            }
+
+            /* General case, use recursion. */
+            while ((test = FOLDCASE(*string, flags)) != EOS) {
+                int e;
+                switch ((e = fnmatchx(pattern, string,
+                    flags & ~FNM_PERIOD, recursion))) {
+                case FNM_NOMATCH:
+                    break;
+                default:
+                    return e;
+                }
+                if (test == '/' && flags & FNM_PATHNAME)
+                    break;
+                ++string;
+            }
+            return FNM_NOMATCH;
+        case '[':
+            if (*string == EOS)
+                return FNM_NOMATCH;
+            if (*string == '/' && flags & FNM_PATHNAME)
+                return FNM_NOMATCH;
+            if ((r = rangematch(pattern,
+                FOLDCASE(*string, flags), flags)) == NULL)
+                return FNM_NOMATCH;
+            if (r == (void *)-1) {
+                if (*string != '[')
+                    return FNM_NOMATCH;
+            } else
+                pattern = r;
+            ++string;
+            break;
+        case '\\':
+            if (!(flags & FNM_NOESCAPE)) {
+                if ((c = FOLDCASE(*pattern++, flags)) == EOS) {
+                    c = '\0';
+                    --pattern;
+                }
+            }
+            /* FALLTHROUGH */
+        default:
+            if (c != FOLDCASE(*string++, flags))
+                return FNM_NOMATCH;
+            break;
+        }
+    }
+    /* NOTREACHED */
+}
+
+int fnmatch(const char *pattern, const char *string, int flags)
+{
+    return fnmatchx(pattern, string, flags, 64);
+}
+

ext/lib/fnmatch/fnmatch.h

@@ -0,0 +1,50 @@
+/*    $NetBSD: fnmatch.h,v 1.12.50.1 2011/02/08 16:18:55 bouyer Exp $    */
+
+/*-
+ * Copyright (c) 1992, 1993
+ *    The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *    @(#)fnmatch.h    8.1 (Berkeley) 6/2/93
+ */
+
+#ifndef    _FNMATCH_H_
+#define    _FNMATCH_H_
+
+#define    FNM_NOMATCH      1    /* Match failed. */
+#define    FNM_NOSYS        2    /* Function not implemented. */
+#define    FNM_NORES        3    /* Out of resources */
+
+#define    FNM_NOESCAPE     0x01    /* Disable backslash escaping. */
+#define    FNM_PATHNAME     0x02    /* Slash must be matched by slash. */
+#define    FNM_PERIOD       0x04    /* Period must be matched by period. */
+#define    FNM_CASEFOLD     0x08    /* Pattern is matched case-insensitive */
+#define    FNM_LEADING_DIR  0x10    /* Ignore /<tail> after Imatch. */
+
+int     fnmatch(const char *, const char *, int);
+
+#endif /* !_FNMATCH_H_ */
+

include/linker/common-rom.ld

@@ -73,3 +73,10 @@
 		KEEP(*(".log_backends"));
 		__log_backends_end = .;
 	} GROUP_LINK_IN(ROMABLE_REGION)
+
+	SECTION_DATA_PROLOGUE(shell_root_cmds_sections, (OPTIONAL),)
+	{
+		__shell_root_cmds_start = .;
+		KEEP(*(SORT(.shell_root_cmd_*)));
+		__shell_root_cmds_end = .;
+	} GROUP_LINK_IN(ROMABLE_REGION)

include/logging/log_ctrl.h

@@ -104,7 +104,7 @@ u32_t log_src_cnt_get(u32_t domain_id);
  * @param domain_id Domain ID.
  * @param src_id    Source ID.
  *
- * @return Source name.
+ * @return Source name or NULL if invalid arguments.
  */
 const char *log_source_name_get(u32_t domain_id, u32_t src_id);
 

include/misc/dlist.h

@@ -310,6 +310,41 @@ static inline sys_dnode_t *sys_dlist_peek_next(sys_dlist_t *list,
 	return node ? sys_dlist_peek_next_no_check(list, node) : NULL;
 }
 
+/**
+ * @brief get a reference to the previous item in the list, node is not NULL
+ *
+ * Faster than sys_dlist_peek_prev() if node is known not to be NULL.
+ *
+ * @param list the doubly-linked list to operate on
+ * @param node the node from which to get the previous element in the list
+ *
+ * @return a pointer to the previous element from a node, NULL if node is the
+ *	   tail
+ */
+
+static inline sys_dnode_t *sys_dlist_peek_prev_no_check(sys_dlist_t *list,
+							sys_dnode_t *node)
+{
+	return (node == list->head) ? NULL : node->prev;
+}
+
+/**
+ * @brief get a reference to the previous item in the list
+ *
+ * @param list the doubly-linked list to operate on
+ * @param node the node from which to get the previous element in the list
+ *
+ * @return a pointer to the previous element from a node, NULL if node is the
+ * 	   tail or NULL (when node comes from reading the head of an empty
+ * 	   list).
+ */
+
+static inline sys_dnode_t *sys_dlist_peek_prev(sys_dlist_t *list,
+					       sys_dnode_t *node)
+{
+	return node ? sys_dlist_peek_prev_no_check(list, node) : NULL;
+}
+
 /**
  * @brief get a reference to the tail item in the list
  *