Merge ~dirk.zimoch/epics-base:chfPluginImprovements into epics-base:7.0

[Dirk Zimoch]

Improved channel filter plugin interface

1. Allow string arguments with arbitrarily long strings.
In addition to the chfPluginArgString argument type which works on fixed size char array members, chfPluginArgStringAlloc works on char* members. It performs the following actions:
* If a chfPluginArgStringAlloc is provided by the user, the char* member is first NULLed, then filled with a dynamically allocated string (which may fail due to memory shortage)
* If the same char* member may be provided multiple times (maybe under different names), the old value is freed before a new value is written.
* When the structure is released (before freePvt is called), the allocated strings are automatically freed and the char* member NULLed.
* If the parameter is optional and not provided my the user, the pointer is left untouched, allowing to initialize the char* member with a static string as a default value.
2. Allow short forms for filters with 1 or 0 parameters
* If only 1 parameter is required, {filter:value} can be used instead of {filter:{parameter:value}}
* If no parameter is requires, {filter} can be used instead of {filter:{}}
3. Documentarion changed: Use JSON5 features in examples.

[Dirk Zimoch (dirk.zimoch)]

Question: Should the old chfPluginArgString be dropped and be replaced by the new chfPluginArgStringAlloc support (redefining the meaning of chfPluginArgString)?

[Dirk Zimoch (dirk.zimoch)]

Additional plan: Implement shortcut for one parameter.

If there is exacly one mandatory parameter, allow a shortcut without using an object.
Instead of: {filter:{onlyparameter:value}}
allow: {filter:value}

[Dirk Zimoch (dirk.zimoch)]

Now the short form works if there is only one parameter or only one parameter is mandatory (which means it is clear which parameter is meant).
Example: The "dec" filter:
Instead of: record.{dec:{n:5}} one can use record.{dec:5}

ab85813... by Dirk Zimoch on 2021-03-17

typo fixed

c1b22d0... by Dirk Zimoch on 2021-03-18

allow arbritrary state name length

06f8a37... by Dirk Zimoch on 2021-03-18

simplified filter syntax for only one argument

[Dirk Zimoch (dirk.zimoch)]

Re-pushed, this time with tests.

4395cf4... by Dirk Zimoch on 2021-03-19

simplified filter syntax for no argument

[Dirk Zimoch (dirk.zimoch)]

Another short form: If no argument at all is needed then just the filter name is sufficient (no :{} needed). Example: caget -a "record.{ts}"
I know this is not valid JSON5, but it is convenient and intuitive and works.
Can be stacked with other filters without problems: caget -a "record.{ts,arr:{i:3},dec:1}"
The filter is created as if called with {}.

[Andrew Johnson (anj)]

Most of this looks great (although I haven't actually tried it).

To answer your first question, answer me this: If someone wrote an out-of-tree filter that has a chfPluginArgString parameter and they compiled their code unmodified after you had redefined the meaning of that parameter, would they find out at compile-time that their code needs to be fixed? If they would, the redefinition is probably fine; if not, you'd need to make it so that their code would not compile.

I'm not sure yet whether I like the extra-short form, although it certainly seems clever. Please convince me that this extra code won't cause any problems, it can't cause crashes if someone feeds it some other non-JSON syntax, what error messages does it generate when fed weird stuff etc. I'm not asking you to take it out, but to justify this approach.

db29bb0... by Dirk Zimoch on 2021-04-09

check that filter without value is not followed by garbage

[Dirk Zimoch (dirk.zimoch)]

I have added a check that the "extra-short form" is not followed by garbage. (And wrote tests for it.) It only accepts , or } now. It never crashed before but had accepted any separator like ; or # and did not check for closing }. That is fixed now.

The error message if } is missing is:
dbChannelCreate: parse error: premature EOF

If garbarge follows instead or a comma, the error is:
dbChannelCreate: lexical error: invalid char in json text.

These are exactly the same error one gets with the "long form" using :{}

Whitespace around the comma are possible just as usual.

---

I could not find a clever way to properly type check chfPluginArgString for char* vs char[] (without writing a new API in C++). Thus I will keep old chfPluginArgString and new chfPluginArgStringAlloc.

1f76799... by Dirk Zimoch on 2021-04-09

check for out of memory

Unmerged commits

1f76799... by Dirk Zimoch on 2021-04-09

check for out of memory

db29bb0... by Dirk Zimoch on 2021-04-09

check that filter without value is not followed by garbage

4395cf4... by Dirk Zimoch on 2021-03-19

simplified filter syntax for no argument

06f8a37... by Dirk Zimoch on 2021-03-18

simplified filter syntax for only one argument

c1b22d0... by Dirk Zimoch on 2021-03-18

allow arbritrary state name length

24da53b... by Dirk Zimoch on 2021-03-12

allow strings with arbitrary length

ab85813... by Dirk Zimoch on 2021-03-17

typo fixed

diff --git a/documentation/RELEASE_NOTES.md b/documentation/RELEASE_NOTES.md
index 17b039c..b79e5f1 100644
--- a/documentation/RELEASE_NOTES.md
+++ b/documentation/RELEASE_NOTES.md
@@ -17,6 +17,22 @@ should also be read to understand what has changed since earlier releases.
 
 <!-- Insert new items immediately below here ... -->
 
+## Channel filter improvements
+
+The new chfStringAlloc and chfTagStringAlloc macros allows to store string
+arguments with arbitrary length in char* members instead of fixed size arrays.
+Memory is automaticaly allocated and released.
+The "sync" filter has has been updated to allow arbitrarily long state names.
+
+Channel filters that require only one parameter (either they have only one
+parameter or only one parameter is required) can be used with a simplified
+syntax where only the value of that parameter is given instead of an object
+with one member.
+
+Channel filters that require no parameter at all can be used with a simplified
+syntax where only the filter name is given but not even an empty parameter set.
+This extends the JSON5 syntax.
+
 ### IOCsh sets `${PWD}`
 
 IOC shell will now ensure `${PWD}` is set on startup,
@@ -105,7 +121,6 @@ that the variables referenced by output pointers are initialized.
 #endif
 ```
 
-
 -----
 
 ## EPICS Release 7.0.5
diff --git a/modules/database/src/ioc/db/chfPlugin.c b/modules/database/src/ioc/db/chfPlugin.c
index c84e086..4f103e3 100644
--- a/modules/database/src/ioc/db/chfPlugin.c
+++ b/modules/database/src/ioc/db/chfPlugin.c
@@ -70,6 +70,7 @@ store_integer_value(const chfPluginArgDef *opt, char *user, epicsInt32 val)
     const chfPluginEnumType *emap;
     double *dval;
     char *sval;
+    char **psval;
     int ret;
     char buff[22];              /* 2^64 = 1.8e+19, so 20 digits plus sign max */
 
@@ -104,6 +105,11 @@ store_integer_value(const chfPluginArgDef *opt, char *user, epicsInt32 val)
         strncpy(sval, buff, opt->size-1);
         sval[opt->size-1]='\0';
         break;
+    case chfPluginArgStringAlloc:
+        psval = (char **) (user + opt->dataOffset);
+        *psval = realloc(*psval, 22);
+        if (*psval) sprintf(*psval, "%ld", (long)val);
+        break;
     case chfPluginArgEnum:
         eval = (int*) (user + opt->dataOffset);
         for (emap = opt->enums; emap && emap->name; emap++) {
@@ -116,7 +122,7 @@ store_integer_value(const chfPluginArgDef *opt, char *user, epicsInt32 val)
             return -1;
         }
         break;
-    case chfPluginArgInvalid:
+    default:
         return -1;
     }
     return 0;
@@ -131,6 +137,7 @@ static int store_boolean_value(const chfPluginArgDef *opt, char *user, int val)
     epicsInt32 *ival;
     double *dval;
     char *sval;
+    char **psval;
 
 #ifdef DEBUG_CHF
     printf("Got a boolean for %s (type %d): %d\n",
@@ -162,8 +169,12 @@ static int store_boolean_value(const chfPluginArgDef *opt, char *user, int val)
         strncpy(sval, val ? "true" : "false", opt->size - 1);
         sval[opt->size - 1] = '\0';
         break;
-    case chfPluginArgEnum:
-    case chfPluginArgInvalid:
+    case chfPluginArgStringAlloc:
+        psval = (char **) (user + opt->dataOffset);
+        *psval = realloc(*psval, 6);
+        if (*psval) strcpy(*psval, val ? "true" : "false");
+        break;
+    default:
         return -1;
     }
     return 0;
@@ -180,6 +191,7 @@ store_double_value(const chfPluginArgDef *opt, void *vuser, double val)
     epicsInt32 *ival;
     double *dval;
     char *sval;
+    char **psval;
     int i;
 
 #ifdef DEBUG_CHF
@@ -217,8 +229,12 @@ store_double_value(const chfPluginArgDef *opt, void *vuser, double val)
             return -1;
         }
         break;
-    case chfPluginArgEnum:
-    case chfPluginArgInvalid:
+    case chfPluginArgStringAlloc:
+        psval = (char **) (user + opt->dataOffset);
+        *psval = realloc(*psval, 25);
+        if (*psval) epicsSnprintf(*psval, 24, "%.17g", val);
+        break;
+    default:
         return -1;
     }
     return 0;
@@ -237,6 +253,7 @@ store_string_value(const chfPluginArgDef *opt, char *user, const char *val,
     const chfPluginEnumType *emap;
     double *dval;
     char *sval;
+    char **psval;
     char *end;
     size_t i;
 
@@ -246,6 +263,7 @@ store_string_value(const chfPluginArgDef *opt, char *user, const char *val,
 #endif
 
     if (!opt->convert && opt->optType != chfPluginArgString &&
+        opt->optType != chfPluginArgStringAlloc &&
         opt->optType != chfPluginArgEnum) {
         return -1;
     }
@@ -279,6 +297,11 @@ store_string_value(const chfPluginArgDef *opt, char *user, const char *val,
         strncpy(sval, val, i);
         sval[i] = '\0';
         break;
+    case chfPluginArgStringAlloc:
+        psval = (char **) (user + opt->dataOffset);
+        free(*psval);
+        *psval = epicsStrnDup(val, len);
+        break;
     case chfPluginArgEnum:
         eval = (int*) (user + opt->dataOffset);
         for (emap = opt->enums; emap && emap->name; emap++) {
@@ -291,7 +314,7 @@ store_string_value(const chfPluginArgDef *opt, char *user, const char *val,
             return -1;
         }
         break;
-    case chfPluginArgInvalid:
+    default:
         return -1;
     }
     return 0;
@@ -314,6 +337,7 @@ static parse_result parse_start(chFilter *filter)
 {
     chfPlugin *p = (chfPlugin*) filter->plug->puser;
     chfFilter *f;
+    size_t i;
 
     /* Filter context */
     /* FIXME: Use a free-list */
@@ -339,25 +363,61 @@ static parse_result parse_start(chFilter *filter)
         }
     }
 
+    /* If there is only one argument or only one required argument,
+       allow shortcut without map */
+    if (p->nopts == 1)
+        f->nextParam = 0;
+    else
+    for (i = 0; i < p->nopts; i++) {
+        if (p->opts[i].required) {
+            if (f->nextParam == -1) {
+                f->nextParam = i;
+            } else {
+                f->nextParam = -1;
+                break;
+            }
+        }
+    }
+    if (f->nextParam >= 0 &&
+        p->opts[f->nextParam].optType == chfPluginArgStringAlloc) {
+        *(char **) ((char*) f->puser + p->opts[f->nextParam].dataOffset) = NULL;
+    }
+
     filter->puser = (void*) f;
 
     return parse_continue;
 
     errplugin:
-    free(f->found);
     errbitarray:
-    free(f);         /* FIXME: Use a free-list */
+    freeInstanceData(f);
     errfctx:
     return parse_stop;
 }
 
+static void freePvt(chFilter *filter) {
+    chfPlugin *p = (chfPlugin*) filter->plug->puser;
+    chfFilter *f = (chfFilter*) filter->puser;
+    int i;
+
+    /* free all chfPluginArgStringAlloc options we had allocated */
+    for(i = 0; i < p->nopts; i++) {
+        if (p->opts[i].optType == chfPluginArgStringAlloc &&
+            (f->found[i/32] & (1<<(i%32)))) {
+            char **psval = (char **) ((char*) f->puser + p->opts[i].dataOffset);
+            free(*psval);
+            *psval = NULL;
+        }
+    }
+    if (p->pif->freePvt) p->pif->freePvt(f->puser);
+}
+
 static void parse_abort(chFilter *filter) {
     chfPlugin *p = (chfPlugin*) filter->plug->puser;
     chfFilter *f = (chfFilter*) filter->puser;
 
     /* Call the plugin to tell it we're aborting */
     if (p->pif->parse_error) p->pif->parse_error(f->puser);
-    if (p->pif->freePvt) p->pif->freePvt(f->puser);
+    freePvt(filter);
     freeInstanceData(f);
 }
 
@@ -365,22 +425,11 @@ static parse_result parse_end(chFilter *filter)
 {
     chfPlugin *p = (chfPlugin*) filter->plug->puser;
     chfFilter *f = (chfFilter*) filter->puser;
-    int i;
-
-    /* Check if all required arguments were supplied */
-    for(i = 0; i < (p->nopts/32)+1; i++) {
-        if ((f->found[i] & p->required[i]) != p->required[i]) {
-            if (p->pif->parse_error) p->pif->parse_error(f->puser);
-            if (p->pif->freePvt) p->pif->freePvt(f->puser);
-            freeInstanceData(f);
-            return parse_stop;
-        }
-    }
 
     /* Call the plugin to tell it we're done */
     if (p->pif->parse_ok) {
         if (p->pif->parse_ok(f->puser)) {
-            if (p->pif->freePvt) p->pif->freePvt(f->puser);
+            freePvt(filter);
             freeInstanceData(f);
             return parse_stop;
         }
@@ -478,6 +527,12 @@ parse_map_key(chFilter *filter, const char *key, size_t stringLen)
         *tag = opts[i].choice;
     }
 
+    /* NULL all found chfPluginArgStringAlloc options */
+    if (opts[i].optType == chfPluginArgStringAlloc &&
+        !(f->found[i/32] & 1<<(i%32))) {
+        char **psval = (char **) ((char*) f->puser + opts[i].dataOffset);
+        *psval = NULL;
+    }
     f->found[i/32] |= 1<<(i%32);
     /* Mark tag and all other options pointing to the same data as found */
     for (cur = opts, j = 0; cur && cur->name; cur++, j++) {
@@ -491,6 +546,15 @@ parse_map_key(chFilter *filter, const char *key, size_t stringLen)
 
 static parse_result parse_end_map(chFilter *filter)
 {
+    chfPlugin *p = (chfPlugin*) filter->plug->puser;
+    chfFilter *f = (chfFilter*) filter->puser;
+    int i;
+
+    /* Check if all required arguments were supplied */
+    for(i = 0; i < (p->nopts/32)+1; i++) {
+        if ((f->found[i] & p->required[i]) != p->required[i])
+            return parse_stop;
+    }
     return parse_continue;
 }
 
@@ -545,9 +609,8 @@ static void channel_close(chFilter *filter)
     chfFilter *f =  (chfFilter*) filter->puser;
 
     if (p->pif->channel_close) p->pif->channel_close(filter->chan, f->puser);
-    if (p->pif->freePvt) p->pif->freePvt(f->puser);
-    free(f->found);
-    free(f);         /* FIXME: Use a free-list */
+    freePvt(filter);
+    freeInstanceData(f);
 }
 
 static void plugin_free(void* puser)
@@ -649,7 +712,16 @@ chfPluginRegister(const char* key, const chfPluginIf *pif,
                 return -1;
             }
             break;
-        case chfPluginArgInvalid:
+        case chfPluginArgStringAlloc:
+            if (cur->size != sizeof(char*)) {
+                  /* Catch if someone has given us a something else than a pointer
+                   */
+                errlogPrintf("Plugin %s: %d bytes not a pointer type for string %s\n",
+                             key, cur->size, cur->name);
+                return -1;
+            }
+            break;
+        default:
             errlogPrintf("Plugin %s: storage type for %s is not defined\n",
                          key, cur->name);
             return -1;
diff --git a/modules/database/src/ioc/db/chfPlugin.h b/modules/database/src/ioc/db/chfPlugin.h
index 5867a66..eed218d 100644
--- a/modules/database/src/ioc/db/chfPlugin.h
+++ b/modules/database/src/ioc/db/chfPlugin.h
@@ -52,6 +52,7 @@ struct db_field_log;
  *   epicsInt32 ival2;
  *   int        enumval;
  *   char       strval[20];
+ *   char*      str;
  *   char       boolval;
  * } myStruct;
  *
@@ -64,6 +65,7 @@ struct db_field_log;
  *   chfInt32   (myStruct, ival2,   "Second"  , 1, 0),
  *   chfDouble  (myStruct, dval,    "Double"  , 1, 0),
  *   chfString  (myStruct, strval , "String"  , 1, 0),
+ *   chfStringAlloc(myStruct, str , "String"  , 1, 0),
  *   chfEnum    (myStruct, enumval, "Color"   , 1, 0, colorEnum),
  *   chfBoolean (myStruct, boolval, "Bool"    , 1, 0),
  *   chfPluginEnd
@@ -225,7 +227,8 @@ typedef enum chfPluginArg {
     chfPluginArgInt32,
     chfPluginArgDouble,
     chfPluginArgString,
-    chfPluginArgEnum
+    chfPluginArgEnum,
+    chfPluginArgStringAlloc
 } chfPluginArg;
 
 typedef struct chfPluginEnumType {
@@ -268,6 +271,10 @@ typedef struct chfPluginArgDef {
     {Name, chfPluginArgEnum, Req, Conv, 0, 0, 0, \
     OFFSET(Struct, Member), sizeof( ((Struct*)0)->Member ), Enums}
 
+#define chfStringAlloc(Struct, Member, Name, Req, Conv) \
+    {Name, chfPluginArgStringAlloc, Req, Conv, 0, 0, 0, \
+    OFFSET(Struct, Member), sizeof( ((Struct*)0)->Member ), NULL}
+
 /* Tagged arguments */
 
 #define chfTagInt32(Struct, Member, Name, Tag, Choice, Req, Conv) \
@@ -290,6 +297,10 @@ typedef struct chfPluginArgDef {
     {Name, chfPluginArgEnum, Req, Conv, 1, OFFSET(Struct, Tag), Choice, \
     OFFSET(Struct, Member), sizeof( ((Struct*)0)->Member ), Enums}
 
+#define chfTagStringAlloc(Struct, Member, Name, Tag, Choice, Req, Conv) \
+    {Name, chfPluginArgStringAlloc, Req, Conv, 1, OFFSET(Struct, Tag), Choice, \
+    OFFSET(Struct, Member), sizeof( ((Struct*)0)->Member ), NULL}
+
 #define chfPluginArgEnd {0}
 
 /* Extra output when parsing and converting */
diff --git a/modules/database/src/ioc/db/dbChannel.c b/modules/database/src/ioc/db/dbChannel.c
index a806f3c..edf2124 100644
--- a/modules/database/src/ioc/db/dbChannel.c
+++ b/modules/database/src/ioc/db/dbChannel.c
@@ -291,6 +291,32 @@ static long chf_parse(dbChannel *chan, const char **pjson)
     case yajl_status_error: {
         unsigned char *err;
 
+        if (parser.depth == 0 && parser.filter &&
+            (json[ylen-1] == ',' || json[ylen-1] == '}')) {
+            /* We get here only if filter is called without arguments. */
+            /* Let's fake ":{}" */
+            if (chf_start_map(&parser) == parse_continue &&
+                chf_end_map(&parser) == parse_continue) {
+                *pjson += ylen;
+                status = 0;
+                if (json[ylen]) {
+                    /* some filters left, let's parse them too */
+                    char *jsoncopy = epicsStrDup(json+ylen-1);
+                    if (!jsoncopy) {
+                        printf("dbChannelCreate: out of memory\n");
+                        break;
+                    }
+                    jsoncopy[0] = '{';
+                    json = jsoncopy;
+                    status = chf_parse(chan, &json);
+                    ylen = json-jsoncopy-1;
+                    *pjson += ylen;
+                    free(jsoncopy);
+                }
+                break;
+            }
+        }
+
         err = yajl_get_error(yh, 1, (const unsigned char *) json, jlen);
         printf("dbChannelCreate: %s\n", err);
         yajl_free_error(yh, err);
diff --git a/modules/database/src/std/filters/filters.dbd.pod b/modules/database/src/std/filters/filters.dbd.pod
index 7b31466..5c1219d 100644
--- a/modules/database/src/std/filters/filters.dbd.pod
+++ b/modules/database/src/std/filters/filters.dbd.pod
@@ -40,6 +40,13 @@ Parameters to that filter are provided as the value part of the name/value pair,
 and will normally appear as a child JSON object consisting of name/value pairs
 inside a nested pair of braces C< {} >.
 
+If a filter takes only one parameter or only one parameter is required, a short
+form may be used where the parameter vallue is passed directly instead of
+an object in braces C< {} >.
+
+If a filter does not need any parameter, the value part can be skipped
+completely. Only the filter name is needed in this case.
+
 =head4 Example Filter
 
 Given a record called C<test:channel> the following would apply a filter C<f> to
@@ -69,12 +76,12 @@ to the EPICS epoch if the record has never processed.
 
 =head4 Parameters
 
-None, use an empty pair of braces.
+None.
 
 =head4 Example
 
- Hal$ caget -a 'test:channel.{"ts":{}}'
- test:channel.{"ts":{}}   2012-08-28 22:10:31.192547 0 UDF INVALID
+ Hal$ caget -a 'test:channel.{"ts"}'
+ test:channel.{"ts"}   2012-08-28 22:10:31.192547 0 UDF INVALID
  Hal$ caget -a 'test:channel'
  test:channel             <undefined> 0 UDF INVALID
 
@@ -281,9 +288,10 @@ client connects.
 =head4 Example
 
 To sample a 60Hz channel at 1Hz, a 10Hz channel every 6 seconds or a 1Hz channel
-once every minute:
+once every minute. As the "dec" filter requires only one parameter, the short
+syntax may be used:
 
- Hal$ camonitor 'test:channel' 'test:channel.{"dec":{"n":60}}'
+ Hal$ camonitor 'test:channel' 'test:channel.{"dec":60}'
  ...
 
 =cut
diff --git a/modules/database/src/std/filters/sync.c b/modules/database/src/std/filters/sync.c
index 8140c36..f31f677 100644
--- a/modules/database/src/std/filters/sync.c
+++ b/modules/database/src/std/filters/sync.c
@@ -21,8 +21,6 @@
 #include "epicsAssert.h"
 #include "epicsExport.h"
 
-#define STATE_NAME_LENGTH 20
-
 typedef enum syncMode {
     syncModeBefore=0,
     syncModeFirst=1,
@@ -45,7 +43,7 @@ chfPluginEnumType modeEnum[] = {
 
 typedef struct myStruct {
     syncMode mode;
-    char state[STATE_NAME_LENGTH];
+    char* state;
     dbStateId id;
     db_field_log *lastfl;
     int laststate:1;
@@ -55,14 +53,14 @@ static void *myStructFreeList;
 
 static const
 chfPluginArgDef opts[] = {
-    chfEnum      (myStruct, mode,  "m", 1, 1, modeEnum),
-    chfString    (myStruct, state, "s", 1, 0),
-    chfTagString (myStruct, state, "before", mode, 0, 1, 0),
-    chfTagString (myStruct, state, "first",  mode, 1, 1, 0),
-    chfTagString (myStruct, state, "last",   mode, 2, 1, 0),
-    chfTagString (myStruct, state, "after",  mode, 3, 1, 0),
-    chfTagString (myStruct, state, "while",  mode, 4, 1, 0),
-    chfTagString (myStruct, state, "unless", mode, 5, 1, 0),
+    chfEnum           (myStruct, mode,  "m", 1, 1, modeEnum),
+    chfStringAlloc    (myStruct, state, "s", 1, 0),
+    chfTagStringAlloc (myStruct, state, "before", mode, 0, 1, 0),
+    chfTagStringAlloc (myStruct, state, "first",  mode, 1, 1, 0),
+    chfTagStringAlloc (myStruct, state, "last",   mode, 2, 1, 0),
+    chfTagStringAlloc (myStruct, state, "after",  mode, 3, 1, 0),
+    chfTagStringAlloc (myStruct, state, "while",  mode, 4, 1, 0),
+    chfTagStringAlloc (myStruct, state, "unless", mode, 5, 1, 0),
     chfPluginArgEnd
 };
 
diff --git a/modules/database/test/ioc/db/chfPluginTest.c b/modules/database/test/ioc/db/chfPluginTest.c
index 4a1667c..6d281fc 100644
--- a/modules/database/test/ioc/db/chfPluginTest.c
+++ b/modules/database/test/ioc/db/chfPluginTest.c
@@ -68,6 +68,7 @@ typedef struct myStruct {
     char        c1[2];
     int         offpre;
     int         offpost;
+    char*       astr;
 } myStruct;
 
 static const
@@ -75,54 +76,76 @@ chfPluginEnumType colorEnum[] = { {"R", 1}, {"G", 2}, {"B", 4}, {NULL,0} };
 
 static const
 chfPluginArgDef sloppyTaggedOpts[] = {
-    chfInt32     (myStruct, tval,    "t" , 0, 0),
-    chfTagInt32  (myStruct, ival,    "I" , tval, 1, 0, 0),
-    chfTagBoolean(myStruct, flag,    "F" , tval, 2, 0, 0),
-    chfTagDouble (myStruct, dval,    "D" , tval, 3, 0, 0),
-    chfTagString (myStruct, str,     "S" , tval, 4, 0, 0),
-    chfTagEnum   (myStruct, enumval, "C" , tval, 5, 0, 0, colorEnum),
+    chfInt32         (myStruct, tval,    "t" , 0, 0),
+    chfTagInt32      (myStruct, ival,    "I" , tval, 1, 0, 0),
+    chfTagBoolean    (myStruct, flag,    "F" , tval, 2, 0, 0),
+    chfTagDouble     (myStruct, dval,    "D" , tval, 3, 0, 0),
+    chfTagString     (myStruct, str,     "S" , tval, 4, 0, 0),
+    chfTagEnum       (myStruct, enumval, "C" , tval, 5, 0, 0, colorEnum),
+    chfTagStringAlloc(myStruct, astr,    "A" , tval, 6, 0, 0),
     chfPluginArgEnd
 };
 
 static const
 chfPluginArgDef strictTaggedOpts[] = {
-    chfInt32     (myStruct, tval,    "t" , 1, 0),
-    chfBoolean   (myStruct, flag,    "f" , 1, 0),
-    chfTagInt32  (myStruct, ival,    "I" , tval, 1, 0, 0),
-    chfTagBoolean(myStruct, flag,    "F" , tval, 2, 0, 0),
-    chfTagDouble (myStruct, dval,    "D" , tval, 3, 1, 0),
-    chfTagDouble (myStruct, dval,    "D2", tval, 4, 1, 0),
-    chfTagEnum   (myStruct, enumval, "C" , tval, 5, 0, 0, colorEnum),
+    chfInt32         (myStruct, tval,    "t" , 1, 0),
+    chfBoolean       (myStruct, flag,    "f" , 1, 0),
+    chfTagInt32      (myStruct, ival,    "I" , tval, 1, 0, 0),
+    chfTagBoolean    (myStruct, flag,    "F" , tval, 2, 0, 0),
+    chfTagDouble     (myStruct, dval,    "D" , tval, 3, 1, 0),
+    chfTagDouble     (myStruct, dval,    "D2", tval, 4, 1, 0),
+    chfTagEnum       (myStruct, enumval, "C" , tval, 5, 0, 0, colorEnum),
+    chfTagStringAlloc(myStruct, astr,    "A",  tval, 6, 0, 0),
     chfPluginArgEnd
 };
 
 static const
 chfPluginArgDef strictOpts[] = {
-    chfInt32  (myStruct, ival,    "i" , 1, 0),
-    chfBoolean(myStruct, flag,    "f" , 1, 0),
-    chfDouble (myStruct, dval,    "d" , 1, 0),
-    chfString (myStruct, str,     "s" , 1, 0),
-    chfEnum   (myStruct, enumval, "c" , 1, 0, colorEnum),
+    chfInt32      (myStruct, ival,    "i" , 1, 0),
+    chfBoolean    (myStruct, flag,    "f" , 1, 0),
+    chfDouble     (myStruct, dval,    "d" , 1, 0),
+    chfString     (myStruct, str,     "s" , 1, 0),
+    chfEnum       (myStruct, enumval, "c" , 1, 0, colorEnum),
+    chfStringAlloc(myStruct, astr,    "a",  1, 0),
     chfPluginArgEnd
 };
 
 static const
 chfPluginArgDef noconvOpts[] = {
-    chfInt32  (myStruct, ival,    "i" , 0, 0),
-    chfBoolean(myStruct, flag,    "f" , 0, 0),
-    chfDouble (myStruct, dval,    "d" , 0, 0),
-    chfString (myStruct, str,     "s" , 0, 0),
-    chfEnum   (myStruct, enumval, "c" , 0, 0, colorEnum),
+    chfInt32      (myStruct, ival,    "i" , 0, 0),
+    chfBoolean    (myStruct, flag,    "f" , 0, 0),
+    chfDouble     (myStruct, dval,    "d" , 0, 0),
+    chfString     (myStruct, str,     "s" , 0, 0),
+    chfEnum       (myStruct, enumval, "c" , 0, 0, colorEnum),
+    chfStringAlloc(myStruct, astr,    "a",  0, 0),
     chfPluginArgEnd
 };
 
 static const
 chfPluginArgDef sloppyOpts[] = {
-    chfInt32  (myStruct, ival,    "i" , 0, 1),
-    chfBoolean(myStruct, flag,    "f" , 0, 1),
-    chfDouble (myStruct, dval,    "d" , 0, 1),
-    chfString (myStruct, str,     "s" , 0, 1),
-    chfEnum   (myStruct, enumval, "c" , 0, 1, colorEnum),
+    chfInt32      (myStruct, ival,    "i" , 0, 1),
+    chfBoolean    (myStruct, flag,    "f" , 0, 1),
+    chfDouble     (myStruct, dval,    "d" , 0, 1),
+    chfString     (myStruct, str,     "s" , 0, 1),
+    chfEnum       (myStruct, enumval, "c" , 0, 1, colorEnum),
+    chfStringAlloc(myStruct, astr,    "a",  0, 1),
+    chfPluginArgEnd
+};
+
+static const
+chfPluginArgDef onlyOneOpts[] = {
+    chfInt32      (myStruct, ival,    "i" , 0, 0),
+    chfPluginArgEnd
+};
+
+static const
+chfPluginArgDef onlyOneRequiredOpts[] = {
+    chfInt32      (myStruct, ival,    "i" , 0, 0),
+    chfBoolean    (myStruct, flag,    "f" , 0, 0),
+    chfDouble     (myStruct, dval,    "d" , 1, 0),
+    chfString     (myStruct, str,     "s" , 0, 0),
+    chfEnum       (myStruct, enumval, "c" , 0, 0, colorEnum),
+    chfStringAlloc(myStruct, astr,    "a",  0, 0),
     chfPluginArgEnd
 };
 
@@ -154,6 +177,7 @@ chfPluginArgDef brokenOpts4[] = {
 int p_ok_return = 0;
 int c_open_return = 0;
 void *puser1, *puser2;
+char defaultstring[] = "default";
 
 static void clearStruct(void *p) {
     myStruct *my = (myStruct*) p;
@@ -168,6 +192,7 @@ static void clearStruct(void *p) {
     my->dval = 1.234e5;
     strcpy(my->str, "hello");
     my->enumval = 4;
+    my->astr = defaultstring;
 }
 
 static char inst(void* user) {
@@ -177,7 +202,6 @@ static char inst(void* user) {
 static void * allocPvt(void)
 {
     myStruct *my = (myStruct*) calloc(1, sizeof(myStruct));
-
     if (!puser1) {
         puser1 = my;
         testOk(e1 & e_alloc, "allocPvt (1) called");
@@ -194,7 +218,7 @@ static void * allocPvt(void)
 static void * allocPvtFail(void)
 {
     if (!puser1) {
-        testOk(e1 & e_alloc, "allocPvt (1) called");
+        testOk(e1 & e_alloc, "allocPvtFail (1) called");
         c1 |= e_alloc;
     }
     return NULL;
@@ -202,7 +226,10 @@ static void * allocPvtFail(void)
 
 static void freePvt(void *user)
 {
-    if (user == puser1) {
+    myStruct *my = (myStruct*) user;
+    if ((user == puser1 || user == puser2) && (my->astr && my->astr != defaultstring)) {
+        testFail("freePvt: allocated string not free'd");
+    } else if (user == puser1) {
         testOk(e1 & e_free, "freePvt (1) called");
         c1 |= e_free;
         free(user);
@@ -499,9 +526,9 @@ static chfPluginIf allocFailPif = {
 };
 
 static int checkValues(myStruct *my,
-    char t, epicsUInt32 i, int f, double d, char *s1, char *s2, int c) {
+    char t, epicsUInt32 i, int f, double d, char *s1, char *s2, int c, char *s3) {
     int ret = 1;
-    int s1fail, s2fail;
+    int s1fail, s2fail, s3fail;
     int s2valid = (s2 && s2[0] != '\0');
 
     if (!my) return 0;
@@ -526,6 +553,11 @@ static int checkValues(myStruct *my,
         if (s2valid && s2fail) testDiag("Fail: my->str (%s) != s (%s)", my->str, s2);
         ret = 0;
     }
+    s3fail = (!s3 && my->astr) || (s3 && !my->astr) || (s3 && strcmp(s3, my->astr));
+    if (s3fail) {
+        testDiag("Fail: my->str (%s) != s (%s)", my->astr, s3);
+        ret = 0;
+    }
     return ret;
 }
 
@@ -549,7 +581,7 @@ MAIN(chfPluginTest)
 #endif
 #endif
 
-    testPlan(1433);
+    testPlan(1612);
 
     dbChannelInit();
     db_init_events();
@@ -599,6 +631,10 @@ MAIN(chfPluginTest)
         "register plugin noconv");
     testOk(!chfPluginRegister("sloppy", &myPif, sloppyOpts),
         "register plugin sloppy");
+    testOk(!chfPluginRegister("onlyOne", &myPif, onlyOneOpts),
+        "register plugin onlyOne");
+    testOk(!chfPluginRegister("onlyOneRequired", &myPif, onlyOneRequiredOpts),
+        "register plugin onlyOneRequired");
     testOk(!chfPluginRegister("pre",   &prePif, sloppyOpts),
         "register plugin pre");
     testOk(!chfPluginRegister("post", &postPif, sloppyOpts),
@@ -629,7 +665,7 @@ MAIN(chfPluginTest)
     testOk(!!(pch = dbChannelCreate(
         "x.{'strict-tagged':{D:1.2e15,f:false}}")),
         "create channel for strict-tagged parsing: D (t and d) and f");
-    testOk(checkValues(puser1, 3, 12, 0, 1.2e15, "hello", 0, 4),
+    testOk(checkValues(puser1, 3, 12, 0, 1.2e15, "hello", 0, 4, "default"),
         "guards intact, values correct");
     if (!testOk(c1 == e1, "all expected calls happened"))
         testDiag("expected %#x - called %#x", e1, c1);
@@ -643,7 +679,7 @@ MAIN(chfPluginTest)
     testOk(!!(pch = dbChannelCreate(
         "x.{'strict-tagged':{D2:1.2e15,f:false}}")),
         "create channel for strict-tagged parsing: D2 (t and d) and f");
-    testOk(checkValues(puser1, 4, 12, 0, 1.2e15, "hello", 0, 4),
+    testOk(checkValues(puser1, 4, 12, 0, 1.2e15, "hello", 0, 4, "default"),
         "guards intact, values correct");
     if (!testOk(c1 == e1, "all expected calls happened"))
         testDiag("expected %#x - called %#x", e1, c1);
@@ -673,12 +709,26 @@ MAIN(chfPluginTest)
 
     testHead("SLOPPY TAGGED parsing: all ok");
 
+    /* no tag */
+    e1 = e_alloc | e_ok; c1 = 0;
+    testOk(!!(pch = dbChannelCreate(
+        "x.{'sloppy-tagged':{}}")),
+        "create channel for sloppy-tagged parsing: no argument");
+    testOk(checkValues(puser1, 99, 12, 1, 1.234e5, "hello", 0, 4, "default"),
+        "guards intact, values correct");
+    if (!testOk(c1 == e1, "all expected calls happened"))
+        testDiag("expected %#x - called %#x", e1, c1);
+    e1 = e_close | e_free; c1 = 0;
+    if (pch) dbChannelDelete(pch);
+    testOk(!puser1, "user part cleaned up");
+    if (!testOk(c1 == e1, "all expected calls happened"))
+        testDiag("expected %#x - called %#x", e1, c1);
     /* tag i */
     e1 = e_alloc | e_ok; c1 = 0;
     testOk(!!(pch = dbChannelCreate(
         "x.{'sloppy-tagged':{I:1}}")),
         "create channel for sloppy-tagged parsing: I");
-    testOk(checkValues(puser1, 1, 1, 1, 1.234e5, "hello", 0, 4),
+    testOk(checkValues(puser1, 1, 1, 1, 1.234e5, "hello", 0, 4, "default"),
         "guards intact, values correct");
     if (!testOk(c1 == e1, "all expected calls happened"))
         testDiag("expected %#x - called %#x", e1, c1);
@@ -692,7 +742,7 @@ MAIN(chfPluginTest)
     testOk(!!(pch = dbChannelCreate(
         "x.{'sloppy-tagged':{F:false}}")),
         "create channel for sloppy-tagged parsing: F");
-    testOk(checkValues(puser1, 2, 12, 0, 1.234e5, "hello", 0, 4),
+    testOk(checkValues(puser1, 2, 12, 0, 1.234e5, "hello", 0, 4, "default"),
         "guards intact, values correct");
     if (!testOk(c1 == e1, "all expected calls happened"))
         testDiag("expected %#x - called %#x", e1, c1);
@@ -706,7 +756,7 @@ MAIN(chfPluginTest)
     testOk(!!(pch = dbChannelCreate(
         "x.{'sloppy-tagged':{D:1.2e15}}")),
         "create channel for sloppy-tagged parsing: D");
-    testOk(checkValues(puser1, 3, 12, 1, 1.2e15, "hello", 0, 4),
+    testOk(checkValues(puser1, 3, 12, 1, 1.2e15, "hello", 0, 4, "default"),
         "guards intact, values correct");
     if (!testOk(c1 == e1, "all expected calls happened"))
         testDiag("expected %#x - called %#x", e1, c1);
@@ -720,7 +770,7 @@ MAIN(chfPluginTest)
     testOk(!!(pch = dbChannelCreate(
         "x.{'sloppy-tagged':{S:'bar'}}")),
         "create channel for sloppy-tagged parsing: S");
-    testOk(checkValues(puser1, 4, 12, 1, 1.234e5, "bar", 0, 4),
+    testOk(checkValues(puser1, 4, 12, 1, 1.234e5, "bar", 0, 4, "default"),
         "guards intact, values correct");
     if (!testOk(c1 == e1, "all expected calls happened"))
         testDiag("expected %#x - called %#x", e1, c1);
@@ -734,7 +784,21 @@ MAIN(chfPluginTest)
     testOk(!!(pch = dbChannelCreate(
         "x.{'sloppy-tagged':{C:'R'}}")),
         "create channel for sloppy-tagged parsing: C");
-    testOk(checkValues(puser1, 5, 12, 1, 1.234e5, "hello", 0, 1),
+    testOk(checkValues(puser1, 5, 12, 1, 1.234e5, "hello", 0, 1, "default"),
+        "guards intact, values correct");
+    if (!testOk(c1 == e1, "all expected calls happened"))
+        testDiag("expected %#x - called %#x", e1, c1);
+    e1 = e_close | e_free; c1 = 0;
+    if (pch) dbChannelDelete(pch);
+    testOk(!puser1, "user part cleaned up");
+    if (!testOk(c1 == e1, "all expected calls happened"))
+        testDiag("expected %#x - called %#x", e1, c1);
+    /* tag A */
+    e1 = e_alloc | e_ok; c1 = 0;
+    testOk(!!(pch = dbChannelCreate(
+        "x.{'sloppy-tagged':{A:'bar'}}")),
+        "create channel for sloppy-tagged parsing: A");
+    testOk(checkValues(puser1, 6, 12, 1, 1.234e5, "hello", 0, 4, "bar"),
         "guards intact, values correct");
     if (!testOk(c1 == e1, "all expected calls happened"))
         testDiag("expected %#x - called %#x", e1, c1);
@@ -749,9 +813,9 @@ MAIN(chfPluginTest)
     /* All perfect */
     testHead("STRICT parsing: all ok");
     e1 = e_alloc | e_ok; c1 = 0;
-    testOk(!!(pch = dbChannelCreate("x.{strict:{i:1,f:false,d:1.2e15,s:'bar',c:'R'}}")),
+    testOk(!!(pch = dbChannelCreate("x.{strict:{i:1,f:false,d:1.2e15,s:'bar',c:'R',a:'foo'}}")),
            "create channel for strict parsing: JSON correct");
-    testOk(checkValues(puser1, 99, 1, 0, 1.2e15, "bar", 0, 1),
+    testOk(checkValues(puser1, 99, 1, 0, 1.2e15, "bar", 0, 1, "foo"),
         "guards intact, values correct");
     if (!testOk(c1 == e1, "all expected calls happened"))
         testDiag("expected %#x - called %#x", e1, c1);
@@ -765,39 +829,46 @@ MAIN(chfPluginTest)
     testHead("STRICT parsing: any missing parameter must fail");
     e1 = e_alloc | e_error | e_free; c1 = 0;
     testOk(!(pch = dbChannelCreate(
-        "x.{strict:{i:1,f:false,d:1.2e15,s:'bar'}}")),
+        "x.{strict:{i:1,f:false,d:1.2e15,s:'bar',a:'foo'}}")),
         "create channel for strict parsing: c missing");
     testOk(!puser1, "user part cleaned up");
     if (!testOk(c1 == e1, "all expected calls happened"))
         testDiag("expected %#x - called %#x", e1, c1);
     e1 = e_alloc | e_error | e_free; c1 = 0;
     testOk(!(pch = dbChannelCreate(
-        "x.{strict:{f:false,i:1,d:1.2e15,c:'R'}}")),
+        "x.{strict:{f:false,i:1,d:1.2e15,c:'R',a:'foo'}}")),
         "create channel for strict parsing: s missing");
     testOk(!puser1, "user part cleaned up");
     if (!testOk(c1 == e1, "all expected calls happened"))
         testDiag("expected %#x - called %#x", e1, c1);
     e1 = e_alloc | e_error | e_free; c1 = 0;
     testOk(!(pch = dbChannelCreate(
-        "x.{strict:{i:1,c:'R',f:false,s:'bar'}}")),
+        "x.{strict:{i:1,c:'R',f:false,s:'bar',a:'foo'}}")),
         "create channel for strict parsing: d missing");
     testOk(!puser1, "user part cleaned up");
     if (!testOk(c1 == e1, "all expected calls happened"))
         testDiag("expected %#x - called %#x", e1, c1);
     e1 = e_alloc | e_error | e_free; c1 = 0;
     testOk(!(pch = dbChannelCreate(
-        "x.{strict:{d:1.2e15,c:'R',i:1,s:'bar'}}")),
+        "x.{strict:{d:1.2e15,c:'R',i:1,s:'bar',a:'foo'}}")),
         "create channel for strict parsing: f missing");
     testOk(!puser1, "user part cleaned up");
     if (!testOk(c1 == e1, "all expected calls happened"))
         testDiag("expected %#x - called %#x", e1, c1);
     e1 = e_alloc | e_error | e_free; c1 = 0;
     testOk(!(pch = dbChannelCreate(
-        "x.{strict:{c:'R',s:'bar',f:false,d:1.2e15}}")),
+        "x.{strict:{c:'R',s:'bar',f:false,d:1.2e15,a:'foo'}}")),
         "create channel for strict parsing: i missing");
     testOk(!puser1, "user part cleaned up");
     if (!testOk(c1 == e1, "all expected calls happened"))
         testDiag("expected %#x - called %#x", e1, c1);
+    e1 = e_alloc | e_error | e_free; c1 = 0;
+    testOk(!(pch = dbChannelCreate(
+        "x.{strict:{i:1,f:false,d:1.2e15,s:'bar',c:'R'}}")),
+        "create channel for strict parsing: a missing");
+    testOk(!puser1, "user part cleaned up");
+    if (!testOk(c1 == e1, "all expected calls happened"))
+        testDiag("expected %#x - called %#x", e1, c1);
 
     /* NOCONV parsing: optional, no conversion */
 
@@ -805,9 +876,9 @@ MAIN(chfPluginTest)
     testHead("NOCONV parsing: missing parameters get default value");
     e1 = e_alloc | e_ok; c1 = 0;
     testOk(!!(pch = dbChannelCreate(
-        "x.{noconv:{i:1,f:false,d:1.2e15,s:'bar'}}")),
+        "x.{noconv:{i:1,f:false,d:1.2e15,s:'bar',a:'foo'}}")),
         "create channel for noconv parsing: c missing");
-    testOk(checkValues(puser1, 99, 1, 0, 1.2e15, "bar", 0, 4),
+    testOk(checkValues(puser1, 99, 1, 0, 1.2e15, "bar", 0, 4, "foo"),
         "guards intact, values correct");
     if (!testOk(c1 == e1, "all expected calls happened"))
         testDiag("expected %#x - called %#x", e1, c1);
@@ -819,36 +890,90 @@ MAIN(chfPluginTest)
 
     e1 = e_any;
     testOk(!!(pch = dbChannelCreate(
-        "x.{noconv:{i:1,f:false,d:1.2e15,c:'R'}}")),
+        "x.{noconv:{i:1,f:false,d:1.2e15,c:'R',a:'foo'}}")),
         "create channel for noconv parsing: s missing");
-    testOk(checkValues(puser1, 99, 1, 0, 1.2e15, "hello", 0, 1),
+    testOk(checkValues(puser1, 99, 1, 0, 1.2e15, "hello", 0, 1, "foo"),
         "guards intact, values correct");
     if (pch) dbChannelDelete(pch);
 
     testOk(!!(pch = dbChannelCreate(
-        "x.{noconv:{i:1,f:false,s:'bar',c:'R'}}")),
+        "x.{noconv:{i:1,f:false,s:'bar',c:'R',a:'foo'}}")),
         "create channel for noconv parsing: d missing");
-    testOk(checkValues(puser1, 99, 1, 0, 1.234e5, "bar", 0, 1),
+    testOk(checkValues(puser1, 99, 1, 0, 1.234e5, "bar", 0, 1, "foo"),
         "guards intact, values correct");
     if (pch) dbChannelDelete(pch);
 
     testOk(!!(pch = dbChannelCreate(
-        "x.{noconv:{i:1,d:1.2e15,s:'bar',c:'R'}}")),
+        "x.{noconv:{i:1,d:1.2e15,s:'bar',c:'R',a:'foo'}}")),
         "create channel for noconv parsing: f missing");
-    testOk(checkValues(puser1, 99, 1, 1, 1.2e15, "bar", 0, 1),
+    testOk(checkValues(puser1, 99, 1, 1, 1.2e15, "bar", 0, 1, "foo"),
         "guards intact, values correct");
     if (pch) dbChannelDelete(pch);
 
     testOk(!!(pch = dbChannelCreate(
-        "x.{noconv:{f:false,d:1.2e15,s:'bar',c:'R'}}")),
+        "x.{noconv:{f:false,d:1.2e15,s:'bar',c:'R',a:'foo'}}")),
         "create channel for noconv parsing: i missing");
-    testOk(checkValues(puser1, 99, 12, 0, 1.2e15, "bar", 0, 1),
+    testOk(checkValues(puser1, 99, 12, 0, 1.2e15, "bar", 0, 1, "foo"),
+        "guards intact, values correct");
+    if (pch) dbChannelDelete(pch);
+
+    testOk(!!(pch = dbChannelCreate(
+        "x.{noconv:{i:1,f:false,d:1.2e15,s:'bar',c:'R'}}")),
+        "create channel for noconv parsing: a missing");
+    testOk(checkValues(puser1, 99, 1, 0, 1.2e15, "bar", 0, 1, "default"),
+        "guards intact, values correct");
+    if (pch) dbChannelDelete(pch);
+
+    /* SIMPLIFIED parsing: only one argument */
+
+    /*  */
+    testHead("SIMPLIFIED parsing: all ok");
+
+    /* only one arg (i) defined */
+    testOk(!!(pch = dbChannelCreate("x.{onlyOne:1}")),
+           "create channel for onlyOne parsing: single arg");
+    testOk(checkValues(puser1, 99, 1, 1, 1.234e5, "hello", 0, 4, "default"),
+        "guards intact, values correct");
+    if (pch) dbChannelDelete(pch);
+
+    /* only one arg (d) required */
+    testOk(!!(pch = dbChannelCreate("x.{onlyOneRequired:1.23}")),
+           "create channel for onlyOneRequired parsing: single arg");
+    testOk(checkValues(puser1, 99, 12, 1, 1.23, "hello", 0, 4, "default"),
+        "guards intact, values correct");
+    if (pch) dbChannelDelete(pch);
+
+    /* ambigous arg fails */
+    testOk(!(pch = dbChannelCreate("x.{sloppy:1}")),
+           "create channel for sloppy parsing: ambigous arg");
+    if (pch) dbChannelDelete(pch);
+
+    /* No arg at all */
+    testOk(!!(pch = dbChannelCreate("x.{sloppy}")),
+           "create channel for sloppy parsing: no arg at all");
+    testOk(checkValues(puser1, 99, 12, 1, 1.234e5, "hello", 0, 4, "default"),
         "guards intact, values correct");
     if (pch) dbChannelDelete(pch);
 
+    /* No arg at all followed by another filter */
+    testHead("Chains of filters without args"); \
+    e1 = e_any; e2 = e_any;
+    testOk(!!(pch = dbChannelCreate("x.{sloppy,sloppy}")),
+           "create channel for chained argless filters: comma separated");
+    if (pch) dbChannelDelete(pch);
+    testOk(!!(pch = dbChannelCreate("x.{sloppy  ,   sloppy}")),
+           "create channel for chained argless filters: comma and space separated");
+    if (pch) dbChannelDelete(pch);
+    testOk(!(pch = dbChannelCreate("x.{sloppy#sloppy}")),
+           "create channel for chained argless filters fail: garbage separator");
+    if (pch) dbChannelDelete(pch);
+    testOk(!(pch = dbChannelCreate("x.{sloppy")),
+           "create channel for chained argless filters fail: missing end");
+    if (pch) dbChannelDelete(pch);
+
     /* Reject wrong types */
 #define WRONGTYPETEST(Var, Val, Typ) \
-    e1 = e_alloc | e_error | e_free; c1 = 0; \
+    e1 = e_alloc | e_error | e_free; c1 = 0; e2 = 0; \
     testOk(!(pch = dbChannelCreate("x.{noconv:{'"#Var"':"#Val"}}")), \
         "create channel for noconv parsing: wrong type "#Typ" for "#Var); \
     testOk(!puser1, "user part cleaned up"); \
@@ -872,15 +997,18 @@ MAIN(chfPluginTest)
     WRONGTYPETEST(c, 1.23, double);
     WRONGTYPETEST(c, true, boolean);
     WRONGTYPETEST(c, 2, integer);
+    WRONGTYPETEST(a, 1.23, double);
+    WRONGTYPETEST(a, true, boolean);
+    WRONGTYPETEST(a, 123, integer);
 
     /* SLOPPY parsing: optional, with conversion */
 
-#define CONVTESTGOOD(Var, Val, Typ, Ival, Fval, Dval, Sval1, Sval2, Cval) \
-    e1 = e_alloc | e_ok; c1 = 0; \
+#define CONVTESTGOOD(Var, Val, Typ, Ival, Fval, Dval, Sval1, Sval2, Cval, Dstr) \
+    e1 = e_alloc | e_ok; c1 = 0; e2 = 0; \
     testDiag("Calling dbChannelCreate x.{sloppy:{"#Var":"#Val"}}"); \
     testOk(!!(pch = dbChannelCreate("x.{sloppy:{"#Var":"#Val"}}")), \
         "create channel for sloppy parsing: "#Typ" (good) for "#Var); \
-    testOk(checkValues(puser1, 99, Ival, Fval, Dval, Sval1, Sval2, Cval), \
+    testOk(checkValues(puser1, 99, Ival, Fval, Dval, Sval1, Sval2, Cval, Dstr), \
         "guards intact, values correct"); \
     if (!testOk(c1 == e1, "create channel: all expected calls happened")) \
         testDiag("expected %#x - called %#x", e1, c1); \
@@ -891,7 +1019,7 @@ MAIN(chfPluginTest)
         testDiag("expected %#x - called %#x", e1, c1);
 
 #define CONVTESTBAD(Var, Val, Typ) \
-    e1 = e_alloc | e_error | e_free; c1 = 0; \
+    e1 = e_alloc | e_error | e_free; c1 = 0; e2 = 0; \
     testDiag("Calling dbChannelCreate x.{sloppy:{"#Var":"#Val"}}"); \
     testOk(!(pch = dbChannelCreate("x.{sloppy:{"#Var":"#Val"}}")), \
         "create channel for sloppy parsing: "#Typ" (bad) for "#Var); \
@@ -901,67 +1029,79 @@ MAIN(chfPluginTest)
 
     /* To integer */
     testHead("SLOPPY parsing: conversion to integer");
-    CONVTESTGOOD(i, "123e4", positive string, 123, 1, 1.234e5, "hello", 0, 4);
-    CONVTESTGOOD(i, "-12345", negative string, -12345, 1, 1.234e5, "hello", 0, 4);
+    CONVTESTGOOD(i, "123e4", positive string, 123, 1, 1.234e5, "hello", 0, 4, "default");
+    CONVTESTGOOD(i, "-12345", negative string, -12345, 1, 1.234e5, "hello", 0, 4, "default");
     CONVTESTBAD(i, "9234567890", out-of-range string);
     CONVTESTBAD(i, ".4", invalid string);
-    CONVTESTGOOD(i, false, valid boolean, 0, 1, 1.234e5, "hello", 0, 4);
-    CONVTESTGOOD(i, 3456.789, valid double, 3456, 1, 1.234e5, "hello", 0, 4);
+    CONVTESTGOOD(i, false, valid boolean, 0, 1, 1.234e5, "hello", 0, 4, "default");
+    CONVTESTGOOD(i, 3456.789, valid double, 3456, 1, 1.234e5, "hello", 0, 4, "default");
     CONVTESTBAD(i, 34.7e14, out-of-range double);
 
     /* To boolean */
     testHead("SLOPPY parsing: conversion to boolean");
-    CONVTESTGOOD(f, "false", valid string, 12, 0, 1.234e5, "hello", 0, 4);
-    CONVTESTGOOD(f, "False", capital valid string, 12, 0, 1.234e5, "hello", 0, 4);
-    CONVTESTGOOD(f, "0", 0 string, 12, 0, 1.234e5, "hello", 0, 4);
-    CONVTESTGOOD(f, "15", 15 string, 12, 1, 1.234e5, "hello", 0, 4);
+    CONVTESTGOOD(f, "false", valid string, 12, 0, 1.234e5, "hello", 0, 4, "default");
+    CONVTESTGOOD(f, "False", capital valid string, 12, 0, 1.234e5, "hello", 0, 4, "default");
+    CONVTESTGOOD(f, "0", 0 string, 12, 0, 1.234e5, "hello", 0, 4, "default");
+    CONVTESTGOOD(f, "15", 15 string, 12, 1, 1.234e5, "hello", 0, 4, "default");
     CONVTESTBAD(f, ".4", invalid .4 string);
     CONVTESTBAD(f, "Flase", misspelled invalid string);
-    CONVTESTGOOD(f, 0, zero integer, 12, 0, 1.234e5, "hello", 0, 4);
-    CONVTESTGOOD(f, 12, positive integer, 12, 1, 1.234e5, "hello", 0, 4);
-    CONVTESTGOOD(f, -1234, negative integer, 12, 1, 1.234e5, "hello", 0, 4);
-    CONVTESTGOOD(f, 0.4, positive non-zero double, 12, 1, 1.234e5, "hello", 0, 4);
-    CONVTESTGOOD(f, 0.0, zero double, 12, 0, 1.234e5, "hello", 0, 4);
-    CONVTESTGOOD(f, -0.0, minus-zero double, 12, 0, 1.234e5, "hello", 0, 4);
-    CONVTESTGOOD(f, -1.24e14, negative double, 12, 1, 1.234e5, "hello", 0, 4);
+    CONVTESTGOOD(f, 0, zero integer, 12, 0, 1.234e5, "hello", 0, 4, "default");
+    CONVTESTGOOD(f, 12, positive integer, 12, 1, 1.234e5, "hello", 0, 4, "default");
+    CONVTESTGOOD(f, -1234, negative integer, 12, 1, 1.234e5, "hello", 0, 4, "default");
+    CONVTESTGOOD(f, 0.4, positive non-zero double, 12, 1, 1.234e5, "hello", 0, 4, "default");
+    CONVTESTGOOD(f, 0.0, zero double, 12, 0, 1.234e5, "hello", 0, 4, "default");
+    CONVTESTGOOD(f, -0.0, minus-zero double, 12, 0, 1.234e5, "hello", 0, 4, "default");
+    CONVTESTGOOD(f, -1.24e14, negative double, 12, 1, 1.234e5, "hello", 0, 4, "default");
 
     /* To double */
     testHead("SLOPPY parsing: conversion to double");
-    CONVTESTGOOD(d, "123e4", positive double string, 12, 1, 1.23e6, "hello", 0, 4);
-    CONVTESTGOOD(d, "-7.89e-14", negative double string, 12, 1, -7.89e-14, "hello", 0, 4);
-    CONVTESTGOOD(d, "123", positive integer string, 12, 1, 123.0, "hello", 0, 4);
-    CONVTESTGOOD(d, "-1234567", negative integer string, 12, 1, -1.234567e6, "hello", 0, 4);
+    CONVTESTGOOD(d, "123e4", positive double string, 12, 1, 1.23e6, "hello", 0, 4, "default");
+    CONVTESTGOOD(d, "-7.89e-14", negative double string, 12, 1, -7.89e-14, "hello", 0, 4, "default");
+    CONVTESTGOOD(d, "123", positive integer string, 12, 1, 123.0, "hello", 0, 4, "default");
+    CONVTESTGOOD(d, "-1234567", negative integer string, 12, 1, -1.234567e6, "hello", 0, 4, "default");
     CONVTESTBAD(d, "1.67e407", out-of-range double string);
     CONVTESTBAD(d, "blubb", invalid blubb string);
-    CONVTESTGOOD(d, 123, positive integer, 12, 1, 123.0, "hello", 0, 4);
-    CONVTESTGOOD(d, -12345, negative integer, 12, 1, -1.2345e4, "hello", 0, 4);
-    CONVTESTGOOD(d, true, true boolean, 12, 1, 1.0, "hello", 0, 4);
-    CONVTESTGOOD(d, false, false boolean, 12, 1, 0.0, "hello", 0, 4);
+    CONVTESTGOOD(d, 123, positive integer, 12, 1, 123.0, "hello", 0, 4, "default");
+    CONVTESTGOOD(d, -12345, negative integer, 12, 1, -1.2345e4, "hello", 0, 4, "default");
+    CONVTESTGOOD(d, true, true boolean, 12, 1, 1.0, "hello", 0, 4, "default");
+    CONVTESTGOOD(d, false, false boolean, 12, 1, 0.0, "hello", 0, 4, "default");
 
     /* To string */
     testHead("SLOPPY parsing: conversion to string");
-    CONVTESTGOOD(s, 12345, positive integer, 12, 1, 1.234e5, "12345", 0, 4);
-    CONVTESTGOOD(s, -1234567891, negative integer, 12, 1, 1.234e5, "-1234567891", 0, 4);
-    CONVTESTGOOD(s, true, true boolean, 12, 1, 1.234e5, "true", 0, 4);
-    CONVTESTGOOD(s, false, false boolean, 12, 1, 1.234e5, "false", 0, 4);
-    CONVTESTGOOD(s, 123e4, small positive double, 12, 1, 1.234e5, "1230000", 0, 4);
-    CONVTESTGOOD(s, -123e24, negative double, 12, 1, 1.234e5, "-1.23e+26", "-1.23e+026", 4);
-    CONVTESTGOOD(s, -1.23456789123e26, large negative double, 12, 1, 1.234e5, "-1.23456789123e+26", "-1.23456789123e+026", 4);
+    CONVTESTGOOD(s, 12345, positive integer, 12, 1, 1.234e5, "12345", 0, 4, "default");
+    CONVTESTGOOD(s, -1234567891, negative integer, 12, 1, 1.234e5, "-1234567891", 0, 4, "default");
+    CONVTESTGOOD(s, true, true boolean, 12, 1, 1.234e5, "true", 0, 4, "default");
+    CONVTESTGOOD(s, false, false boolean, 12, 1, 1.234e5, "false", 0, 4, "default");
+    CONVTESTGOOD(s, 123e4, small positive double, 12, 1, 1.234e5, "1230000", 0, 4, "default");
+    CONVTESTGOOD(s, -123e24, negative double, 12, 1, 1.234e5, "-1.23e+26", "-1.23e+026", 4, "default");
+    CONVTESTGOOD(s, -1.23456789123e26, large negative double, 12, 1, 1.234e5, "-1.23456789123e+26", "-1.23456789123e+026", 4, "default");
 
     /* To Enum */
     testHead("SLOPPY parsing: conversion to enum");
-    CONVTESTGOOD(c, 2, valid integer choice, 12, 1, 1.234e5, "hello", 0, 2);
+    CONVTESTGOOD(c, 2, valid integer choice, 12, 1, 1.234e5, "hello", 0, 2, "default");
     CONVTESTBAD(c, 3, invalid integer choice);
     CONVTESTBAD(c, 3.2, double);
-    CONVTESTGOOD(c, "R", valid string choice, 12, 1, 1.234e5, "hello", 0, 1);
+    CONVTESTGOOD(c, "R", valid string choice, 12, 1, 1.234e5, "hello", 0, 1, "default");
     CONVTESTBAD(c, "blubb", invalid string choice);
 
+    /* To allocated string */
+    testHead("SLOPPY parsing: conversion to string");
+    CONVTESTGOOD(a, 12345, positive integer, 12, 1, 1.234e5, "hello", 0, 4, "12345");
+    CONVTESTGOOD(a, -1234567891, negative integer, 12, 1, 1.234e5, "hello", 0, 4, "-1234567891");
+    CONVTESTGOOD(a, true, true boolean, 12, 1, 1.234e5, "hello", 0, 4, "true");
+    CONVTESTGOOD(a, false, false boolean, 12, 1, 1.234e5, "hello", 0, 4, "false");
+    CONVTESTGOOD(a, 123e4, small positive double, 12, 1, 1.234e5, "hello", 0, 4, "1230000");
+    CONVTESTGOOD(a, -123e24, negative double, 12, 1, 1.234e5, "hello", 0, 4, "-1.23e+26");
+    CONVTESTGOOD(a, -1.23456789123e26, large negative double, 12, 1, 1.234e5, "hello", 0, 4, "-1.23456789123e+26");
+    CONVTESTGOOD(a, {}, empty argument, 12, 1, 1.234e5, "hello", 0, 4, 0);
+    CONVTESTGOOD(a, '', empty string, 12, 1, 1.234e5, "hello", 0, 4, "");
+
     /* Registering and running filter callbacks */
 
 #define CHAINTEST1(Type, Json, ExpReg, ExpRun, DType) \
     testHead("Filter chain test, "Type" filter"); \
     offset = 0; \
-    e1 = e_alloc | e_ok; c1 = 0; \
+    e1 = e_alloc | e_ok; c1 = 0; e2 = 0; \
     testOk(!!(pch = dbChannelCreate("x."Json)), "filter chains: create channel with "Type" filter"); \
     if (!testOk(c1 == e1, "create channel: all expected calls happened")) testDiag("expected %#x - called %#x", e1, c1); \
     e1 = e_open | ExpReg; c1 = 0; \
diff --git a/modules/database/test/std/filters/decTest.c b/modules/database/test/std/filters/decTest.c
index e0961af..1eefe5d 100644
--- a/modules/database/test/std/filters/decTest.c
+++ b/modules/database/test/std/filters/decTest.c
@@ -251,8 +251,8 @@ MAIN(decTest)
 
     /* Decimation (N=4) */
 
-    testHead("Decimation (n=4)");
-    testOk(!!(pch = dbChannelCreate("x.VAL{dec:{n:4}}")),
+    testHead("Decimation (n=4) with simplified syntax");
+    testOk(!!(pch = dbChannelCreate("x.VAL{dec:4}")),
            "dbChannel with plugin dec (n=4) created");
 
     checkAndOpenChannel(pch, plug);
diff --git a/modules/database/test/std/filters/tsTest.c b/modules/database/test/std/filters/tsTest.c
index bd0b799..31ceb99 100644
--- a/modules/database/test/std/filters/tsTest.c
+++ b/modules/database/test/std/filters/tsTest.c
@@ -74,7 +74,7 @@ MAIN(tsTest)
 
     testOk(!!(plug = dbFindFilter(ts, strlen(ts))), "plugin ts registered correctly");
 
-    testOk(!!(pch = dbChannelCreate("x.VAL{ts:{}}")), "dbChannel with plugin ts created");
+    testOk(!!(pch = dbChannelCreate("x.{ts}")), "dbChannel with plugin ts created");
     testOk((ellCount(&pch->filters) == 1), "channel has one plugin");
 
     memset(&fl, PATTERN, sizeof(fl));