Index: src/glob.c
==================================================================
--- src/glob.c
+++ src/glob.c
@@ -29,16 +29,17 @@
 **    zVal:       "x"
 **    zGlobList:  "*.o,*.obj"
 **
 **    Result:     "(x GLOB '*.o' OR x GLOB '*.obj')"
 **
-** Each element of the GLOB list may optionally be enclosed in either '...'
-** or "...".  This allows commas in the expression.  Whitespace at the
-** beginning and end of each GLOB pattern is ignored, except when enclosed
-** within '...' or "...".
+** Commas and whitespace are considered to be element delimters.  Each
+** element of the GLOB list may optionally be enclosed in either '...' or
+** "...".  This allows commas and/or whitespace to be used in the elements
+** themselves.
 **
-** This routine makes no effort to free the memory space it uses.
+** This routine makes no effort to free the memory space it uses, which
+** currently consists of a blob object and its contents.
 */
 char *glob_expr(const char *zVal, const char *zGlobList){
   Blob expr;
   char *zSep = "(";
   int nTerm = 0;
@@ -46,21 +47,24 @@
   int cTerm;
 
   if( zGlobList==0 || zGlobList[0]==0 ) return "0";
   blob_zero(&expr);
   while( zGlobList[0] ){
-    while( fossil_isspace(zGlobList[0]) || zGlobList[0]==',' ) zGlobList++;
+    while( fossil_isspace(zGlobList[0]) || zGlobList[0]==',' ){
+      zGlobList++;  /* Skip leading commas, spaces, and newlines */
+    }
     if( zGlobList[0]==0 ) break;
     if( zGlobList[0]=='\'' || zGlobList[0]=='"' ){
       cTerm = zGlobList[0];
       zGlobList++;
     }else{
       cTerm = ',';
     }
-    for(i=0; zGlobList[i] && zGlobList[i]!=cTerm && zGlobList[i]!='\n'; i++){}
-    if( cTerm==',' ){
-      while( i>0 && fossil_isspace(zGlobList[i-1]) ){ i--; }
+    /* Find the next delimter (or the end of the string). */
+    for(i=0; zGlobList[i] && zGlobList[i]!=cTerm; i++){
+      if( cTerm!=',' ) continue; /* If quoted, keep going. */
+      if( fossil_isspace(zGlobList[i]) ) break; /* If space, stop. */
     }
     blob_appendf(&expr, "%s%s GLOB '%#q'", zSep, zVal, i, zGlobList);
     zSep = " OR ";
     if( cTerm!=',' && zGlobList[i] ) i++;
     zGlobList += i;
@@ -85,24 +89,24 @@
   char **azPattern;    /* Array of pointers to patterns */
 };
 #endif /* INTERFACE */
 
 /*
-** zPatternList is a comma-separate list of glob patterns.  Parse up
+** zPatternList is a comma-separated list of glob patterns.  Parse up
 ** that list and use it to create a new Glob object.
 **
 ** Elements of the glob list may be optionally enclosed in single our
-** double-quotes.  This allows a comma to be part of a glob.
+** double-quotes.  This allows a comma to be part of a glob pattern.
 **
 ** Leading and trailing spaces on unquoted glob patterns are ignored.
 **
 ** An empty or null pattern list results in a null glob, which will
 ** match nothing.
 */
 Glob *glob_create(const char *zPatternList){
   int nList;         /* Size of zPatternList in bytes */
-  int i, j;          /* Loop counters */
+  int i;             /* Loop counters */
   Glob *p;           /* The glob being created */
   char *z;           /* Copy of the pattern list */
   char delimiter;    /* '\'' or '\"' or 0 */
 
   if( zPatternList==0 || zPatternList[0]==0 ) return 0;
@@ -110,27 +114,26 @@
   p = fossil_malloc( sizeof(*p) + nList+1 );
   memset(p, 0, sizeof(*p));
   z = (char*)&p[1];
   memcpy(z, zPatternList, nList+1);
   while( z[0] ){
-    while( z[0]==',' || z[0]==' ' || z[0]=='\n' || z[0]=='\r' ){
-      z++;  /* Skip leading spaces and newlines */
+    while( fossil_isspace(z[0]) || z[0]==',' ){
+      z++;  /* Skip leading commas, spaces, and newlines */
     }
+    if( z[0]==0 ) break;
     if( z[0]=='\'' || z[0]=='"' ){
       delimiter = z[0];
       z++;
     }else{
       delimiter = ',';
     }
-    if( z[0]==0 ) break;
     p->azPattern = fossil_realloc(p->azPattern, (p->nPattern+1)*sizeof(char*) );
     p->azPattern[p->nPattern++] = z;
-    for(i=0; z[i] && z[i]!=delimiter && z[i]!='\n' && z[i]!='\r'; i++){}
-    if( delimiter==',' ){
-      /* Remove trailing spaces / newlines on a comma-delimited pattern */
-      for(j=i; j>1 && (z[j-1]==' ' || z[j-1]=='\n' || z[j-1]=='\r'); j--){}
-      if( j<i ) z[j] = 0;
+    /* Find the next delimter (or the end of the string). */
+    for(i=0; z[i] && z[i]!=delimiter; i++){
+      if( delimiter!=',' ) continue; /* If quoted, keep going. */
+      if( fossil_isspace(z[i]) ) break; /* If space, stop. */
     }
     if( z[i]==0 ) break;
     z[i] = 0;
     z += i+1;
   }
@@ -245,22 +248,35 @@
 /*
 ** COMMAND: test-glob
 **
 ** Usage:  %fossil test-glob PATTERN STRING...
 **
-** PATTERN is a comma-separated list of glob patterns.  Show which of
-** the STRINGs that follow match the PATTERN.
+** PATTERN is a comma- and whitespace-separated list of optionally
+** quoted glob patterns.  Show which of the STRINGs that follow match
+** the PATTERN.
+**
+** If PATTERN begins with "@" the the rest of the pattern is understood
+** to be a setting name (such as binary-glob, crln-glob, or encoding-glob)
+** and the value of that setting is used as the actually glob pattern.
 */
 void glob_test_cmd(void){
   Glob *pGlob;
   int i;
+  char *zPattern;
   if( g.argc<4 ) usage("PATTERN STRING ...");
-  fossil_print("SQL expression: %s\n", glob_expr("x", g.argv[2]));
-  pGlob = glob_create(g.argv[2]);
+  zPattern = g.argv[2];
+  if( zPattern[0]=='@' ){
+    db_find_and_open_repository(OPEN_ANY_SCHEMA,0);
+    zPattern = db_get(zPattern+1, 0);
+    if( zPattern==0 ) fossil_fatal("no such setting: %s", g.argv[2]+1);
+    fossil_print("GLOB pattern: %s\n", zPattern);
+  }
+  fossil_print("SQL expression: %s\n", glob_expr("x", zPattern));
+  pGlob = glob_create(zPattern);
   for(i=0; i<pGlob->nPattern; i++){
     fossil_print("pattern[%d] = [%s]\n", i, pGlob->azPattern[i]);
   }
   for(i=3; i<g.argc; i++){
     fossil_print("%d %s\n", glob_match(pGlob, g.argv[i]), g.argv[i]);
   }
   glob_free(pGlob);
 }

ADDED   test/glob.test
Index: test/glob.test
==================================================================
--- /dev/null
+++ test/glob.test
@@ -0,0 +1,184 @@
+#
+# Copyright (c) 2013 D. Richard Hipp
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the Simplified BSD License (also
+# known as the "2-Clause License" or "FreeBSD License".)
+#
+# This program is distributed in the hope that it will be useful,
+# but without any warranty; without even the implied warranty of
+# merchantability or fitness for a particular purpose.
+#
+# Author contact information:
+#   drh@hwaci.com
+#   http://www.hwaci.com/drh/
+#
+############################################################################
+#
+# Test glob pattern parsing
+#
+
+proc glob-parse {testname args} {
+  set i 1
+  foreach {pattern string result} $args {
+    fossil test-glob $pattern $string
+    test glob-parse-$testname.$i {$::RESULT eq $result}
+    incr i
+  }
+}
+
+glob-parse 100 test test [string map [list \r\n \n] \
+{SQL expression: (x GLOB 'test')
+pattern[0] = [test]
+1 test}]
+
+glob-parse 101 "one two" one [string map [list \r\n \n] \
+{SQL expression: (x GLOB 'one' OR x GLOB 'two')
+pattern[0] = [one]
+pattern[1] = [two]
+1 one}]
+
+glob-parse 102 t* test [string map [list \r\n \n] \
+{SQL expression: (x GLOB 't*')
+pattern[0] = [t*]
+1 test}]
+
+glob-parse 103 "o* two" one [string map [list \r\n \n] \
+{SQL expression: (x GLOB 'o*' OR x GLOB 'two')
+pattern[0] = [o*]
+pattern[1] = [two]
+1 one}]
+
+glob-parse 104 {"o* two" "three four"} "one two" [string map [list \r\n \n] \
+{SQL expression: (x GLOB 'o* two' OR x GLOB 'three four')
+pattern[0] = [o* two]
+pattern[1] = [three four]
+1 one two}]
+
+glob-parse 105 {"o* two" "three four"} "two one" [string map [list \r\n \n] \
+{SQL expression: (x GLOB 'o* two' OR x GLOB 'three four')
+pattern[0] = [o* two]
+pattern[1] = [three four]
+0 two one}]
+
+glob-parse 106 "\"o*\ntwo\" \"three\nfour\"" "one\ntwo" \
+[string map [list \r\n \n] \
+{SQL expression: (x GLOB 'o*
+two' OR x GLOB 'three
+four')
+pattern[0] = [o*
+two]
+pattern[1] = [three
+four]
+1 one
+two}]
+
+glob-parse 107 "\"o*\ntwo\" \"three\nfour\"" "two\none" \
+[string map [list \r\n \n] \
+{SQL expression: (x GLOB 'o*
+two' OR x GLOB 'three
+four')
+pattern[0] = [o*
+two]
+pattern[1] = [three
+four]
+0 two
+one}]
+
+glob-parse 108 "\"o*\rtwo\" \"three\rfour\"" "one\rtwo" \
+[string map [list \r\n \n] \
+{SQL expression: (x GLOB 'o*
+two' OR x GLOB 'three
+four')
+pattern[0] = [o*
+two]
+pattern[1] = [three
+four]
+1 one
+two}]
+
+glob-parse 109 "\"o*\rtwo\" \"three\rfour\"" "two\rone" \
+[string map [list \r\n \n] \
+{SQL expression: (x GLOB 'o*
+two' OR x GLOB 'three
+four')
+pattern[0] = [o*
+two]
+pattern[1] = [three
+four]
+0 two
+one}]
+
+glob-parse 110 "'o*\ntwo' 'three\nfour'" "one\ntwo" \
+[string map [list \r\n \n] \
+{SQL expression: (x GLOB 'o*
+two' OR x GLOB 'three
+four')
+pattern[0] = [o*
+two]
+pattern[1] = [three
+four]
+1 one
+two}]
+
+glob-parse 111 "'o*\ntwo' 'three\nfour'" "two\none" \
+[string map [list \r\n \n] \
+{SQL expression: (x GLOB 'o*
+two' OR x GLOB 'three
+four')
+pattern[0] = [o*
+two]
+pattern[1] = [three
+four]
+0 two
+one}]
+
+glob-parse 112 "\"'o*' 'two'\" \"'three' 'four'\"" "'one' 'two'" \
+[string map [list \r\n \n] \
+{SQL expression: (x GLOB '''o*'' ''two''' OR x GLOB '''three'' ''four''')
+pattern[0] = ['o*' 'two']
+pattern[1] = ['three' 'four']
+1 'one' 'two'}]
+
+glob-parse 113 "\"'o*' 'two'\" \"'three' 'four'\"" "two one" \
+[string map [list \r\n \n] \
+{SQL expression: (x GLOB '''o*'' ''two''' OR x GLOB '''three'' ''four''')
+pattern[0] = ['o*' 'two']
+pattern[1] = ['three' 'four']
+0 two one}]
+
+glob-parse 114 o*,two one [string map [list \r\n \n] \
+{SQL expression: (x GLOB 'o*' OR x GLOB 'two')
+pattern[0] = [o*]
+pattern[1] = [two]
+1 one}]
+
+glob-parse 115 "o*,two three,four" "one two" [string map [list \r\n \n] \
+{SQL expression: (x GLOB 'o*' OR x GLOB 'two' OR x GLOB 'three' OR x GLOB 'four')
+pattern[0] = [o*]
+pattern[1] = [two]
+pattern[2] = [three]
+pattern[3] = [four]
+1 one two}]
+
+glob-parse 116 'o*,two' one [string map [list \r\n \n] \
+{SQL expression: (x GLOB 'o*,two')
+pattern[0] = [o*,two]
+0 one}]
+
+glob-parse 117 'o*,two' one,two [string map [list \r\n \n] \
+{SQL expression: (x GLOB 'o*,two')
+pattern[0] = [o*,two]
+1 one,two}]
+
+glob-parse 118 "'o*,two three,four'" "one two three,four" \
+[string map [list \r\n \n] \
+{SQL expression: (x GLOB 'o*,two three,four')
+pattern[0] = [o*,two three,four]
+0 one two three,four}]
+
+glob-parse 119 "'o*,two three,four'" "one,two three,four" \
+[string map [list \r\n \n] \
+{SQL expression: (x GLOB 'o*,two three,four')
+pattern[0] = [o*,two three,four]
+1 one,two three,four}]