posix: c_lib_ext: fnmatch: add support for posix character classes

Implemented match_posix_class function that was needed
to match the possible posix classes like alnum, alpha etc...

Signed-off-by: Harun Spago <harun.spago.code@gmail.com>

Author: Spago123

lib/posix/c_lib_ext/fnmatch.c

@@ -48,6 +48,146 @@
 
 #define EOS '\0'
 
+#define MATCH_CLASS6(p,a,b,c,d,e,f,g) \
+	((p)[0]==(a) && (p)[1]==(b) && (p)[2]==(c) && (p)[3]==(d) && (p)[4]==(e) && (p)[5]==(f) && (p)[6]==(g))
+
+#define MATCH_CLASS7(p,a,b,c,d,e,f,g,h) \
+	((p)[0]==(a) && (p)[1]==(b) && (p)[2]==(c) && (p)[3]==(d) && (p)[4]==(e) && (p)[5]==(f) && (p)[6]==(g) && (p)[7]==(h))
+
+enum fnm_char_class {
+	FNM_CC_ALNUM,
+	FNM_CC_ALPHA,
+	FNM_CC_BLANK,
+	FNM_CC_CNTRL,
+	FNM_CC_DIGIT,
+	FNM_CC_GRAPH,
+	FNM_CC_LOWER,
+	FNM_CC_PRINT,
+	FNM_CC_PUNCT,
+	FNM_CC_SPACE,
+	FNM_CC_UPPER,
+	FNM_CC_XDIGIT,
+	FNM_CC_INVALID,
+};
+
+static bool fnm_cc_is_valid(const char *pattern, size_t psize, enum fnm_char_class *cc)
+{
+	if (psize < 4 || *pattern != ':')
+		return false;
+
+	pattern++;  /* skip ':' */
+	psize--;
+
+	/* Each class name ends with ":]" */
+	switch (pattern[0]) {
+	case 'a':
+		if (MATCH_CLASS6(pattern,'a','l','n','u','m',':',']')) {
+			*cc = FNM_CC_ALNUM;
+			return true;
+		}
+		if (MATCH_CLASS6(pattern,'a','l','p','h','a',':',']')) {
+			*cc = FNM_CC_ALPHA;
+			return true;
+		}
+		break;
+	
+	case 'b':
+		if (MATCH_CLASS6(pattern,'b','l','a','n','k',':',']')) {
+			*cc = FNM_CC_BLANK;
+			return true;
+		}
+		break;
+
+	case 'c':
+		if (MATCH_CLASS6(pattern,'c','n','t','r','l',':',']')) {
+			*cc = FNM_CC_CNTRL;
+			return true;
+		}
+		break;
+
+	case 'd':
+		if (MATCH_CLASS6(pattern,'d','i','g','i','t',':',']')) {
+			*cc = FNM_CC_DIGIT;
+			return true;
+		}
+		break;
+
+	case 'g':
+		if (MATCH_CLASS6(pattern,'g','r','a','p','h',':',']')) {
+			*cc = FNM_CC_GRAPH;
+			return true;
+		}
+		break;
+
+	case 'l':
+		if (MATCH_CLASS6(pattern,'l','o','w','e','r',':',']')) {
+			*cc = FNM_CC_LOWER;
+			return true;
+		}
+		break;
+
+	case 'p':
+		if (MATCH_CLASS6(pattern,'p','r','i','n','t',':',']')) {
+			*cc = FNM_CC_PRINT;
+			return true;
+		}
+		if (MATCH_CLASS6(pattern,'p','u','n','c','t',':',']')) {
+			*cc = FNM_CC_PUNCT;
+			return true;
+		}
+		break;
+
+	case 's':
+		if (MATCH_CLASS6(pattern,'s','p','a','c','e',':',']')) {
+			*cc = FNM_CC_SPACE;
+			return true;
+		}
+		break;
+
+	case 'u':
+		if (MATCH_CLASS6(pattern,'u','p','p','e','r',':',']')) {
+			*cc = FNM_CC_UPPER;
+			return true;
+		}
+		break;
+
+	case 'x':
+		if (MATCH_CLASS7(pattern,'x','d','i','g','i','t',':',']')) {
+			*cc = FNM_CC_XDIGIT;
+			return true;
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	return false;
+}
+
+static inline int fnm_cc_match(int c, enum fnm_char_class cc)
+{
+	switch (cc) {
+	case FNM_CC_ALNUM:  return isalnum(c);
+	case FNM_CC_ALPHA:  return isalpha(c);
+	case FNM_CC_BLANK:  return isblank(c);
+	case FNM_CC_CNTRL:  return iscntrl(c);
+	case FNM_CC_DIGIT:  return isdigit(c);
+	case FNM_CC_GRAPH:  return isgraph(c);
+	case FNM_CC_LOWER:  return islower(c);
+	case FNM_CC_PRINT:  return isprint(c);
+	case FNM_CC_PUNCT:  return ispunct(c);
+	case FNM_CC_SPACE:  return isspace(c);
+	case FNM_CC_UPPER:  return isupper(c);
+	case FNM_CC_XDIGIT: return isxdigit(c);
+	default:
+		break;
+	}
+
+	return 0;
+}
+
+
 static inline int foldcase(int ch, int flags)
 {
 
@@ -60,6 +200,24 @@ static inline int foldcase(int ch, int flags)
 
 #define FOLDCASE(ch, flags) foldcase((unsigned char)(ch), (flags))
 
+static bool match_posix_class(const char **pattern, int test)
+{
+	enum fnm_char_class cc;
+
+	const char *p = *pattern;
+	size_t remaining = strlen(p);
+
+	if (!fnm_cc_is_valid(p, remaining, &cc))
+		return false;
+
+	/* move pattern pointer past ":]" */
+	const char *end = strstr(p, ":]");
+	if (end)
+		*pattern = end + 2;
+
+	return fnm_cc_match(test, cc);
+}
+
 static const char *rangematch(const char *pattern, int test, int flags)
 {
 	bool negate, ok, need;
@@ -99,6 +257,18 @@ static const char *rangematch(const char *pattern, int test, int flags)
 			return NULL;
 		}
 
+		if (c == '[' && *pattern == ':') {
+			if (match_posix_class(&pattern, test)) {
+				ok = true;
+				continue;
+			} else {
+				// skip over class if unrecognized
+				while (*pattern && !(*pattern == ':' && *(pattern+1) == ']')) pattern++;
+				if (*pattern) pattern += 2;
+				continue;
+			}
+		}
+
 		if (*pattern == '-') {
 			c2 = FOLDCASE(*(pattern + 1), flags);
 			if (c2 != EOS && c2 != ']') {