configure/modules/RULES_VLIBS

 
-.PHONY: vlibs
+#.PHONY: vlibs
 
-vlibs: conf
-	$(QUIET) $(E3_MODULE_MAKE_CMDS) vlibs
+## Install vendor libraries
+#vlibs: conf
+#	$(QUIET) $(E3_MODULE_MAKE_CMDS) vlibs
 

docs/TODO.md

+# Version 3.3.1
+
+## Finished
+
+* Remove `loadIocsh`, which simply duplicates `runScript` for some reason. (Done by Krisztian f02d2c88ffd802f78fa61795486d1bd5ed13e96a)
+* Fix the metadata for the wrapper e.g. the url should not fetch origin, but the first remote. FIXED 57dc892bfb29c8ddad82baf2d2f287a766800dca
+* Not sure why the description fails for the wrapper, however. Aha: the ifeq in CONFIG_E3_MAKEFILE should compare $$? not $?. FIXED 57dc892bfb29c8ddad82baf2d2f287a766800dca
+* `make build` followed by `make cellinstall` should not do a rebuild. This is done because
+  `INSTBASE` changes, and for `make cellinstall` we should ignore that. FIXED (require/2f2016179004eae6811f6f3a5567a0db1fd8b81e)
+* Allow SKIP_TEST FIXED 3590a3a8ced658251a333c59396cdbe836b418a4
+* `make patch` does not respect build numbers: FIXED 7388f41d19230141e5c54ed2130109d30e52514c
+* Fix the install permissions for cellMods FIXED aa4749f887ed92fb90f577326c9e756fadbc081b
+* `cellinstall` should write the version of base/require! b9168c9a3479bb4efe3df1e7bbfdb667903aa5ab
+* require gets its version from CONFIG_MODULE, so why is it specified in RELEASE? This is confusing. ac9ec7b6e73dc5968b5500f8daf93155fb4699fe
+* Remove `rm -rf cellMods` from `celluninstall` target; this is not a great idea if we are using multiple modules installed in the same place. 598cf611260fb40780db204cdc814f7c3a0e305e  
+* Go through and figure out if we should remove all of the `sudo` usage. 922905e247d6f6ac309b0909f994576f9fedc2b5
+
+## Not done
+
+* Remove more vxWorks/3.x code in e.g. runScript.c and expr.c
+* Also, we need to be able to test once it is installed. This would fit with the iterating thing that I had made.
+* The auto-load build number thing doesn't seem to work correctly with build descriptors
+* Figure out how to fix the fact that asyn, on build, installs devEpics.dbd *** IMPORTANT <=== Needs a patch on EPICS base
+* `make cellinstall` does not install vendor libraries anywhere.
+* Moreover, vlibs are installed with no reference to `$(T_A)`, which isn't a good idea! One possible idea:
+  we could move the `vlibs` target into driver.makefile instead of letting it reside outside in the 
+  module makefile. This needs to be discussed.
+* module_DB vs module_DIR: DIR includes trailing slash, DB does not. Fix?
+* Should there be an error message if non-existent versions of e.g. sequencer are specified?
+* base/require version should be added to shared library object; this is needed for cellinstall but should
+  more generally be used on startup to check that the library was compiled with the running version of base/require.
\ No newline at end of file

require @ d2a89ffe

-Subproject commit d2a89ffee8d5b40f1b37cf0be378790f72cf71f6

require-ess/Db/moduleversion.template

+record (waveform, "$(REQUIRE_IOC):MODULES")
+{
+    field (DESC, "List of loaded modules")
+    field (FTVL, "STRING")
+    field (NELM, "$(MODULE_COUNT)")
+    field (PINI, "YES")
+}
+
+record (waveform, "$(REQUIRE_IOC):VERSIONS")
+{
+    field (DESC, "Versions of loaded modules")
+    field (FTVL, "STRING")
+    field (NELM, "$(MODULE_COUNT)")
+    field (PINI, "YES")
+}
+
+record (waveform, "$(REQUIRE_IOC):MOD_VER")
+{
+    field (DESC, "List of loaded modules")
+    field (FTVL, "CHAR")
+    field (NELM, "$(BUFFER_SIZE)")
+    field (PINI, "YES")
+}
+
+record (stringin, "$(REQUIRE_IOC):$(MODULE)_VER")
+{
+    field (DESC, "Module $(MODULE) version")
+    field (VAL,  "$(VERSION)")
+    field (PINI, "YES")
+}

require-ess/src/asprintf.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include "asprintf.h"
+
+/* some implementations have __va_copy instead of va_copy */
+#if !defined(va_copy) && defined (__va_copy)
+#define va_copy __va_copy
+#endif
+
+int vasprintf(char** pbuffer, const char* format, va_list ap)
+{
+    int len = -1;
+
+#ifdef va_copy
+    va_list ap2;
+    va_copy(ap2, ap);
+#else
+    /* if we have no va_copy, we probably don't need one */
+    #define ap2 ap
+#endif
+
+#if defined(_WIN32)
+    len = _vscprintf(format, ap2);
+#else
+    len = vsnprintf(NULL, 0, format, ap2);
+#endif
+
+#ifdef va_copy
+    va_end(ap2);
+#endif
+    
+    if (len <= 0)
+    {
+        fprintf(stderr, "vasprintf: error calculating needed size\n");
+        return -1;
+    }
+    *pbuffer = malloc(len+1);
+    if (*pbuffer == NULL) return -1;
+    return vsprintf(*pbuffer, format, ap);
+}
+
+int asprintf(char** pbuffer, const char* format, ...)
+{
+    va_list ap;
+    int len;
+
+    va_start(ap, format);
+    len = vasprintf(pbuffer, format, ap);
+    va_end(ap);
+    return len;
+}

require-ess/src/asprintf.h

+#ifndef asprintf_h
+#define asprintf_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <stdarg.h>
+#ifndef __GNUC__
+#define __attribute__(arg)
+#endif
+
+int asprintf(char** pbuffer, const char* format, ...) __attribute__((__format__(__printf__,2,3)));
+int vasprintf(char** pbuffer, const char* format, va_list ap) __attribute__((__format__(__printf__,2,0)));
+#ifdef __cplusplus
+}
+#endif
+#endif

require-ess/src/dbLoadTemplate.dbd

+registrar(dbLoadTemplateRegister)

require-ess/src/dbLoadTemplate.h

+/*************************************************************************\
+* Copyright (c) 2002 The University of Chicago, as Operator of Argonne
+*     National Laboratory.
+* Copyright (c) 2002 The Regents of the University of California, as
+*     Operator of Los Alamos National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution. 
+\*************************************************************************/
+/* dbLoadTemplate.h */
+
+#ifndef INCdbLoadTemplateh
+#define INCdbLoadTemplateh
+
+#include "shareLib.h"
+epicsShareFunc int dbLoadTemplate(
+    const char *sub_file, const char *cmd_collect, const char *path);
+
+#endif /*INCdbLoadTemplateh*/

require-ess/src/dbLoadTemplate.y

+%{
+
+/*************************************************************************\
+* Copyright (c) 2006 UChicago, as Operator of Argonne
+*     National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution. 
+\*************************************************************************/
+
+/* for vasprintf */
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <errno.h>
+
+#if !defined (_WIN32)
+#include <unistd.h>
+#endif
+
+#include "macLib.h"
+#include "dbmf.h"
+
+#include "dbAccess.h"
+#include "dbLoadTemplate.h"
+#include "osiFileName.h"
+#include "epicsVersion.h"
+
+#if defined(vxWorks) || defined (_WIN32)
+#include "asprintf.h"
+#endif
+
+#ifdef BASE_VERSION
+#define EPICS_3_13
+extern void dbLoadRecords(const char*, const char*);
+#else
+#include "iocsh.h"
+#include "epicsExport.h"
+#endif
+
+#if (EPICS_VERSION*10000+EPICS_REVISION*100+EPICS_MODIFICATION<31412)
+#define dbmfStrdup(s) strcpy(dbmfMalloc(strlen((char*)(s))+1),(char*)(s))
+#endif
+
+#if (EPICS_VERSION*10000+EPICS_REVISION*100+EPICS_MODIFICATION>=31600)
+#define dbmfStrdup(s) dbmfStrdup((char*)s) 
+#endif
+
+static int line_num;
+static int yyerror(char* str);
+
+static char *sub_collect = NULL;
+static char *sub_locals;
+static char **vars = NULL;
+static char *db_file_name = NULL;
+static int var_count, sub_count;
+
+/* We allocate MAX_VAR_FACTOR chars in the sub_collect string for each
+ * "variable=value," segment, and will accept at most dbTemplateMaxVars
+ * template variables.  The user can adjust that variable to increase
+ * the number of variables or the length allocated for the buffer.
+ */
+#define MAX_VAR_FACTOR 50
+
+int dbTemplateMaxVars = 100;
+
+%}
+
+%start substitution_file
+
+%token <Str> WORD QUOTE
+%token DBFILE
+%token PATTERN
+%token GLOBAL
+%token EQUALS COMMA
+%left O_PAREN C_PAREN
+%left O_BRACE C_BRACE
+
+%union
+{
+    int Int;
+    char Char;
+    char *Str;
+    double Real;
+}
+
+%%
+
+substitution_file: global_or_template
+    | substitution_file global_or_template
+    ;
+
+global_or_template: global_definitions
+    | template_substitutions
+    ;
+
+global_definitions: GLOBAL O_BRACE C_BRACE
+    | GLOBAL O_BRACE variable_definitions C_BRACE
+    {
+    #ifdef ERROR_STUFF
+        fprintf(stderr, "global_definitions: %s\n", sub_collect+1);
+    #endif
+        sub_locals += strlen(sub_locals);
+    }
+    ;
+
+template_substitutions: template_filename O_BRACE C_BRACE
+    {
+    #ifdef ERROR_STUFF
+        fprintf(stderr, "template_substitutions: %s unused\n", db_file_name);
+    #endif
+        dbmfFree(db_file_name);
+        db_file_name = NULL;
+    }
+    | template_filename O_BRACE substitutions C_BRACE
+    {
+    #ifdef ERROR_STUFF
+        fprintf(stderr, "template_substitutions: %s finished\n", db_file_name);
+    #endif
+        dbmfFree(db_file_name);
+        db_file_name = NULL;
+    }
+    ;
+
+template_filename: DBFILE WORD
+    {
+    #ifdef ERROR_STUFF
+        fprintf(stderr, "template_filename: %s\n", $2);
+    #endif
+        var_count = 0;
+        db_file_name = dbmfMalloc(strlen($2)+1);
+        strcpy(db_file_name, $2);
+        dbmfFree($2);
+    }
+    | DBFILE QUOTE
+    {
+    #ifdef ERROR_STUFF
+        fprintf(stderr, "template_filename: \"%s\"\n", $2);
+    #endif
+        var_count = 0;
+        db_file_name = dbmfMalloc(strlen($2)+1);
+        strcpy(db_file_name, $2);
+        dbmfFree($2);
+    }
+    ;
+
+substitutions: pattern_substitutions
+    | variable_substitutions
+    ;
+
+pattern_substitutions: PATTERN O_BRACE C_BRACE
+    | PATTERN O_BRACE C_BRACE pattern_definitions
+    | PATTERN O_BRACE pattern_names C_BRACE
+    | PATTERN O_BRACE pattern_names C_BRACE pattern_definitions
+    ;
+
+pattern_names: pattern_name
+    | pattern_names COMMA
+    | pattern_names pattern_name
+    ;
+
+pattern_name: WORD
+    {
+    #ifdef ERROR_STUFF
+        fprintf(stderr, "pattern_name: [%d] = %s\n", var_count, $1);
+    #endif
+        if (var_count >= dbTemplateMaxVars) {
+            fprintf(stderr,
+                "More than dbTemplateMaxVars = %d macro variables used\n",
+                dbTemplateMaxVars);
+            yyerror(NULL);
+        }
+        else {
+            vars[var_count] = dbmfMalloc(strlen($1)+1);
+            strcpy(vars[var_count], $1);
+            var_count++;
+            dbmfFree($1);
+        }
+    }
+    ;
+
+pattern_definitions: pattern_definition
+    | pattern_definitions pattern_definition
+    ;
+
+pattern_definition: global_definitions
+    | O_BRACE C_BRACE
+    {
+    #ifdef ERROR_STUFF
+        fprintf(stderr, "pattern_definition: pattern_values empty\n");
+        fprintf(stderr, "    dbLoadRecords(%s)\n", sub_collect+1);
+    #endif
+        dbLoadRecords(db_file_name, sub_collect+1);
+    }
+    | O_BRACE pattern_values C_BRACE
+    {
+    #ifdef ERROR_STUFF
+        fprintf(stderr, "pattern_definition:\n");
+        fprintf(stderr, "    dbLoadRecords(%s)\n", sub_collect+1);
+    #endif
+        dbLoadRecords(db_file_name, sub_collect+1);
+        *sub_locals = '\0';
+        sub_count = 0;
+    }
+    | WORD O_BRACE pattern_values C_BRACE
+    {   /* DEPRECATED SYNTAX */
+        fprintf(stderr,
+            "dbLoadTemplate: Substitution file uses deprecated syntax.\n"
+            "    the string '%s' on line %d that comes just before the\n"
+            "    '{' character is extraneous and should be removed.\n",
+            $1, line_num);
+    #ifdef ERROR_STUFF
+        fprintf(stderr, "pattern_definition:\n");
+        fprintf(stderr, "    dbLoadRecords(%s)\n", sub_collect+1);
+    #endif
+        dbLoadRecords(db_file_name, sub_collect+1);
+        dbmfFree($1);
+        *sub_locals = '\0';
+        sub_count = 0;
+    }
+    ;
+
+pattern_values: pattern_value
+    | pattern_values COMMA
+    | pattern_values pattern_value
+    ;
+
+pattern_value: QUOTE
+    {
+    #ifdef ERROR_STUFF
+        fprintf(stderr, "pattern_value: [%d] = \"%s\"\n", sub_count, $1);
+    #endif
+        if (sub_count < var_count) {
+            strcat(sub_locals, ",");
+            strcat(sub_locals, vars[sub_count]);
+            strcat(sub_locals, "=\"");
+            strcat(sub_locals, $1);
+            strcat(sub_locals, "\"");
+            sub_count++;
+        } else {
+            fprintf(stderr, "dbLoadTemplate: Too many values given, line %d.\n",
+                line_num);
+        }
+        dbmfFree($1);
+    }
+    | WORD
+    {
+    #ifdef ERROR_STUFF
+        fprintf(stderr, "pattern_value: [%d] = %s\n", sub_count, $1);
+    #endif
+        if (sub_count < var_count) {
+            strcat(sub_locals, ",");
+            strcat(sub_locals, vars[sub_count]);
+            strcat(sub_locals, "=");
+            strcat(sub_locals, $1);
+            sub_count++;
+        } else {
+            fprintf(stderr, "dbLoadTemplate: Too many values given, line %d.\n",
+                line_num);
+        }
+        dbmfFree($1);
+    }
+    ;
+
+variable_substitutions: variable_substitution
+    | variable_substitutions variable_substitution
+    ;
+
+variable_substitution: global_definitions
+    | O_BRACE C_BRACE
+    {
+    #ifdef ERROR_STUFF
+        fprintf(stderr, "variable_substitution: variable_definitions empty\n");
+        fprintf(stderr, "    dbLoadRecords(%s)\n", sub_collect+1);
+    #endif
+        dbLoadRecords(db_file_name, sub_collect+1);
+    }
+    | O_BRACE variable_definitions C_BRACE
+    {
+    #ifdef ERROR_STUFF
+        fprintf(stderr, "variable_substitution:\n");
+        fprintf(stderr, "    dbLoadRecords(%s)\n", sub_collect+1);
+    #endif
+        dbLoadRecords(db_file_name, sub_collect+1);
+        *sub_locals = '\0';
+    }
+    | WORD O_BRACE variable_definitions C_BRACE
+    {   /* DEPRECATED SYNTAX */
+        fprintf(stderr,
+            "dbLoadTemplate: Substitution file uses deprecated syntax.\n"
+            "    the string '%s' on line %d that comes just before the\n"
+            "    '{' character is extraneous and should be removed.\n",
+            $1, line_num);
+    #ifdef ERROR_STUFF
+        fprintf(stderr, "variable_substitution:\n");
+        fprintf(stderr, "    dbLoadRecords(%s)\n", sub_collect+1);
+    #endif
+        dbLoadRecords(db_file_name, sub_collect+1);
+        dbmfFree($1);
+        *sub_locals = '\0';
+    }
+    ;
+
+variable_definitions: variable_definition
+    | variable_definitions COMMA
+    | variable_definitions variable_definition
+    ;
+
+variable_definition: WORD EQUALS WORD
+    {
+    #ifdef ERROR_STUFF
+        fprintf(stderr, "variable_definition: %s = %s\n", $1, $3);
+    #endif
+        strcat(sub_locals, ",");
+        strcat(sub_locals, $1);
+        strcat(sub_locals, "=");
+        strcat(sub_locals, $3);
+        dbmfFree($1); dbmfFree($3);
+    }
+    | WORD EQUALS QUOTE
+    {
+    #ifdef ERROR_STUFF
+        fprintf(stderr, "variable_definition: %s = \"%s\"\n", $1, $3);
+    #endif
+        strcat(sub_locals, ",");
+        strcat(sub_locals, $1);
+        strcat(sub_locals, "=\"");
+        strcat(sub_locals, $3);
+        strcat(sub_locals, "\"");
+        dbmfFree($1); dbmfFree($3);
+    }
+    | QUOTE EQUALS QUOTE
+    {
+    #ifdef ERROR_STUFF
+        fprintf(stderr, "variable_definition: \"%s\" = \"%s\"\n", $1, $3);
+    #endif
+        strcat(sub_locals, ",\"");
+        strcat(sub_locals, $1);
+        strcat(sub_locals, "\"=\"");
+        strcat(sub_locals, $3);
+        strcat(sub_locals, "\"");
+        dbmfFree($1); dbmfFree($3);
+    }
+    ;
+
+%%
+ 
+#include "dbLoadTemplate_lex.c"
+ 
+static int yyerror(char* str)
+{
+    if (str)
+        fprintf(stderr, "Substitution file error: %s\n", str);
+    else
+        fprintf(stderr, "Substitution file error.\n");
+    fprintf(stderr, "line %d: '%s'\n", line_num, yytext);
+    return 0;
+}
+
+static int is_not_inited = 1;
+
+int dbLoadTemplate(const char *sub_file, const char *cmd_collect, const char *path)
+{
+    FILE *fp;
+    int i;
+
+    line_num = 1;
+    
+    if (!sub_file || !*sub_file) {
+        fprintf(stderr, "must specify variable substitution file\n");
+        return -1;
+    }
+
+    if (dbTemplateMaxVars < 1) {
+        fprintf(stderr,"Error: dbTemplateMaxVars = %d, must be positive\n",
+                dbTemplateMaxVars);
+        return -1;
+    }
+
+    fp = fopen(sub_file, "r");
+    if (!fp && sub_file[0] != OSI_PATH_SEPARATOR[0]) {
+        const char *dirname, *end;
+        int dirlen;
+        char* filename;
+
+        if (!path || !*path) {
+	    path = getenv("EPICS_DB_INCLUDE_PATH");
+        }
+        for(dirname = path; dirname != NULL; dirname = end) {
+            end = strchr(dirname, OSI_PATH_LIST_SEPARATOR[0]);
+            if (end) dirlen = (int)(end++ - dirname);
+            else dirlen = (int)strlen(dirname);
+            if (dirlen == 0) continue; /* ignore empty path elements */
+            if (dirlen == 1 && dirname[0] == '.') continue; /* we had . already */
+            filename = NULL;
+            if (asprintf(&filename, "%.*s" OSI_PATH_SEPARATOR "%s", dirlen, dirname, sub_file) < 0)
+            {
+                fprintf(stderr,"dbLoadTemplate: out of memory\n");
+                break;
+            }
+            fp = fopen(filename, "r");
+            free(filename);
+            if (fp) break;
+        }
+    }
+    if (!fp) {
+        fprintf(stderr, "dbLoadTemplate: error opening sub file %s: %s\n", sub_file, strerror(errno));
+        return -1;
+    }
+
+    vars = malloc(dbTemplateMaxVars * sizeof(char*));
+    sub_collect = malloc(dbTemplateMaxVars * MAX_VAR_FACTOR);
+    if (!vars || !sub_collect) {
+        free(vars);
+        free(sub_collect);
+        fclose(fp);
+        fprintf(stderr, "dbLoadTemplate: Out of memory!\n");
+        return -1;
+    }
+    strcpy(sub_collect, ",");
+
+    if (cmd_collect && *cmd_collect) {
+        strcat(sub_collect, cmd_collect);
+        sub_locals = sub_collect + strlen(sub_collect);
+    } else {
+        sub_locals = sub_collect;
+        *sub_locals = '\0';
+    }
+    var_count = 0;
+    sub_count = 0;
+
+    if (is_not_inited) {
+        yyin = fp;
+        is_not_inited = 0;
+    } else {
+        yyrestart(fp);
+    }
+
+    yyparse();
+
+    for (i = 0; i < var_count; i++) {
+        dbmfFree(vars[i]);
+    }
+    free(vars);
+    free(sub_collect);
+    vars = NULL;
+    fclose(fp);
+    if (db_file_name) {
+        dbmfFree(db_file_name);
+        db_file_name = NULL;
+    }
+    return 0;
+}
+
+#ifndef EPICS_3_13
+#include "registry.h"
+epicsExportAddress(int, dbTemplateMaxVars);
+
+static const iocshFuncDef dbLoadTemplateDef = {
+    "dbLoadTemplate", 3, (const iocshArg *[]) {
+        &(iocshArg) { "filename", iocshArgString },
+        &(iocshArg) { "\"macro=value,...\"", iocshArgString },
+        &(iocshArg) { "searchpath", iocshArgString },
+}};
+
+#ifdef __GNUC__
+/* Without this I always get the original dbLoadTemplate linked instead of my version */
+int __dbLoadTemplate(const char *sub_file, const char *cmd_collect, const char *path) __attribute__ ((alias ("dbLoadTemplate")));
+#define dbLoadTemplate __dbLoadTemplate
+#endif
+
+static void dbLoadTemplateFunc(const iocshArgBuf *args)
+{
+    dbLoadTemplate(args[0].sval, args[1].sval, args[2].sval);
+}
+
+typedef struct iocshCommand {
+    iocshFuncDef const    *pFuncDef;
+    iocshCallFunc          func;
+    struct iocshCommand   *next;
+}iocshCommand;
+
+static void dbLoadTemplateRegister(void)
+{
+    static int firstTime = 1;
+    if (firstTime) {
+        iocshRegister(&dbLoadTemplateDef, dbLoadTemplateFunc);
+        firstTime = 0;
+    }
+}
+
+epicsExportRegistrar(dbLoadTemplateRegister);
+#endif

require-ess/src/dbLoadTemplate_lex.l

+/*************************************************************************\
+* Copyright (c) 2006 UChicago, as Operator of Argonne
+*     National Laboratory.
+* EPICS BASE is distributed subject to a Software License Agreement found
+* in file LICENSE that is included with this distribution. 
+\*************************************************************************/
+
+newline     "\n"
+backslash   "\\"
+doublequote "\""
+singlequote "'"
+comment     "#"
+whitespace  [ \t\r]
+escape      {backslash}.
+dstringchar [^"\n\\]
+sstringchar [^'\n\\]
+/*
+This breaks backward compatibility to 3.14.8:
+bareword    [a-zA-Z0-9_\-+:./\\\[\]<>;]
+Re-enable unquoted chars except #
+*/
+bareword    [a-zA-Z0-9_\-+:./\\\[\]<>;^~*%!|&$()@?]
+
+%%
+
+"pattern" { return(PATTERN);    }
+"file"    { return(DBFILE);     }
+"global"  { return(GLOBAL);     }
+
+{doublequote}({dstringchar}|{escape})*{doublequote} |
+{singlequote}({sstringchar}|{escape})*{singlequote} {
+    yylval.Str = dbmfStrdup(yytext+1);
+    yylval.Str[strlen(yylval.Str)-1] = '\0';
+    return(QUOTE);
+}
+
+{bareword}+ {
+    yylval.Str = dbmfStrdup(yytext);
+    return(WORD);
+}
+
+"="     { return(EQUALS);       }
+","     { return(COMMA);        }
+"{"     { return(O_BRACE);      }
+"}"     { return(C_BRACE);      }
+
+{comment}.*     ;
+{whitespace}    ;
+{newline}       { line_num++;   }
+
+. {
+    char message[40];
+
+    sprintf(message, "invalid character '%c'", yytext[0]);
+    yyerror(message);
+
+    /* Suppress compiler warning messages */
+    if (0) yyunput('c',NULL);
+    if (0) yy_switch_to_buffer(NULL);
+}
+
+%%

require-ess/src/expr.c

+#include <ctype.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "expr.h"
+
+int exprDebug;
+
+static int parseSubExpr(const char **pp, long *v, int pr, int op);
+static long parseString(const char **pp, const char **pstart);
+#define parseExpr(pp,v) parseSubExpr(pp, v, 0, 0)
+#define skipSpace(p) while (isspace((unsigned char)*p)) p++
+
+static int parseValue(const char **pp, long *v)
+{
+    long val;
+    const char *p = *pp;
+    char o;
+
+    /* A value is optionally prefixed with an unary operator + - ! ~.
+     * It is either a number (decimal, octal or hex)
+     * or an expression in ().
+     * Allowed chars after a number: operators, closing parenthesis, whitespace, quotes, end of string
+     */
+
+    /* first look for value */
+    skipSpace(p);
+    o = *p;
+    if (memchr("+-~!", o, 4))
+    {
+        /* unary operators */
+        p++;
+        if (!parseValue(&p, &val)) return 0; /* no valid value */
+        if (exprDebug) printf("parseValue: %c %ld\n", o, val);
+        if (o == '-') val=-val;
+        else if (o == '~') val=~val;
+        else if (o == '!') val=!val;
+    }
+    else if (o == '(')
+    {
+        /* sub-expression */
+        p++;
+        if (parseExpr(&p, &val) < 0) return 0; /* no valid expression */
+        skipSpace(p);
+        if (*p++ != ')') return 0; /* missing ) */
+    }
+    else if (o == '#')
+    {
+        /* string length operator */
+        p++;
+        if (exprDebug) printf("parseValue: string length of %s\n", p);
+        if (*p == '"' || *p == '\'')
+            val = parseString(&p, NULL);
+        else return 0;
+    }
+    else
+    {
+        /* number */
+        char *e;
+        val = strtol(p, &e, 0);
+        if (e == p) return 0; /* no number */
+
+        if (isalpha((unsigned char)*e)||*e=='.')
+        {
+            /* part of plain word or floating point number */
+            return 0;
+        }
+        p = e;
+    }
+    *pp = p;
+    *v = val;
+    return 1;
+}
+
+static long ipow(long base, long exp)
+{
+    long val;
+    if (exp == 2) return base*base;
+    if (exp == 3) return base*base*base;   
+    if (exp == 1) return base;
+    if (exp == 0) return 1;
+    if (exp < 0) return 0;
+    val = ipow(base,exp>>1);
+    val *= val;
+    if (exp&1) val *= base;
+    return val;
+}
+
+static char parseSep(const char **pp, const char *seps)
+{
+    const char *p = *pp;
+
+    skipSpace(p);
+    if (!*p || !strchr(seps, *p)) return 0;
+    *pp = p+1;
+    return *p;
+}
+
+struct {char str[4]; int pr;} ops[] = {
+    {":=",0},
+    {"**",14},
+    {"*", 13},{"/",13},{"%",13},
+    {"+",12},{"-",12},
+    {"<<",11},{">>>",11},{">>",11},
+    {"<?",10},{">?",10},
+    {"<=>",9},
+    {"<=",8},{">=",8},{"<",8},{">",8},
+    {"==",7},{"!=",7},
+    {"&&",3},{"||",2},
+    {"&",6},{"^",5},{"|",4},
+    {"?:",1},{"?",1}
+};
+
+enum op {
+    op_none,
+    op_pow, 
+    op_mul,op_div,op_mod,
+    op_plus,op_minus,
+    op_lshift,op_urshift,op_rshift,
+    op_min,op_max,
+    op_cmp,
+    op_lteq,op_gteq,op_lt,op_gt,
+    op_eq,op_neq,
+    op_logicand,op_logicor,
+    op_bitand,op_bitxor,op_bitor,
+    op_alt,op_if
+};
+
+static int startsWith(const char *p, const char *s)
+{
+    int i = 0;
+    while (*s) { i++; if (*p++ != *s++) return 0; }
+    return i;
+}
+
+static int parseOp(const char **pp)
+{
+    const char *p = *pp;
+    int o, l;
+
+    skipSpace(p);
+    if (ispunct((unsigned char)*p))
+    {
+        for (o = 1; o < (int)(sizeof(ops)/sizeof(ops[0])); o++)
+        {
+            if ((l = startsWith(p, ops[o].str)))
+            {
+                /* operator found */
+                *pp = p+l;
+                return o;
+            }
+        }
+    }
+    return 0;
+}
+
+static int parseSubExpr(const char **pp, long *v, int pr, int o)
+{
+    const char *p = *pp;
+    long val = o ? *v : 0;
+    long val2;
+    int o2 = o;
+
+    if (exprDebug) printf("parseExpr(%d): start %ld %s \"%s\"\n", pr, val, ops[o].str, p);
+    do {
+        if (!parseValue(&p, &val2))
+        {
+            if (exprDebug) printf("parseExpr(%d): no value after %ld %s\n", pr, val, ops[o].str);
+            return -1;
+        }
+nextop:
+        if ((o2 = parseOp(&p)))
+        {
+            if (exprDebug) printf("parseExpr(%d): %ld %s %ld %s \"%s\"\n", pr, val, ops[o].str, val2, ops[o2].str, p);
+            if (o && ops[o2].pr > ops[o].pr)
+            {
+                if ((o2 = parseSubExpr(&p, &val2, ops[o].pr, o2)) < 0)
+                {
+                    if (exprDebug) printf("parseExpr(%d): parse failed after %ld %s %ld\n", pr, val, ops[o].str, val2);
+                    return -1;
+                }
+            }
+        }
+        if (exprDebug) printf("parseExpr(%d): calc %ld %s %ld\n", pr, val, ops[o].str, val2);
+        switch (o)
+        {
+            case op_none:     val = val2; break;
+            case op_pow:      val = ipow(val, val2); break;
+            case op_mul:      val *= val2; break;
+            case op_div:      val /= val2; break;
+            case op_mod:      val %= val2; break;
+            case op_plus:     val += val2; break;
+            case op_minus:    val -= val2; break;
+            case op_lshift:   val <<= val2; break;
+            case op_urshift:  val = (unsigned long)val >> val2; break;
+            case op_rshift:   val >>= val2; break;
+            case op_min:      if (val2 < val) val = val2; break;
+            case op_max:      if (val2 > val) val = val2; break;
+            case op_cmp:      val = val < val2 ? -1 : val == val2 ? 0 : 1; break;
+            case op_lteq:     val = val <= val2; break;
+            case op_gteq:     val = val >= val2; break;
+            case op_lt:       val = val < val2; break;
+            case op_gt:       val = val > val2; break;
+            case op_eq:       val = val == val2; break;
+            case op_neq:      val = val != val2; break;
+            case op_logicand: val = val && val2; break;
+            case op_logicor:  val = val || val2; break;
+            case op_bitand:   val &= val2; break;
+            case op_bitxor:   val ^= val2; break;
+            case op_bitor:    val |= val2; break;
+            case op_alt:      if (!val) val = val2; break;
+        }
+        if (exprDebug) printf("parseExpr(%d): result %ld\n", pr, val);
+        if (o2 == op_if)
+        {
+            long val3 = 0;
+            val2 = 1;
+            if (exprDebug) printf("parseExpr(%d) if %ld\n", pr, val);
+            if ((o2 = parseExpr(&p, &val2)) >= 0)
+            {
+                if (exprDebug) printf("parseExpr(%d) then %ld\n", pr, val2);
+                if (parseSep(&p, ":"))
+                {
+                    parseExpr(&p, &val3);
+                    if (exprDebug) printf("parseExpr(%d) else %ld\n", pr, val3);
+                }
+            }
+            if (exprDebug) printf("parseExpr(%d) if %ld then %ld else %ld\n", pr, val, val2, val3);
+            val = val ? val2 : val3;
+            if (exprDebug) printf("parseExpr(%d): result %ld, o2=%d, rest \"%s\" \n", pr, val, o2, p);
+            if (o2 == -1) goto nextop;
+        }
+        o = o2;
+    } while (ops[o].pr && pr <= ops[o].pr);
+    if (exprDebug) printf("parseExpr(%d): value = %ld return %d %s\n", pr, val, o, ops[o].str);
+    *pp = p;
+    *v = val;
+    return o;
+}
+
+static const char *getFormat(const char **pp)
+{
+    static char format [20];
+    const char *p = *pp;
+    unsigned int i = 1;
+    if (exprDebug) printf("getFormat %s\n", p);
+    if ((format[0] = *p++) == '%')
+    {
+        while (i < sizeof(format) && memchr(" #-+0", *p, 5))
+            format[i++] = *p++;
+        while (i < sizeof(format) && *p >= '0' && *p <= '9')
+            format[i++] = *p++;
+        if (i < sizeof(format))
+            format[i++] = 'l';
+        if (i < sizeof(format) && memchr("diouxXc", *p, 7))
+        {
+            format[i++] = *p++;
+            format[i] = 0;
+            *pp = p;
+            if (exprDebug) printf("format = '%s'\n", format);
+            return format;
+        }
+    }
+    if (exprDebug) printf("no format\n");
+    return NULL;
+}
+
+static int parseSlice(const char **pp, long* pstart, long* plength)
+{
+    const char *p = *pp;
+    long slice_start = 0;
+    long slice_length = 0;
+    long string_length = *plength;
+    char o;
+
+    if (*p++ != '[') return 0;
+    parseExpr(&p, &slice_start);
+    if (slice_start < 0) slice_start += string_length;
+    if ((o = parseSep(&p, ":,"))) /* [start,length] or [start:end] */
+    {
+        parseExpr(&p, &slice_length);
+        if (o == ':')
+        {
+            if (slice_length < 0) slice_length += string_length;
+            slice_length -= slice_start;
+        }
+    }
+    else slice_length = 1;
+    if (slice_start < 0)
+    {
+        slice_length += slice_start;
+        slice_start = 0;
+    }
+    if (slice_start > string_length)
+        slice_length = 0;
+    if (slice_length > string_length - slice_start)
+        slice_length = string_length - slice_start;
+    if (slice_length < 0)
+        slice_length = 0;
+    skipSpace(p);
+    if (*p++ != ']') return 0;
+    *pstart += slice_start;
+    *plength = slice_length;
+    *pp = p;
+    return 1;
+}
+
+static long parseString(const char **pp, const char **pstart)
+{
+    const char *p = *pp;
+    const char *string_start = p;
+    long slice_start = 0;
+    long length = 0;
+    char q;
+
+    q = *p++;
+    while (*p) /* string length with escapes */
+    {
+        if (*p == '\\')
+            if (*++p == 0) break;
+        if (*p++ == q) break;
+        length++;
+    }
+    while (parseSlice(&p, &slice_start, &length));
+    if (exprDebug) printf("parseString %.*s[%ld,%ld]\n", (int)(p-string_start), string_start, slice_start, length);
+    if (length && pstart)
+    {
+        while (slice_start-- > 0)
+        {
+            if (*string_start++ == '\\') string_start++;
+        }
+        *pstart = ++string_start;
+    }
+    *pp = p;
+    return length;
+}
+
+static void writeString(char** pw, const char* r, long length, char q)
+{
+    char* w = *pw;
+    *w++ = q;
+    while (length-- > 0)
+    {
+        if (*r == '\\') *w++ = *r++;
+        *w++ = *r++;
+    }
+    *w++ = q;
+    *w++ = 0;
+    *pw = w;
+}
+
+size_t replaceExpressions(const char *r, char *buffer, size_t buffersize)
+{
+    long val, string_length;
+    char *w = buffer;
+    char *s;
+    const char *string_start = r;
+    char q;
+
+    *w = 0;
+    while (*r)
+    {
+        s = w;
+        if (*r == '"' || *r == '\'')
+        {
+            /* quoted strings */
+            q = *r;
+            string_length = parseString(&r, &string_start);
+            writeString(&w, string_start, string_length, q);
+            if (exprDebug) printf("quoted string %s\n", s);
+        }
+        else if (*r == '%')
+        {
+            /* formatted expression */
+            const char *r2 = r;
+            const char *f;
+            if (exprDebug) printf("formatted expression after '%s'\n", s);
+            if ((f = getFormat(&r2)) && parseExpr(&r2, &val) >= 0)
+            {
+                r = r2;
+                if (w > buffer && w[-1] == '(' && *r2++ == ')')
+                {
+                    w--;
+                    r = r2;
+                }
+                w += sprintf(w, f , val);
+                if (exprDebug) printf("formatted expression %s\n", s);
+            }
+        }
+        else if (parseExpr(&r, &val) >= 0)
+        {
+            /* unformatted expression */
+            if (r[-1] == '?' && (q = parseSep(&r, "\"'")))
+            {
+                /* handle expression ? "string1" : "string2" */
+                w = s;
+                r--;
+                string_length = parseString(&r, &string_start);
+                if (val) writeString(&w, string_start, string_length, q);
+                if (parseSep(&r, ":"))
+                {
+                    string_length = parseString(&r, &string_start);
+                    if (!val) writeString(&w, string_start, string_length, q);
+                }
+            }
+            else
+            {
+                w += sprintf(w, "%ld", val);
+            }
+            if (exprDebug) printf("expression %s\n", s);
+        }
+        else {
+            /* unquoted string (i.e plain word) */
+            do {
+                if ((*w++ = *r++) == '\\') if (*r) *w++ = *r++;
+            } while (*r && !strchr("%(\"', \t\n", *r));
+            *w = 0;
+            if (exprDebug) printf("plain word '%s'\n", s);
+        }
+        /* copy space */
+        while (isspace((unsigned char)*r) || *r == ',') *w++ = *r++;
+        /* terminate */
+        *w = 0;
+    }
+    return w - buffer;
+}

require-ess/src/expr.h

+#ifndef expr_h
+#define expr_h
+
+#ifdef __cplusplus
+extern {
+#endif
+
+extern int exprDebug;
+
+size_t replaceExpressions(const char* source, char* buffer, size_t buffersize);
+/* Resolve integer expressions that are either free standing
+ * or in parentheses () embedded in an unquoted word.
+ * Do not resolve expressions in single or double quoted strings.
+ * An expression optionally starts with a integer format such as %x.
+ * It consists of integer numbers, operators and parentheses ().
+ */
+
+#ifdef __cplusplus
+}
+#endif
+#endif

require-ess/src/require.dbd

+registrar(requireRegister)
+variable(requireDebug,int)

require-ess/src/require.h

+#ifndef require_h
+#define require_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef __GNUC__
+#define __attribute__(dummy)
+#endif
+
+int require(const char* libname, const char* version, const char* args);
+size_t foreachLoadedLib(size_t (*func)(const char* name, const char* version, const char* path, void* arg), void* arg);
+const char* getLibVersion(const char* libname);
+const char* getLibLocation(const char* libname);
+int libversionShow(const char* outfile);
+int runScript(const char* filename, const char* args);
+int putenvprintf(const char* format, ...) __attribute__((__format__(__printf__,1,2)));
+void pathAdd(const char* varname, const char* dirname);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

require-ess/src/runScript.c

+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <errno.h>
+#include <macLib.h>
+#include <dbAccess.h>
+#include <initHooks.h>
+#include <epicsVersion.h>
+
+#define EPICSVER EPICS_VERSION*10000+EPICS_REVISION*100+EPICS_MODIFICATION
+
+#if defined (_WIN32)
+#include "asprintf.h"
+#endif
+
+#include <osiFileName.h>
+#include <iocsh.h>
+epicsShareFunc int epicsShareAPI iocshCmd(const char *cmd);
+#include <epicsExport.h>
+
+#define IS_ABS_PATH(filename) (filename[0] == OSI_PATH_SEPARATOR[0])  /* may be different for other OS ? */
+
+#include "expr.h"
+#include "require.h"
+
+#define SAVEENV(var) do { old_##var = getenv(#var); if (old_##var) old_##var=strdup(old_##var); } while(0)
+#define RESTOREENV(var) do { if(old_##var) { putenvprintf("%s=%s", #var, old_##var); free(old_##var); }} while(0)
+
+int runScriptDebug=0;
+
+int runScript(const char* filename, const char* args)
+{
+    MAC_HANDLE *mac = NULL;
+    FILE* file = NULL;
+    char* line_raw = NULL;
+    char* line_exp = NULL;
+    long line_raw_size = 256;
+    long line_exp_size = line_raw_size;
+    long len;
+    char** pairs;
+    int status = 0;
+    char* old_MODULE = NULL;
+    char* old_MODULE_DIR = NULL;
+    
+    if (!filename)
+    {
+        fprintf(stderr, "Usage: runScript filename [macro=value,...]\n");
+        return -1;
+    }
+    
+    if (macCreateHandle(&mac,(const char*[]){ "", "environ", NULL, NULL }) != 0) goto error;
+    macSuppressWarning(mac, 1);
+
+    if ((line_exp = malloc(line_exp_size)) == NULL) goto error;
+    if ((line_raw = malloc(line_raw_size)) == NULL) goto error;
+
+    /* add args to macro definitions */
+    if (args)
+    {
+        if (runScriptDebug)
+            printf("runScript: macParseDefns \"%s\"\n", args);
+        macParseDefns(mac, (char*)args, &pairs);
+        macInstallMacros(mac, pairs);
+        free(pairs);
+    }
+
+    if (IS_ABS_PATH(filename))
+    {
+        file = fopen(filename, "r");
+    }
+    else
+    {
+        const char* dirname;
+        const char* end;
+        char* fullname;
+        const char* path = getenv("SCRIPT_PATH");
+        int dirlen;
+        
+        for (dirname = path; dirname != NULL; dirname = end)
+        {
+            end = strchr(dirname, OSI_PATH_LIST_SEPARATOR[0]);
+            if (end && end[1] == OSI_PATH_SEPARATOR[0] && end[2] == OSI_PATH_SEPARATOR[0])   /* "http://..." and friends */
+                end = strchr(end+2, OSI_PATH_LIST_SEPARATOR[0]);
+            if (end) dirlen = (int)(end++ - dirname);
+            else dirlen = (int)strlen(dirname);
+            if (dirlen == 0) continue; /* ignore empty path elements */
+            if (dirname[dirlen-1] == OSI_PATH_SEPARATOR[0]) dirlen--;
+            asprintf(&fullname, "%.*s" OSI_PATH_SEPARATOR "%s", 
+                dirlen, dirname, filename);
+            if (runScriptDebug)
+                printf("runScript: trying %s\n", fullname);
+            file = fopen(fullname, "r");
+            if (!file && (errno & 0xffff) != ENOENT) perror(fullname);
+            free(fullname);
+            if (file) break;
+        }
+    }
+    if (file == NULL) { perror(filename); return errno; }
+    
+    /* save some environments variables */
+    SAVEENV(MODULE);
+    SAVEENV(MODULE_DIR);
+
+    /* execute script line by line after expanding macros with arguments or environment */
+    while (fgets(line_raw, line_raw_size, file))
+    {
+        char* p, *x;
+
+        /* check if we have a line longer than the buffer size */
+        while (line_raw[(len = (long)strlen(line_raw))-1] != '\n' && !feof(file))
+        {
+            if (runScriptDebug)
+                    printf("runScript partial line: \"%s\"\n", line_raw);
+            if ((line_raw = realloc(line_raw, line_raw_size *= 2)) == NULL) goto error;
+            if (fgets(line_raw + len, line_raw_size - len, file) == NULL) break;
+        }
+        while (len > 0 && isspace((unsigned char)line_raw[len-1])) line_raw[--len] = 0; /* get rid of '\n' and friends */
+        if (runScriptDebug)
+                printf("runScript raw line (%ld chars): '%s'\n", len, line_raw);
+        /* expand and check the buffer size (different epics versions write different may number of bytes)*/
+        while ((len = labs(macExpandString(mac, line_raw, line_exp, line_exp_size-1))) >= line_exp_size-2)
+        {
+            if (runScriptDebug)
+                printf("runScript: grow expand buffer: len=%ld size=%ld\n", len, line_exp_size);
+            free(line_exp);
+            if ((line_exp = malloc(line_exp_size *= 2)) == NULL) goto error;
+        }
+        if (runScriptDebug)
+                printf("runScript expanded line (%ld chars): '%s'\n", len, line_exp);
+        printf("%s\n", line_exp);
+        p = line_exp;
+        while (isspace((unsigned char)*p)) p++;
+        if (*p == 0 || *p == '#') continue;
+        
+        /* find local variable assignments */
+        if ((x = strpbrk(p, "=(, \t\n\r")) != NULL && *x=='=')
+        {
+            *x++ = 0;
+            replaceExpressions(x, line_raw, line_raw_size);
+            if (runScriptDebug)
+                printf("runScript: assign %s=%s\n", p, line_raw);
+            macPutValue(mac, p, line_raw);
+            continue;
+        }
+        if (runScriptDebug)
+            printf("runScript: iocshCmd: '%s'\n", line_exp);
+        status = iocshCmd(line_exp);
+        if (status != 0) break;
+    }
+    goto end;
+error:
+    if (errno)
+    {
+        status = errno;
+        perror("runScript");
+    }
+end:
+    free(line_raw);
+    free(line_exp);
+    if (mac) macDeleteHandle(mac);
+    if (file) fclose(file);
+
+    /* restore environment */
+    RESTOREENV(MODULE);
+    RESTOREENV(MODULE_DIR);
+
+    return status;
+}
+
+struct cmditem
+{
+    struct cmditem* next;
+    int type;
+    union {
+        char* a[12];
+        char cmd[256];
+    } x;
+} *cmdlist, **cmdlast=&cmdlist;
+
+void afterInitHook(initHookState state)
+{
+    struct cmditem *item;
+
+    if (state != 
+#ifdef INCinitHooksh
+        /* old: without iocPause etc */
+        initHookAfterInterruptAccept
+#else
+        /* new: with iocPause etc */
+        initHookAfterIocRunning
+#endif
+        ) return;
+    for (item = cmdlist; item != NULL; item = item->next)
+    {
+        if (item->type == 1)
+        {
+            printf("%s\n", item->x.cmd);
+            iocshCmd(item->x.cmd);
+        }
+        else
+        ((void (*)())item->x.a[0])(item->x.a[1], item->x.a[2], item->x.a[3], item->x.a[4], item->x.a[5],
+            item->x.a[6], item->x.a[7], item->x.a[8], item->x.a[9], item->x.a[10], item->x.a[11]);
+    }
+}
+
+
+static int first_time = 1;
+
+static struct cmditem *newItem(char* cmd, int type)
+{
+    struct cmditem *item;
+    if (!cmd)
+    {
+        fprintf(stderr, "usage: afterInit command, args...\n");
+        return NULL;
+    }
+    if (interruptAccept)
+    {
+        fprintf(stderr, "afterInit can only be used before iocInit\n");
+        return NULL;
+    } 
+    if (first_time)
+    {
+        first_time = 0;
+        initHookRegister(afterInitHook);
+    }
+    item = malloc(sizeof(struct cmditem));
+    if (item == NULL)
+    {
+        perror("afterInit");
+        return NULL;
+    }
+    item->type = type;
+    item->next = NULL;
+    *cmdlast = item;
+    cmdlast = &item->next;
+    return item;
+}
+
+int afterInit(char* cmd, char* a1, char* a2, char* a3, char* a4, char* a5, char* a6, char* a7, char* a8, char* a9, char* a10, char* a11)
+{
+    struct cmditem *item = newItem(cmd, 0);
+    if (!item) return -1;
+    
+    item->x.a[0] = cmd;
+    item->x.a[1] = a1;
+    item->x.a[2] = a2;
+    item->x.a[3] = a3;
+    item->x.a[4] = a4;
+    item->x.a[5] = a5;
+    item->x.a[6] = a6;
+    item->x.a[7] = a7;
+    item->x.a[8] = a8;
+    item->x.a[9] = a9;
+    item->x.a[10] = a10;
+    item->x.a[11] = a11;
+
+    return 0;
+}
+
+epicsExportAddress(int, runScriptDebug);
+epicsExportAddress(int, exprDebug);
+
+static const iocshFuncDef runScriptDef = {
+    "runScript", 2, (const iocshArg *[]) {
+        &(iocshArg) { "filename", iocshArgString },
+        &(iocshArg) { "substitutions", iocshArgString },
+}};
+    
+static void runScriptFunc(const iocshArgBuf *args)
+{
+    runScript(args[0].sval, args[1].sval);
+}
+
+static const iocshFuncDef afterInitDef = {
+    "afterInit", 1, (const iocshArg *[]) {
+        &(iocshArg) { "commandline", iocshArgArgv },
+}};
+    
+static void afterInitFunc(const iocshArgBuf *args)
+{
+    int i, n;
+    struct cmditem *item = newItem(args[0].aval.av[1], 1);
+    if (!item) return;
+
+    n = sprintf(item->x.cmd, "%.255s", args[0].aval.av[1]);
+    for (i = 2; i < args[0].aval.ac; i++)
+    {
+        if (strpbrk(args[0].aval.av[i], " ,\"\\"))
+            n += sprintf(item->x.cmd+n, " '%.*s'", 255-3-n, args[0].aval.av[i]);
+        else
+            n += sprintf(item->x.cmd+n, " %.*s", 255-1-n, args[0].aval.av[i]);
+    }
+}
+
+static void runScriptRegister(void)
+{
+    static int firstTime = 1;
+    if (firstTime) {
+        firstTime = 0;
+        iocshRegister (&runScriptDef, runScriptFunc);
+        iocshRegister (&afterInitDef, afterInitFunc);
+    }
+}
+epicsExportRegistrar(runScriptRegister);

require-ess/src/runScript.dbd

+registrar(runScriptRegister)
+variable(runScriptDebug,int)
+variable(exprDebug,int)

require-ess/src/strdup.c

+#include <string.h>
+#include <stdlib.h>
+
+char *strdup(const char *s)
+{
+    char *d = malloc(strlen(s)+1);
+    if (d) strcpy(d,s);
+    return d;
+}
+
+char *strndup(const char *s, size_t n)
+{
+    size_t l;
+    char *d;
+    
+    l = strlen(s);
+    if (n > l) n = l;
+    d = malloc(n+1);
+    strncpy(d,s,l);
+    d[n] = 0;
+    return d;
+}

require-ess/src/strdup.h

+#ifndef strdup_h
+#define strdup_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+char *strdup(const char *s);
+char *strndup(const char *s, size_t n);
+#ifdef __cplusplus
+}
+#endif
+#endif

require-ess/src/version.c

+#include <regex.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "version.h"
+
+void cleanup_semver(semver_t *s)
+{
+    free(s->version_str);
+    free(s);
+}
+
+static void init_semver(const char *version, semver_t *s)
+{
+    s->version_str = calloc(strlen(version) + 1, sizeof(char));
+    strcpy(s->version_str, version);
+    s->test_str = "";
+
+    s->major = 0;
+    s->minor = 0;
+    s->patch = 0;
+    s->build = -1;
+}
+
+static void fetch_part(char *version_str, const regmatch_t *groups, unsigned int ix, int *part)
+{
+    char tmp;
+
+    tmp = version_str[groups[ix].rm_eo];
+    version_str[groups[ix].rm_eo] = 0;
+    *part = atoi(version_str + groups[ix].rm_so);
+    version_str[groups[ix].rm_eo] = tmp;
+}
+
+int parse_semver(const char *version, semver_t *s)
+{
+    static const char* version_regex = "^(([0-9]+)\\.([0-9]+)\\.([0-9]+)(\\+([0-9]+))?)?(.*)$";
+    static const unsigned int max_regex_groups = 7 + 1;
+    static const unsigned int major_ix = 2;
+    static const unsigned int minor_ix = 3;
+    static const unsigned int patch_ix = 4;
+    static const unsigned int build_ix = 6;
+    static const unsigned int test_ix = 7;
+
+    regex_t compiled;
+    regmatch_t groups[max_regex_groups];
+
+    init_semver(version, s);
+
+    if (s->version_str == NULL || s->version_str[0] == 0)
+    {
+        return 1;
+    }
+
+    if (regcomp(&compiled, version_regex, REG_EXTENDED))
+    {
+        return 1;
+    }
+
+    if (regexec(&compiled, s->version_str, max_regex_groups, groups, 0) == 0)
+    {
+        fetch_part(s->version_str, groups, major_ix, &s->major);
+        fetch_part(s->version_str, groups, minor_ix, &s->minor);
+        fetch_part(s->version_str, groups, patch_ix, &s->patch);
+        if (groups[build_ix].rm_so != (regoff_t)-1)
+        {
+            fetch_part(s->version_str, groups, build_ix, &s->build);
+        }
+        s->test_str = s->version_str + groups[test_ix].rm_so;
+    }
+    return 0;
+}