Implement and document g_ascii_isxxx.
authorAlexander Larsson <alla@lysator.liu.se>
Sat, 25 Aug 2001 22:29:40 +0000 (22:29 +0000)
committerAlexander Larsson <alexl@src.gnome.org>
Sat, 25 Aug 2001 22:29:40 +0000 (22:29 +0000)
2001-08-25  Alexander Larsson  <alla@lysator.liu.se>

* glib/gstrfuncs.[ch]:
* docs/reference/glib/glib-overrides.txt:
* docs/reference/glib/glib-sections.txt:
* docs/reference/glib/tmpl/string_utils.sgml:
Implement and document g_ascii_isxxx.

* tests/strfunc-test.c:
Add tests for g_ascii_isxxx

* glib/guniprop.c (g_unichar_ispunct):
include symbols, not just punctuation.
(g_unichar_isspace): Vertical tab is not
considered whitespace.

* tests/shell-test.c:
Output errors on stderr

docs/reference/glib/glib-overrides.txt
docs/reference/glib/glib-sections.txt
docs/reference/glib/tmpl/string_utils.sgml
glib/gstrfuncs.c
glib/gstrfuncs.h
glib/guniprop.c
tests/shell-test.c
tests/strfunc-test.c

index 80fe2f1..2905b1e 100644 (file)
@@ -219,3 +219,71 @@ GPrivate *private_key, gpointer data
 <NAME>G_OS_BEOS</NAME>
 #define G_OS_BEOS
 </MACRO>
+
+# g_ascii_isxxx
+
+<FUNCTION>
+<NAME>g_ascii_isalnum</NAME>
+<RETURNS>gboolean</RETURNS>
+gchar c
+</FUNCTION>
+
+<FUNCTION>
+<NAME>g_ascii_isalpha</NAME>
+<RETURNS>gboolean</RETURNS>
+gchar c
+</FUNCTION>
+
+<FUNCTION>
+<NAME>g_ascii_iscntrl</NAME>
+<RETURNS>gboolean</RETURNS>
+gchar c
+</FUNCTION>
+
+<FUNCTION>
+<NAME>g_ascii_isdigit</NAME>
+<RETURNS>gboolean</RETURNS>
+gchar c
+</FUNCTION>
+
+<FUNCTION>
+<NAME>g_ascii_isgraph</NAME>
+<RETURNS>gboolean</RETURNS>
+gchar c
+</FUNCTION>
+
+<FUNCTION>
+<NAME>g_ascii_islower</NAME>
+<RETURNS>gboolean</RETURNS>
+gchar c
+</FUNCTION>
+
+<FUNCTION>
+<NAME>g_ascii_isprint</NAME>
+<RETURNS>gboolean</RETURNS>
+gchar c
+</FUNCTION>
+
+<FUNCTION>
+<NAME>g_ascii_ispunct</NAME>
+<RETURNS>gboolean</RETURNS>
+gchar c
+</FUNCTION>
+
+<FUNCTION>
+<NAME>g_ascii_isspace</NAME>
+<RETURNS>gboolean</RETURNS>
+gchar c
+</FUNCTION>
+
+<FUNCTION>
+<NAME>g_ascii_isupper</NAME>
+<RETURNS>gboolean</RETURNS>
+gchar c
+</FUNCTION>
+
+<FUNCTION>
+<NAME>g_ascii_isxdigit</NAME>
+<RETURNS>gboolean</RETURNS>
+gchar c
+</FUNCTION>
index a582701..7840cbe 100644 (file)
@@ -852,6 +852,39 @@ g_vsnprintf
 g_printf_string_upper_bound
 
 <SUBSECTION>
+g_ascii_isalnum
+g_ascii_isalpha
+g_ascii_iscntrl
+g_ascii_isdigit
+g_ascii_isgraph
+g_ascii_islower
+g_ascii_isprint
+g_ascii_ispunct
+g_ascii_isspace
+g_ascii_isupper
+g_ascii_isxdigit
+
+<SUBSECTION>
+g_ascii_digit_value
+g_ascii_xdigit_value
+
+<SUBSECTION>
+g_ascii_strcasecmp
+g_ascii_strncasecmp
+
+<SUBSECTION>
+g_ascii_strup
+g_ascii_strdown
+
+<SUBSECTION>
+g_ascii_tolower
+g_ascii_toupper
+
+<SUBSECTION>
+g_string_ascii_up
+g_string_ascii_down
+
+<SUBSECTION>
 g_strup
 g_strdown
 
index 3dc9080..0c2be0c 100644 (file)
@@ -193,6 +193,286 @@ documentation.
 @Returns: the maximum space needed to store the formatted string.
 
 
+<!-- ##### FUNCTION g_ascii_isalnum ##### -->
+<para>
+Determines whether a character is alphanumeric.
+</para>
+<para>
+Unlike the standard C library isalnum function, this only
+recognizes standard ASCII letters and ignores the locale, returning
+%FALSE for all non-ASCII characters. Also unlike the standard
+library function, this takes a char, not an int, so don't call it
+on EOF but no need to cast to guchar before passing a possibly
+non-ASCII character in.
+</para>
+
+@c: any characted
+@Returns: %TRUE if @c is an ASCII alphanumeric character
+
+
+<!-- ##### FUNCTION g_ascii_isalpha ##### -->
+<para>
+Determines whether a character is alphabetic (i.e. a letter).
+</para>
+<para>
+Unlike the standard C library isalpha function, this only
+recognizes standard ASCII letters and ignores the locale, returning
+%FALSE for all non-ASCII characters. Also unlike the standard
+library function, this takes a char, not an int, so don't call it
+on EOF but no need to cast to guchar before passing a possibly
+non-ASCII character in.
+</para>
+
+@c: any characted
+@Returns: %TRUE if @c is an ASCII alphabetic character
+
+
+<!-- ##### FUNCTION g_ascii_iscntrl ##### -->
+<para>
+Determines whether a character is a control character.
+</para>
+<para>
+Unlike the standard C library iscntrl function, this only
+recognizes standard ASCII control characters and ignores the locale,
+returning%FALSE for all non-ASCII characters. Also unlike the standard
+library function, this takes a char, not an int, so don't call it
+on EOF but no need to cast to guchar before passing a possibly
+non-ASCII character in.
+</para>
+
+@c: any characted
+@Returns: %TRUE if @c is an ASCII control character.
+
+
+<!-- ##### FUNCTION g_ascii_isdigit ##### -->
+<para>
+Determines whether a character is digit (0-9).
+</para>
+<para>
+Unlike the standard C library isdigit function, this only
+recognizes standard ASCII digits and ignores the locale, returning
+%FALSE for all non-ASCII characters. Also unlike the standard
+library function, this takes a char, not an int, so don't call it
+on EOF but no need to cast to guchar before passing a possibly
+non-ASCII character in.
+</para>
+
+@c: any characted
+@Returns: %TRUE if @c is an ASCII digit.
+
+
+<!-- ##### FUNCTION g_ascii_isgraph ##### -->
+<para>
+Determines whether a character is a printing character and not a space.
+</para>
+<para>
+Unlike the standard C library isgraph function, this only
+recognizes standard ASCII characters and ignores the locale, returning
+%FALSE for all non-ASCII characters. Also unlike the standard
+library function, this takes a char, not an int, so don't call it
+on EOF but no need to cast to guchar before passing a possibly
+non-ASCII character in.
+</para>
+
+@c: any characted
+@Returns: %TRUE if @c is an ASCII printing character other than space.
+
+
+<!-- ##### FUNCTION g_ascii_islower ##### -->
+<para>
+Determines whether a character is an ASCII lower case letter.
+</para>
+<para>
+Unlike the standard C library islower function, this only
+recognizes standard ASCII letters and ignores the locale, returning
+%FALSE for all non-ASCII characters. Also unlike the standard
+library function, this takes a char, not an int, so don't call it
+on EOF but no need to worry about casting to guchar before passing
+a possibly non-ASCII character in.
+</para>
+
+@c: any characted
+@Returns: %TRUE if @c is an ASCII lower case letter
+
+
+<!-- ##### FUNCTION g_ascii_isprint ##### -->
+<para>
+Determines whether a character is a printing character.
+</para>
+<para>
+Unlike the standard C library isprint function, this only
+recognizes standard ASCII characters and ignores the locale, returning
+%FALSE for all non-ASCII characters. Also unlike the standard
+library function, this takes a char, not an int, so don't call it
+on EOF but no need to cast to guchar before passing a possibly
+non-ASCII character in.
+</para>
+
+@c: any characted
+@Returns: %TRUE if @c is an ASCII printing character.
+
+
+<!-- ##### FUNCTION g_ascii_ispunct ##### -->
+<para>
+Determines whether a character is a punctuation character.
+</para>
+<para>
+Unlike the standard C library ispunct function, this only
+recognizes standard ASCII letters and ignores the locale, returning
+%FALSE for all non-ASCII characters. Also unlike the standard
+library function, this takes a char, not an int, so don't call it
+on EOF but no need to cast to guchar before passing a possibly
+non-ASCII character in.
+</para>
+
+@c: any characted
+@Returns: %TRUE if @c is an ASCII punctuation character.
+
+
+<!-- ##### FUNCTION g_ascii_isspace ##### -->
+<para>
+Determines whether a character is a white-space character.
+</para>
+<para>
+Unlike the standard C library isspace function, this only
+recognizes standard ASCII white-space and ignores the locale, returning
+%FALSE for all non-ASCII characters. Also unlike the standard
+library function, this takes a char, not an int, so don't call it
+on EOF but no need to cast to guchar before passing a possibly
+non-ASCII character in.
+</para>
+
+@c: any characted
+@Returns: %TRUE if @c is an ASCII white-space character
+
+
+<!-- ##### FUNCTION g_ascii_isupper ##### -->
+<para>
+Determines whether a character is an ASCII upper case letter.
+</para>
+<para>
+Unlike the standard C library isupper function, this only
+recognizes standard ASCII letters and ignores the locale, returning
+%FALSE for all non-ASCII characters. Also unlike the standard
+library function, this takes a char, not an int, so don't call it
+on EOF but no need to worry about casting to guchar before passing
+a possibly non-ASCII character in.
+</para>
+
+@c: any characted
+@Returns: %TRUE if @c is an ASCII upper case letter
+
+
+<!-- ##### FUNCTION g_ascii_isxdigit ##### -->
+<para>
+Determines whether a character is a hexadecimal-digit character.
+</para>
+<para>
+Unlike the standard C library isxdigit function, this only
+recognizes standard ASCII hexadecimal digits and ignores the
+locale, returning %FALSE for all non-ASCII characters. Also unlike
+the standard library function, this takes a char, not an int, so
+don't call it on EOF but no need to cast to guchar before passing a
+possibly non-ASCII character in.
+</para>
+
+@c: any characted
+@Returns: %TRUE if @c is an ASCII hexadecimal-digit character.
+
+
+<!-- ##### FUNCTION g_ascii_digit_value ##### -->
+<para>
+
+</para>
+
+@c: 
+@Returns: 
+
+
+<!-- ##### FUNCTION g_ascii_xdigit_value ##### -->
+<para>
+
+</para>
+
+@c: 
+@Returns: 
+
+
+<!-- ##### FUNCTION g_ascii_strcasecmp ##### -->
+<para>
+
+</para>
+
+@s1: 
+@s2: 
+@Returns: 
+
+
+<!-- ##### FUNCTION g_ascii_strncasecmp ##### -->
+<para>
+
+</para>
+
+@s1: 
+@s2: 
+@n: 
+@Returns: 
+
+
+<!-- ##### FUNCTION g_ascii_strup ##### -->
+<para>
+
+</para>
+
+@string: 
+@Returns: 
+
+
+<!-- ##### FUNCTION g_ascii_strdown ##### -->
+<para>
+
+</para>
+
+@string: 
+@Returns: 
+
+
+<!-- ##### FUNCTION g_ascii_tolower ##### -->
+<para>
+
+</para>
+
+@c: 
+@Returns: 
+
+
+<!-- ##### FUNCTION g_ascii_toupper ##### -->
+<para>
+
+</para>
+
+@c: 
+@Returns: 
+
+
+<!-- ##### FUNCTION g_string_ascii_up ##### -->
+<para>
+
+</para>
+
+@string: 
+@Returns: 
+
+
+<!-- ##### FUNCTION g_string_ascii_down ##### -->
+<para>
+
+</para>
+
+@string: 
+@Returns: 
+
+
 <!-- ##### FUNCTION g_strup ##### -->
 <para>
 Converts a string to upper case.
index 45dfe95..eb0393d 100644 (file)
  * inteferes with g_strsignal() on some OSes
  */
 
+const guint16 g_ascii_table[256] = {
+  0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
+  0x004, 0x104, 0x104, 0x004, 0x104, 0x104, 0x004, 0x004,
+  0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
+  0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
+  0x140, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,
+  0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,
+  0x459, 0x459, 0x459, 0x459, 0x459, 0x459, 0x459, 0x459,
+  0x459, 0x459, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,
+  0x0d0, 0x653, 0x653, 0x653, 0x653, 0x653, 0x653, 0x253,
+  0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253,
+  0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253,
+  0x253, 0x253, 0x253, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,
+  0x0d0, 0x473, 0x473, 0x473, 0x473, 0x473, 0x473, 0x073,
+  0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073,
+  0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073,
+  0x073, 0x073, 0x073, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x004
+  /* the upper 128 are all zeroes */
+};
+
 gchar*
 g_strdup (const gchar *str)
 {
@@ -1081,91 +1101,6 @@ g_strreverse (gchar *string)
 }
 
 /**
- * g_ascii_isalpha:
- * @c: any character
- * 
- * Determines whether a character is alphabetic (i.e. a letter).
- *
- * Unlike the standard C library isalpha function, this only
- * recognizes standard ASCII letters and ignores the locale, returning
- * %FALSE for all non-ASCII characters. Also unlike the standard
- * library function, this takes a char, not an int, so don't call it
- * on EOF but no need to cast to guchar before passing a possibly
- * non-ASCII character in.
- * 
- * Return value: %TRUE if @c is an ASCII alphabetic character
- **/
-gboolean
-g_ascii_isalpha (gchar c)
-{
-  return g_ascii_islower (c) || g_ascii_isupper (c);
-}
-
-/**
- * g_ascii_isalnum:
- * @c: any character
- * 
- * Determines whether a character is alphanumeric.
- *
- * Unlike the standard C library isalnum function, this only
- * recognizes standard ASCII letters and ignores the locale, returning
- * %FALSE for all non-ASCII characters. Also unlike the standard
- * library function, this takes a char, not an int, so don't call it
- * on EOF but no need to cast to guchar before passing a possibly
- * non-ASCII character in.
- * 
- * Return value: %TRUE if @c is an ASCII alphanumeric character
- **/
-gboolean
-g_ascii_isalnum (gchar c)
-{
-  return g_ascii_isalpha (c) || isdigit (c);
-}
-
-
-/**
- * g_ascii_islower:
- * @c: any character
- * 
- * Determines whether a character is an ASCII lower case letter.
- *
- * Unlike the standard C library islower function, this only
- * recognizes standard ASCII letters and ignores the locale, returning
- * %FALSE for all non-ASCII characters. Also unlike the standard
- * library function, this takes a char, not an int, so don't call it
- * on EOF but no need to worry about casting to guchar before passing
- * a possibly non-ASCII character in.
- * 
- * Return value: %TRUE if @c is an ASCII lower case letter
- **/
-gboolean
-g_ascii_islower (gchar c)
-{
-  return c >= 'a' && c <= 'z';
-}
-
-/**
- * g_ascii_isupper:
- * @c: any character
- * 
- * Determines whether a character is an ASCII upper case letter.
- *
- * Unlike the standard C library isupper function, this only
- * recognizes standard ASCII letters and ignores the locale, returning
- * %FALSE for all non-ASCII characters. Also unlike the standard
- * library function, this takes a char, not an int, so don't call it
- * on EOF but no need to worry about casting to guchar before passing
- * a possibly non-ASCII character in.
- * 
- * Return value: %TRUE if @c is an ASCII upper case letter
- **/
-gboolean
-g_ascii_isupper (gchar c)
-{
-  return c >= 'A' && c <= 'Z';
-}
-
-/**
  * g_ascii_tolower:
  * @c: any character
  * 
@@ -1214,6 +1149,48 @@ g_ascii_toupper (gchar c)
 }
 
 /**
+ * g_ascii_digit_value:
+ * @c: an ASCII character
+ *
+ * Determines the numeric value of a character as a decimal
+ * digit. Differs from g_unichar_digit_value because it takes
+ * a char, so there's no worry about sign extension if characters
+ * are signed.
+ *
+ * Return value: If @c is a decimal digit (according to
+ * `g_ascii_isdigit'), its numeric value. Otherwise, -1.
+ **/
+int
+g_ascii_digit_value (gchar c)
+{
+  if (g_ascii_isdigit (c))
+    return c - '0';
+  return -1;
+}
+
+/**
+ * g_ascii_xdigit_value:
+ * @c: an ASCII character
+ *
+ * Determines the numeric value of a character as a hexidecimal
+ * digit. Differs from g_unichar_xdigit_value because it takes
+ * a char, so there's no worry about sign extension if characters
+ * are signed.
+ *
+ * Return value: If @c is a hex digit (according to
+ * `g_ascii_isxdigit'), its numeric value. Otherwise, -1.
+ **/
+int
+g_ascii_xdigit_value (gchar c)
+{
+  if (c >= 'A' && c <= 'F')
+    return c - 'A' + 10;
+  if (c >= 'a' && c <= 'f')
+    return c - 'a' + 10;
+  return g_ascii_digit_value (c);
+}
+
+/**
  * g_ascii_strcasecmp:
  * @s1: string to compare with @s2
  * @s2: string to compare with @s1
index 4346266..95667aa 100644 (file)
 G_BEGIN_DECLS
 
 /* Functions like the ones in <ctype.h> that are not affected by locale. */
-gboolean              g_ascii_isalpha  (gchar        c) G_GNUC_CONST;
-gboolean              g_ascii_isalnum  (gchar        c) G_GNUC_CONST;
-gboolean              g_ascii_islower  (gchar        c) G_GNUC_CONST;
-gboolean              g_ascii_isupper  (gchar        c) G_GNUC_CONST;
+typedef enum {
+  G_ASCII_ALNUM  = 1 << 0,
+  G_ASCII_ALPHA  = 1 << 1,
+  G_ASCII_CNTRL  = 1 << 2,
+  G_ASCII_DIGIT  = 1 << 3,
+  G_ASCII_GRAPH  = 1 << 4,
+  G_ASCII_LOWER  = 1 << 5,
+  G_ASCII_PRINT  = 1 << 6,
+  G_ASCII_PUNCT  = 1 << 7,
+  G_ASCII_SPACE  = 1 << 8,
+  G_ASCII_UPPER  = 1 << 9,
+  G_ASCII_XDIGIT = 1 << 10
+} GAsciiType;
+
+extern const guint16 g_ascii_table[256];
+
+#define g_ascii_isalnum(c) \
+  ((g_ascii_table[(guchar) (c)] & G_ASCII_ALNUM) != 0)
+
+#define g_ascii_isalpha(c) \
+  ((g_ascii_table[(guchar) (c)] & G_ASCII_ALPHA) != 0)
+
+#define g_ascii_iscntrl(c) \
+  ((g_ascii_table[(guchar) (c)] & G_ASCII_CNTRL) != 0)
+
+#define g_ascii_isdigit(c) \
+  ((g_ascii_table[(guchar) (c)] & G_ASCII_DIGIT) != 0)
+
+#define g_ascii_isgraph(c) \
+  ((g_ascii_table[(guchar) (c)] & G_ASCII_GRAPH) != 0)
+
+#define g_ascii_islower(c) \
+  ((g_ascii_table[(guchar) (c)] & G_ASCII_LOWER) != 0)
+
+#define g_ascii_isprint(c) \
+  ((g_ascii_table[(guchar) (c)] & G_ASCII_PRINT) != 0)
+
+#define g_ascii_ispunct(c) \
+  ((g_ascii_table[(guchar) (c)] & G_ASCII_PUNCT) != 0)
+
+#define g_ascii_isspace(c) \
+  ((g_ascii_table[(guchar) (c)] & G_ASCII_SPACE) != 0)
+
+#define g_ascii_isupper(c) \
+  ((g_ascii_table[(guchar) (c)] & G_ASCII_UPPER) != 0)
+
+#define g_ascii_isxdigit(c) \
+  ((g_ascii_table[(guchar) (c)] & G_ASCII_XDIGIT) != 0)
+
 gchar                 g_ascii_tolower  (gchar        c) G_GNUC_CONST;
 gchar                 g_ascii_toupper  (gchar        c) G_GNUC_CONST;
 
+gint                  g_ascii_digit_value  (gchar    c) G_GNUC_CONST;
+gint                  g_ascii_xdigit_value (gchar    c) G_GNUC_CONST;
+
 /* String utility functions that modify a string argument or
  * return a constant string that must not be freed.
  */
index 45bc186..4eb6370 100644 (file)
@@ -190,11 +190,11 @@ g_unichar_isprint (gunichar c)
  * g_unichar_ispunct:
  * @c: a Unicode character
  * 
- * Determines whether a character is punctuation.
+ * Determines whether a character is punctuation or a symbol.
  * Given some UTF-8 text, obtain a character value with
  * g_utf8_get_char().
  * 
- * Return value: %TRUE if @c is a punctuation character
+ * Return value: %TRUE if @c is a punctuation or symbol character
  **/
 gboolean
 g_unichar_ispunct (gunichar c)
@@ -203,7 +203,9 @@ g_unichar_ispunct (gunichar c)
   return (t == G_UNICODE_CONNECT_PUNCTUATION || t == G_UNICODE_DASH_PUNCTUATION
          || t == G_UNICODE_CLOSE_PUNCTUATION || t == G_UNICODE_FINAL_PUNCTUATION
          || t == G_UNICODE_INITIAL_PUNCTUATION || t == G_UNICODE_OTHER_PUNCTUATION
-         || t == G_UNICODE_OPEN_PUNCTUATION);
+         || t == G_UNICODE_OPEN_PUNCTUATION || t == G_UNICODE_CURRENCY_SYMBOL
+         || t == G_UNICODE_MODIFIER_SYMBOL || t == G_UNICODE_MATH_SYMBOL
+         || t == G_UNICODE_OTHER_SYMBOL);
 }
 
 /**
@@ -230,7 +232,6 @@ g_unichar_isspace (gunichar c)
     case '\n':
     case '\r':
     case '\f':
-    case '\v': /* vertical tab - as if anyone has ever used this... */
       return TRUE;
       break;
       
@@ -444,7 +445,7 @@ g_unichar_totitle (gunichar c)
  * @c: a unicode character
  *
  * Determines the numeric value of a character as a decimal
- * degital.
+ * digit.
  *
  * Return value: If @c is a decimal digit (according to
  * `g_unichar_isdigit'), its numeric value. Otherwise, -1.
@@ -462,7 +463,7 @@ g_unichar_digit_value (gunichar c)
  * @c: a unicode character
  *
  * Determines the numeric value of a character as a hexidecimal
- * degital.
+ * digit.
  *
  * Return value: If @c is a hex digit (according to
  * `g_unichar_isxdigit'), its numeric value. Otherwise, -1.
index 378c918..e960412 100644 (file)
@@ -95,25 +95,23 @@ print_test (const gchar *cmdline, gint argc, gchar **argv,
 {
   gint i;
   
-  printf ("\nCommand line was: '%s'\n", cmdline);
+  fprintf (stderr, "Command line was: '%s'\n", cmdline);
 
-  printf ("Expected result (%d args):\n", result->argc);
+  fprintf (stderr, "Expected result (%d args):\n", result->argc);
   
   i = 0;
   while (result->argv[i])
     {
-      printf (" %3d '%s'\n", i, result->argv[i]);
-
+      fprintf (stderr, " %3d '%s'\n", i, result->argv[i]);
       ++i;
     }  
 
-  printf ("Actual result (%d args):\n", argc);
+  fprintf (stderr, "Actual result (%d args):\n", argc);
   
   i = 0;
   while (argv[i])
     {
-      printf (" %3d '%s'\n", i, argv[i]);
-
+      fprintf (stderr, " %3d '%s'\n", i, argv[i]);
       ++i;
     }
 }
@@ -170,10 +168,7 @@ run_tests (void)
   i = 0;
   while (test_command_lines[i])
     {
-      printf ("g_shell_parse_argv() test %d - ", i);
       do_argv_test (test_command_lines[i], &correct_results[i]);
-      printf ("ok (%s)\n", test_command_lines[i]);
-      
       ++i;
     }
 }
index 9255233..30ff116 100644 (file)
@@ -30,6 +30,7 @@
 #include <string.h>
 #include "glib.h"
 #include <stdarg.h>
+#include <ctype.h>
 
 static gboolean any_failed = FALSE;
 static gboolean failed = FALSE;
@@ -37,15 +38,17 @@ static gboolean failed = FALSE;
 #define        TEST(m,cond)    G_STMT_START { failed = !(cond); \
 if (failed) \
   { if (!m) \
-      g_print ("\n(%s:%d) failed for: %s\n", __FILE__, __LINE__, ( # cond )); \
+      g_print ("(%s:%d) failed for: %s\n", __FILE__, __LINE__, ( # cond )); \
     else \
-      g_print ("\n(%s:%d) failed for: %s: (%s)\n", __FILE__, __LINE__, ( # cond ), (gchar*)m); \
-      any_failed = TRUE; \
+      g_print ("(%s:%d) failed for: %s: (%s)\n", __FILE__, __LINE__, ( # cond ), (gchar*)m); \
+    fflush (stdout); \
+    any_failed = TRUE; \
   } \
-else \
-  g_print ("."); fflush (stdout); \
 } G_STMT_END
 
+#define TEST_FAILED(message) \
+  G_STMT_START { g_print ("Error: "); g_print message; g_print ("\n"); any_failed = TRUE; } G_STMT_END
+
 #define GLIB_TEST_STRING "el dorado "
 
 static gboolean
@@ -77,6 +80,156 @@ strv_check (gchar **strv, ...)
   return ok;
 }
 
+static gboolean
+test_isalnum (gchar c)
+{
+  return g_ascii_isalnum (c);
+}
+
+static gboolean
+test_isalpha (gchar c)
+{
+  return g_ascii_isalpha (c);
+}
+
+static gboolean
+test_iscntrl (gchar c)
+{
+  return g_ascii_iscntrl (c);
+}
+
+static gboolean
+test_isdigit (gchar c)
+{
+  return g_ascii_isdigit (c);
+}
+
+static gboolean
+test_isgraph (gchar c)
+{
+  return g_ascii_isgraph (c);
+}
+
+static gboolean
+test_islower (gchar c)
+{
+  return g_ascii_islower (c);
+}
+
+static gboolean
+test_isprint (gchar c)
+{
+  return g_ascii_isprint (c);
+}
+
+static gboolean
+test_ispunct (gchar c)
+{
+  return g_ascii_ispunct (c);
+}
+
+static gboolean
+test_isspace (gchar c)
+{
+  return g_ascii_isspace (c);
+}
+
+static gboolean
+test_isupper (gchar c)
+{
+  return g_ascii_isupper (c);
+}
+
+static gboolean
+test_isxdigit (gchar c)
+{
+  return g_ascii_isxdigit (c);
+}
+
+
+
+static void
+test_is_function (const char *name,
+                 gboolean (* ascii_function) (gchar),
+                 int (* c_library_function) (int),
+                 gboolean (* unicode_function) (gunichar))
+{
+  int c;
+
+  for (c = 0; c <= 0x7F; c++)
+    {
+      gboolean ascii_result = ascii_function ((gchar)c);
+      gboolean c_library_result = c_library_function (c) != 0;
+      gboolean unicode_result = unicode_function ((gunichar) c);
+      if (ascii_result != c_library_result && c != '\v')
+       TEST_FAILED (("g_ascii_%s returned %d and %s returned %d for 0x%X",
+                     name, ascii_result, name, c_library_result, c));
+      if (ascii_result != unicode_result)
+       TEST_FAILED (("g_ascii_%s returned %d and g_unichar_%s returned %d for 0x%X",
+                     name, ascii_result, name, unicode_result, c));
+    }
+  for (c = 0x80; c <= 0xFF; c++)
+    {
+      gboolean ascii_result = ascii_function ((gchar)c);
+      if (ascii_result)
+       TEST_FAILED (("g_ascii_%s returned TRUE for 0x%X",
+                     name, c));
+    }
+}
+
+static void
+test_to_function (const char *name,
+                 gchar (* ascii_function) (gchar),
+                 int (* c_library_function) (int),
+                 gunichar (* unicode_function) (gunichar))
+{
+  int c;
+
+  for (c = 0; c <= 0x7F; c++)
+    {
+      int ascii_result = (guchar) ascii_function ((gchar) c);
+      int c_library_result = c_library_function (c);
+      int unicode_result = unicode_function ((gunichar) c);
+      if (ascii_result != c_library_result)
+       TEST_FAILED (("g_ascii_%s returned 0x%X and %s returned 0x%X for 0x%X",
+                     name, ascii_result, name, c_library_result, c));
+      if (ascii_result != unicode_result)
+       TEST_FAILED (("g_ascii_%s returned 0x%X and g_unichar_%s returned 0x%X for 0x%X",
+                     name, ascii_result, name, unicode_result, c));
+    }
+  for (c = 0x80; c <= 0xFF; c++)
+    {
+      int ascii_result = (guchar) ascii_function ((gchar) c);
+      if (ascii_result != c)
+       TEST_FAILED (("g_ascii_%s returned 0x%X for 0x%X",
+                     name, ascii_result, c));
+    }
+}
+
+static void
+test_digit_function (const char *name,
+                    int (* ascii_function) (gchar),
+                    int (* unicode_function) (gunichar))
+{
+  int c;
+
+  for (c = 0; c <= 0x7F; c++)
+    {
+      int ascii_result = ascii_function ((gchar) c);
+      int unicode_result = unicode_function ((gunichar) c);
+      if (ascii_result != unicode_result)
+       TEST_FAILED (("g_ascii_%s_value returned %d and g_unichar_%s_value returned %d for 0x%X",
+                     name, ascii_result, name, unicode_result, c));
+    }
+  for (c = 0x80; c <= 0xFF; c++)
+    {
+      int ascii_result = ascii_function ((gchar) c);
+      if (ascii_result != -1)
+       TEST_FAILED (("g_ascii_%s_value returned %d for 0x%X",
+                     name, ascii_result, c));
+    }
+}
+
 int
 main (int   argc,
       char *argv[])
@@ -171,7 +324,35 @@ main (int   argc,
   TEST (NULL, strv_check (g_strsplit (",,x,,y,,z,,", ",", 2), "", ",x,,y,,z,,", NULL));
   TEST (NULL, strv_check (g_strsplit (",,x,,y,,z,,", ",,", 2), "", "x,,y,,z,,", NULL));
 
-  g_print ("\n");
+  #define TEST_IS(name) test_is_function (#name, test_##name, name, g_unichar_##name)
+
+  TEST_IS (isalnum);
+  TEST_IS (isalpha);
+  TEST_IS (iscntrl);
+  TEST_IS (isdigit);
+  TEST_IS (isgraph);
+  TEST_IS (islower);
+  TEST_IS (isprint);
+  TEST_IS (ispunct);
+  TEST_IS (isspace);
+  TEST_IS (isupper);
+  TEST_IS (isxdigit);
+
+  #undef TEST_IS
+
+  #define TEST_TO(name) test_to_function (#name, g_ascii_##name, name, g_unichar_##name)
+
+  TEST_TO (tolower);
+  TEST_TO (toupper);
+
+  #undef TEST_TO
+
+  #define TEST_DIGIT(name) test_digit_function (#name, g_ascii_##name##_value, g_unichar_##name##_value)
+
+  TEST_DIGIT (digit);
+  TEST_DIGIT (xdigit);
+
+  #undef TEST_DIGIT
 
   return any_failed;
 }