Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • e3/wrappers/e3-require
  • waynelewis/e3-require
  • krisztianloki/e3-require
  • timokorhonen/e3-require
  • juntongliu/e3-require
  • roryclarke/e3-require
  • alfiorizzo/e3-require
  • lucasmagalhaes/e3-require
  • lucas-module-testgroup/e3-require
  • grzegorzkowalski/e3-require
  • anderslindh1/e3-require
11 results
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 745 additions and 2830 deletions
require-ess/src/dbLoadTemplate.dbd deleted 100644 → 0
View file @ 73bbc073
registrar(dbLoadTemplateRegister)
require-ess/src/dbLoadTemplate.h deleted 100644 → 0
View file @ 73bbc073
/*************************************************************************\
* 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 deleted 100644 → 0
View file @ 73bbc073
%{
/*************************************************************************\
* 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
#include "iocsh.h"
#include "epicsExport.h"
#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;
}
#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);
require-ess/src/dbLoadTemplate_lex.l deleted 100644 → 0
View file @ 73bbc073
/*************************************************************************\
* 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 deleted 100644 → 0
View file @ 73bbc073
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.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 deleted 100644 → 0
View file @ 73bbc073
#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/module.c 0 → 100644
View file @ 4560be22
#include "module.h"
#include <dbAccess.h>
#include <errlog.h>
#ifdef __MACH__
#include <mach/error.h>
#else
#include <error.h>
#endif
#include <limits.h>
#include <osiFileName.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "common.h"
#define MAX_MODULE_SIZE 256
unsigned long int bufferSize = 0;
const char *getLibVersion(struct linkedList *linkedlist, const char *libname) {
struct module *m = NULL;
for (m = linkedlist->head; m; m = m->next) {
if (strcmp(m->name, libname) == 0) {
return m->version;
}
}
return NULL;
}
const char *getLibLocation(struct linkedList *linkedlist, const char *libname) {
struct module *m = NULL;
for (m = linkedlist->head; m; m = m->next) {
if (strcmp(m->name, libname) == 0) {
return m->path;
}
}
return NULL;
}
int isModuleLoaded(struct linkedList *linkedlist, const char *libname) {
struct module *m = NULL;
for (m = linkedlist->head; m; m = m->next) {
if (strcmp(m->name, libname) == 0) return TRUE;
}
return FALSE;
}
int registerModule(struct linkedList *linkedlist, const char *moduleName,
const char *version, const char *location) {
char *absLocation = NULL;
char *absLocationRequire = NULL;
char *argstring = NULL;
const char *mylocation = NULL;
/* require should be called only before iocInit. */
if (interruptAccept) return 0;
debug("require: registerModule(%s,%s,%s)\n", moduleName, version, location);
if (!moduleName) return -1;
if (!version) version = "";
if (location) {
absLocation = realpathSeparator(location);
}
struct module *module = NULL;
if (!(module = (struct module *)calloc(sizeof(struct module), 1))) {
goto out_of_memory;
}
/* Check if string is well formated, there is a \0 in the next MAX_MODULE_SIZE
bytes. */
int nameSize = strnlen(moduleName, MAX_MODULE_SIZE) + 1;
if (nameSize > MAX_MODULE_SIZE) return -1;
if (!(module->name = calloc(nameSize, sizeof(char)))) {
goto out_of_memory;
}
strcpy(module->name, moduleName);
int versionSize = strnlen(version, MAX_MODULE_SIZE) + 1;
if (versionSize > MAX_MODULE_SIZE) return -1;
if (!(module->version = calloc(versionSize, sizeof(char)))) {
goto out_of_memory;
}
strcpy(module->version, version);
if (!(module->path =
calloc(strnlen(absLocation, PATH_MAX) + 1, sizeof(char)))) {
goto out_of_memory;
}
strcpy(module->path, absLocation ? absLocation : "");
free(absLocation);
/* This bufferSize is used to calculate the ModuleVersions buffer size. It
* will be updated every time we call dbLoadRecords at the end of this
* function. The size here will be calculated based on the string that is
* being written in fillModuleListRecord. So the magic number here is related
* to that string format.*/
bufferSize += nameSize + versionSize + 2;
if (linkedlist->size == 0) {
linkedlist->head = module;
} else {
linkedlist->tail->next = module;
}
linkedlist->tail = module;
linkedlist->size++;
putenvprintf("MODULE=%s", module->name);
putenvprintf("%s_VERSION=%s", module->name, module->version);
if (location) {
putenvprintf("%s_DIR=%s", module->name, module->path);
pathAdd("SCRIPT_PATH", module->path);
}
/* create a record with the version string */
mylocation = getenv("require_DIR");
if (mylocation == NULL) return 0;
if (asprintf(&absLocationRequire,
"%s" OSI_PATH_SEPARATOR "db" OSI_PATH_SEPARATOR
"moduleversion.template",
mylocation) < 0)
return 0;
/*
Require DB has the following four PVs:
- $(REQUIRE_IOC):$(MODULE)Version
- $(REQUIRE_IOC):ModuleVersions
- $(REQUIRE_IOC):Versions
- $(REQUIRE_IOC):Modules
We reserved 30 chars for :$(MODULE)Version, so MODULE has the maximum 24
chars. And we've reserved for 30 chars for $(REQUIRE_IOC). So, the whole PV
and record name in moduleversion.template has 59 + 1.
*/
if (asprintf(&argstring,
"REQUIRE_IOC=%.30s, MODULE=%.24s, VERSION=%.39s, "
"MODULE_COUNT=%u, BUFFER_SIZE=%lu",
getenv("REQUIRE_IOC"), module->name, module->version,
linkedlist->size, bufferSize) < 0) {
errlogPrintf("Error asprintf failed\n");
return 0;
}
printf("Loading module info records for %s\n", module->name);
dbLoadRecords(absLocationRequire, argstring);
free(argstring);
free(absLocationRequire);
return 0;
out_of_memory:
errlogPrintf("require: out of memory\n");
return -1;
}
require-ess/src/module.h 0 → 100644
View file @ 4560be22
#ifndef __MODULE_H__
#define __MODULE_H__
struct module {
struct module *next;
char *name;
char *version;
char *path;
};
struct linkedList {
struct module *head;
struct module *tail;
unsigned int size;
};
const char *getLibVersion(struct linkedList *linkedlist, const char *libname);
const char *getLibLocation(struct linkedList *linkedlist, const char *libname);
int isModuleLoaded(struct linkedList *linkedlist, const char *libname);
int registerModule(struct linkedList *linkedlist, const char *module,
const char *version, const char *location);
#endif /*__MODULE_H__*/
require-ess/src/require.c
View file @ 4560be22
/*
* ld - load code dynamically
*
* $Author: zimoch $
* $ID$
* $Date: 2015/06/29 09:47:30 $
*
* DISCLAIMER: Use at your own risc and so on. No warranty, no refund.
*/
/* Copyright (C) 2020 Dirk Zimoch */
/* Copyright (C) 2020-2022 European Spallation Source, ERIC */
#ifdef __unix
/* for vasprintf and dl_iterate_phdr */
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#endif
#endif // _GNU_SOURCE
#endif // __unix
/* for 64 bit (NFS) file systems */
#define _FILE_OFFSET_BITS 64
#include "require.h"
#include <ctype.h>
#include <dbAccess.h>
#include <epicsExit.h>
#include <epicsExport.h>
#include <epicsStdio.h>
#include <epicsVersion.h>
#include <errlog.h>
#include <errno.h>
#include <initHooks.h>
#include <iocsh.h>
#include <osiFileName.h>
#include <recSup.h>
#include <stdio.h>
......@@ -29,50 +30,43 @@
#include <string.h>
#include <sys/stat.h>
#include <dbAccess.h>
#include <iocsh.h>
/* This prototype is missing in older EPICS versions */
epicsShareFunc int epicsShareAPI iocshCmd(const char *cmd);
#include <epicsExit.h>
#include <epicsExport.h>
#include <epicsStdio.h>
#include <osiFileName.h>
#include "require.h"
#include "common.h"
#include "module.h"
#include "version.h"
int requireDebug;
#if defined(__unix)
#if defined(__unix) || defined(UNIX)
#ifndef OS_CLASS
#ifdef __linux
#if defined(__linux) || defined(linux)
#define OS_CLASS "Linux"
#endif
#endif // __linux
#ifdef SOLARIS
#define OS_CLASS "solaris"
#endif
#endif // SOLARIS
#ifdef __rtems__
#define OS_CLASS "RTEMS"
#endif
#ifdef CYGWIN32
#define OS_CLASS "cygwin32"
#endif
#endif // __rtems__
#ifdef freebsd
#define OS_CLASS "freebsd"
#endif
#endif // freebsd
#ifdef darwin
#ifdef __MACH__
#define OS_CLASS "Darwin"
#endif
#define PATH_MAX 1024
#endif // darwin
#ifdef _AIX32
#define OS_CLASS "AIX"
#endif
#endif // _AIX32
#endif // OS_CLASS
#else
#error Only support Unix based distros
#endif
#include <dlfcn.h>
......@@ -80,121 +74,41 @@ int requireDebug;
#define getAddress(module, name) dlsym(module, name)
#ifdef CYGWIN32
#define PREFIX
#define INFIX
#define EXT ".dll"
#else
#define PREFIX "lib"
#define INFIX
#define EXT ".so"
#endif
#elif defined(_WIN32)
#ifndef OS_CLASS
#define OS_CLASS "WIN32"
#endif
#include <Psapi.h>
#include <windows.h>
#pragma comment(lib, "kernel32.lib")
#pragma comment(lib, "psapi.lib")
#include "asprintf.h"
#define snprintf _snprintf
#define setenv(name, value, overwrite) _putenv_s(name, value)
#define PATH_MAX MAX_PATH
#define PREFIX
#define INFIX
#define EXT ".dll"
#define getAddress(module, name) GetProcAddress(module, name)
static char *realpath(const char *path, char *buffer) {
int len = MAX_PATH;
if (buffer == NULL) {
len = GetFullPathName(path, 0, NULL, NULL);
if (len == 0)
return NULL;
buffer = malloc(len);
if (buffer == NULL)
return NULL;
}
GetFullPathName(path, len, buffer, NULL);
return buffer;
}
#ifdef __MACH__
#define EXT ".dylib"
#else
#warning unknown OS
#define PREFIX
#define INFIX
#define EXT
#define getAddress(module, name) NULL
#define EXT ".so"
#endif
/* for readdir: Windows or Posix */
#if defined(_WIN32)
#define DIR_HANDLE HANDLE
#define DIR_ENTRY WIN32_FIND_DATA
#define IF_OPEN_DIR(f) \
if (snprintf(f + modulediroffs, sizeof(f) - modulediroffs, "\\*.*"), \
(dir = FindFirstFile(filename, &direntry)) != INVALID_HANDLE_VALUE || \
(FindClose(dir), 0))
#define START_DIR_LOOP do
#define END_DIR_LOOP \
while (FindNextFile(dir, &direntry)) \
; \
FindClose(dir);
#define SKIP_NON_DIR(e) \
if (!(e.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) || \
(e.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)) \
continue;
#define FILENAME(e) e.cFileName
#else
#include <dirent.h>
#define DIR_HANDLE DIR *
#define IF_OPEN_DIR(f) if ((dir = opendir(f)))
#define DIR_ENTRY struct dirent *
#define START_DIR_LOOP while ((errno = 0, direntry = readdir(dir)) != NULL)
#define END_DIR_LOOP \
if (!direntry && errno) \
fprintf(stderr, "error reading directory %s: %s\n", filename, \
strerror(errno)); \
if (dir) \
closedir(dir);
#define END_DIR_LOOP \
if (!direntry && errno) \
errlogPrintf("error reading directory %s: %s\n", filename, \
strerror(errno)); \
if (dir) closedir(dir);
#ifdef _DIRENT_HAVE_D_TYPE
#define SKIP_NON_DIR(e) \
if (e->d_type != DT_DIR && e->d_type != DT_UNKNOWN) \
continue;
#else
#define SKIP_NON_DIR(e) \
if (e->d_type != DT_DIR && e->d_type != DT_UNKNOWN) continue;
#else // _DIRENT_HAVE_D_TYPE
#define SKIP_NON_DIR(e)
#endif
#endif // _DIRENT_HAVE_D_TYPE
#define FILENAME(e) e->d_name
#endif
#define LIBDIR "lib" OSI_PATH_SEPARATOR
#define TEMPLATEDIR "db"
#define LIBRELEASE "LibRelease"
/*
#define TOSTR(s) TOSTR2(s)
#define TOSTR2(s) #s
const char epicsRelease[] =
TOSTR(EPICS_VERSION)"."TOSTR(EPICS_REVISION)"."TOSTR(EPICS_MODIFICATION);
#ifndef T_A
#error T_A not defined: Compile with USR_CFLAGS += -DT_A='"${T_A}"'
#endif
const char targetArch[] = T_A;
*/
#define E3_REQUIRE_LOCATION "E3_REQUIRE_LOCATION"
#define E3_REQUIRE_VERSION "E3_REQUIRE_VERSION"
#ifndef OS_CLASS
#error OS_CLASS not defined: Try to compile with USR_CFLAGS += -DOS_CLASS='"${OS_CLASS}"'
#endif
#endif // OS_CLASS
const char osClass[] = OS_CLASS;
......@@ -213,158 +127,38 @@ void set_require_env() {
sprintf(epicsRelease, "%s.%s.%s", epics_version_major, epics_version_middle,
epics_version_minor);
targetArch = getenv("EPICS_HOST_ARCH");
return;
putenvprintf("T_A=%s", targetArch);
putenvprintf("EPICS_HOST_ARCH=%s", targetArch);
putenvprintf("EPICS_RELEASE=%s", epicsRelease);
putenvprintf("OS_CLASS=%s", osClass);
}
static HMODULE loadlib(const char *libname) {
HMODULE libhandle = NULL;
if (libname == NULL) {
fprintf(stderr, "missing library name\n");
errlogPrintf("missing library name\n");
return NULL;
}
#if defined(__unix)
if ((libhandle = dlopen(libname, RTLD_NOW | RTLD_GLOBAL)) == NULL) {
fprintf(stderr, "Loading %s library failed: %s\n", libname, dlerror());
}
#elif defined(_WIN32)
if ((libhandle = LoadLibrary(libname)) == NULL) {
LPVOID lpMsgBuf;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpMsgBuf,
0, NULL);
fprintf(stderr, "Loading %s library failed: %s\n", libname, lpMsgBuf);
LocalFree(lpMsgBuf);
errlogPrintf("Loading %s library failed: %s\n", libname, dlerror());
}
#else
fprintf(stderr, "cannot load libraries on this OS.\n");
#endif
return libhandle;
}
typedef struct moduleitem {
struct moduleitem *next;
char content[0];
} moduleitem;
static moduleitem *loadedModules = NULL;
static unsigned long moduleCount = 0;
static unsigned long moduleListBufferSize = 1;
static unsigned long maxModuleNameLength = 0;
int putenvprintf(const char *format, ...) {
va_list ap;
char *var;
char *val;
int status = 0;
if (!format)
return -1;
va_start(ap, format);
if (vasprintf(&var, format, ap) < 0) {
perror("require putenvprintf");
return errno;
}
va_end(ap);
if (requireDebug)
printf("require: putenv(\"%s\")\n", var);
val = strchr(var, '=');
if (!val) {
fprintf(stderr, "putenvprintf: string contains no =: %s\n", var);
status = -1;
} else {
*val++ = 0;
if (setenv(var, val, 1) != 0) {
perror("require putenvprintf: setenv failed");
status = errno;
}
}
free(var);
return status;
}
void pathAdd(const char *varname, const char *dirname) {
char *old_path;
if (!varname || !dirname) {
fprintf(stderr, "usage: pathAdd \"ENVIRONMENT_VARIABLE\",\"directory\"\n");
fprintf(stderr, " Adds or moves the directory to the front of the "
"ENVIRONMENT_VARIABLE\n");
fprintf(stderr, " but after a leading \".\".\n");
return;
}
/* add directory to front */
old_path = getenv(varname);
if (old_path == NULL)
putenvprintf("%s=." OSI_PATH_LIST_SEPARATOR "%s", varname, dirname);
else {
size_t len = strlen(dirname);
char *p;
/* skip over "." at the beginning */
if (old_path[0] == '.' && old_path[1] == OSI_PATH_LIST_SEPARATOR[0])
old_path += 2;
/* If directory is already in path, move it to front */
p = old_path;
while ((p = strstr(p, dirname)) != NULL) {
if ((p == old_path || *(p - 1) == OSI_PATH_LIST_SEPARATOR[0]) &&
(p[len] == 0 || p[len] == OSI_PATH_LIST_SEPARATOR[0])) {
if (p == old_path)
break; /* already at front, nothing to do */
memmove(old_path + len + 1, old_path, p - old_path - 1);
strcpy(old_path, dirname);
old_path[len] = OSI_PATH_LIST_SEPARATOR[0];
if (requireDebug)
printf("require: modified %s=%s\n", varname, old_path);
break;
}
p += len;
}
if (p == NULL)
/* add new directory to the front (after "." )*/
putenvprintf("%s=." OSI_PATH_LIST_SEPARATOR "%s" OSI_PATH_LIST_SEPARATOR
"%s",
varname, dirname, old_path);
}
}
char *realpathSeparator(const char *location) {
size_t ll;
char *buffer = malloc(PATH_MAX + strlen(OSI_PATH_SEPARATOR));
buffer = realpath(location, buffer);
if (!buffer) {
if (requireDebug)
printf("require: realpath(%s) failed\n", location);
return NULL;
}
ll = strlen(buffer);
/* linux realpath removes trailing slash */
if (buffer[ll - strlen(OSI_PATH_SEPARATOR)] != OSI_PATH_SEPARATOR[0]) {
strcpy(buffer + ll + 1 - strlen(OSI_PATH_SEPARATOR), OSI_PATH_SEPARATOR);
}
return buffer;
}
int isModuleLoaded(const char *libname);
struct linkedList loadedModules = {0};
static int setupDbPath(const char *module, const char *dbdir) {
char *absdir =
realpathSeparator(dbdir); /* so we can change directory later safely */
if (absdir == NULL) {
if (requireDebug)
printf("require: cannot resolve %s\n", dbdir);
debug("require: cannot resolve %s\n", dbdir);
return -1;
}
if (requireDebug)
printf("require: found template directory %s\n", absdir);
debug("require: found template directory %s\n", absdir);
/* set up db search path environment variables
<module>_DB template path of <module>
......@@ -375,7 +169,7 @@ static int setupDbPath(const char *module, const char *dbdir) {
putenvprintf("%s_DB=%s", module, absdir);
putenvprintf("TEMPLATES=%s", absdir);
if (isModuleLoaded("stream")) {
if (isModuleLoaded(&loadedModules, "stream")) {
pathAdd("STREAM_PROTOCOL_PATH", absdir);
}
pathAdd("EPICS_DB_INCLUDE_PATH", absdir);
......@@ -383,50 +177,31 @@ static int setupDbPath(const char *module, const char *dbdir) {
return 0;
}
static int getRecordHandle(const char *namepart, short type, long minsize,
DBADDR *paddr) {
/*
#define PVNAME_STRINGSZ 61
defined in EPICS_BASE/include/dbDefs.h
*/
char recordname[PVNAME_STRINGSZ] = "";
long dummy = 0L;
long offset = 0L;
static int getRecordHandle(const char *namepart, short type, DBADDR *paddr) {
char recordname[PVNAME_STRINGSZ] = {0};
sprintf(recordname, "%.*s%s", (int)(PVNAME_STRINGSZ - strlen(namepart) - 1),
sprintf(recordname, "%.*s%s",
(int)(PVNAME_STRINGSZ - strnlen(namepart, PVNAME_STRINGSZ - 1) - 1),
getenv("REQUIRE_IOC"), namepart);
if (dbNameToAddr(recordname, paddr) != 0) {
fprintf(stderr, "require:getRecordHandle : record %s not found\n",
recordname);
errlogPrintf("require:getRecordHandle : record %s not found\n", recordname);
return -1;
}
if (paddr->field_type != type) {
fprintf(
stderr,
errlogPrintf(
"require:getRecordHandle : record %s has wrong type %s instead of %s\n",
recordname, pamapdbfType[paddr->field_type].strvalue,
pamapdbfType[type].strvalue);
return -1;
}
if (paddr->no_elements < minsize) {
fprintf(stderr,
"require:getRecordHandle : record %s has not enough elements: %lu "
"instead of %lu\n",
recordname, paddr->no_elements, minsize);
return -1;
}
if (paddr->pfield == NULL) {
fprintf(
stderr,
errlogPrintf(
"require:getRecordHandle : record %s has not yet allocated memory\n",
recordname);
return -1;
}
/* update array information */
dbGetRset(paddr)->get_array_info(paddr, &dummy, &offset);
return 0;
}
......@@ -435,351 +210,100 @@ We can fill the records only after they have been initialized, at
initHookAfterFinishDevSup. But use double indirection here because in 3.13 we
must wait until initHooks is loaded before we can register the hook.
*/
static void fillModuleListRecord(initHookState state) {
if (state == initHookAfterFinishDevSup) /* MODULES record exists and has
allocated memory */
{
DBADDR modules, versions, modver;
int have_modules, have_versions, have_modver;
moduleitem *m;
int i = 0;
long c = 0;
if (requireDebug)
printf("require: fillModuleListRecord\n");
have_modules =
(getRecordHandle(":MODULES", DBF_STRING, moduleCount, &modules) == 0);
have_versions =
(getRecordHandle(":VERSIONS", DBF_STRING, moduleCount, &versions) == 0);
moduleListBufferSize += moduleCount * maxModuleNameLength;
have_modver = (getRecordHandle(":MOD_VER", DBF_CHAR, moduleListBufferSize,
&modver) == 0);
for (m = loadedModules, i = 0; m; m = m->next, i++) {
size_t lm = strlen(m->content) + 1;
if (have_modules) {
if (requireDebug)
printf("require: %s[%d] = \"%.*s\"\n", modules.precord->name, i,
MAX_STRING_SIZE - 1, m->content);
sprintf((char *)(modules.pfield) + i * MAX_STRING_SIZE, "%.*s",
MAX_STRING_SIZE - 1, m->content);
}
if (have_versions) {
if (requireDebug)
printf("require: %s[%d] = \"%.*s\"\n", versions.precord->name, i,
MAX_STRING_SIZE - 1, m->content + lm);
sprintf((char *)(versions.pfield) + i * MAX_STRING_SIZE, "%.*s",
MAX_STRING_SIZE - 1, m->content + lm);
}
if (have_modver) {
if (requireDebug)
printf("require: %s+=\"%-*s%s\"\n", modver.precord->name,
(int)maxModuleNameLength, m->content, m->content + lm);
c += sprintf((char *)(modver.pfield) + c, "%-*s%s\n",
(int)maxModuleNameLength, m->content, m->content + lm);
}
}
if (have_modules)
dbGetRset(&modules)->put_array_info(&modules, i);
if (have_versions)
dbGetRset(&versions)->put_array_info(&versions, i);
if (have_modver)
dbGetRset(&modver)->put_array_info(&modver, c + 1);
}
if (state != initHookAfterFinishDevSup) return;
struct dbAddr modules = {0}, versions = {0}, modver = {0};
char *bufferModules, *bufferVersions, *bufferModver;
struct module *m = NULL;
int i = 0;
int c = 0;
getRecordHandle(":Modules", DBF_STRING, &modules);
getRecordHandle(":Versions", DBF_STRING, &versions);
getRecordHandle(":ModuleVersions", DBF_CHAR, &modver);
bufferModules =
(char *)calloc(MAX_STRING_SIZE * loadedModules.size, sizeof(char));
bufferVersions =
(char *)calloc(MAX_STRING_SIZE * loadedModules.size, sizeof(char));
bufferModver =
(char *)calloc(MAX_STRING_SIZE * loadedModules.size, sizeof(char));
for (m = loadedModules.head, i = 0; m != NULL; m = m->next, i++) {
debug("require: %s[%d] = \"%.*s\"\n", modules.precord->name, i,
MAX_STRING_SIZE - 1, m->name);
sprintf((char *)(bufferModules) + i * MAX_STRING_SIZE, "%.*s",
MAX_STRING_SIZE - 1, m->name);
debug("require: %s[%d] = \"%.*s\"\n", versions.precord->name, i,
MAX_STRING_SIZE - 1, m->version);
sprintf((char *)(bufferVersions) + i * MAX_STRING_SIZE, "%.*s",
MAX_STRING_SIZE - 1, m->version);
debug("require: %s+=\"%s %s\"\n", modver.precord->name, m->name,
m->version);
c += sprintf((char *)(bufferModver) + c, "%s %s\n", m->name, m->version);
}
if (dbPut(&modules, DBF_STRING, bufferModules, loadedModules.size) != 0) {
errlogPrintf("require: Error to put Modules\n");
}
if (dbPut(&versions, DBF_STRING, bufferVersions, loadedModules.size) != 0) {
errlogPrintf("require: Error to put Versions\n");
}
if (dbPut(&modver, DBF_CHAR, bufferModver, strlen(bufferModver)) != 0) {
errlogPrintf("require: Error to put ModuleVersions\n");
}
free(bufferModules);
free(bufferVersions);
free(bufferModver);
}
void registerModule(const char *module, const char *version,
const char *location) {
moduleitem *m, **pm;
size_t lm = strlen(module) + 1;
size_t lv = (version ? strlen(version) : 0) + 1;
size_t ll = 1;
char *absLocation = NULL;
char *absLocationRequire = NULL;
char *argstring = NULL;
const char *mylocation;
static int firstTime = 1;
if (requireDebug)
printf("require: registerModule(%s,%s,%s)\n", module, version, location);
if (firstTime) {
initHookRegister(fillModuleListRecord);
if (requireDebug)
printf("require: initHookRegister\n");
firstTime = 0;
}
if (!version)
version = "";
if (location) {
absLocation = realpathSeparator(location);
ll = strlen(absLocation) + 1;
}
m = (moduleitem *)malloc(sizeof(moduleitem) + lm + lv + ll);
if (m == NULL) {
fprintf(stderr, "require: out of memory\n");
return;
}
m->next = NULL;
strcpy(m->content, module);
strcpy(m->content + lm, version);
strcpy(m->content + lm + lv, absLocation ? absLocation : "");
free(absLocation);
for (pm = &loadedModules; *pm != NULL; pm = &(*pm)->next)
;
*pm = m;
if (lm > maxModuleNameLength)
maxModuleNameLength = lm;
moduleListBufferSize += lv;
moduleCount++;
putenvprintf("MODULE=%s", module);
putenvprintf("%s_VERSION=%s", module, version);
if (location) {
putenvprintf("%s_DIR=%s", module, m->content + lm + lv);
pathAdd("SCRIPT_PATH", m->content + lm + lv);
}
/* only do registration register stuff at init */
if (interruptAccept)
return;
/* create a record with the version string */
mylocation = getenv("require_DIR");
if (mylocation == NULL)
return;
if (asprintf(&absLocationRequire,
"%s" OSI_PATH_SEPARATOR "db" OSI_PATH_SEPARATOR
"moduleversion.template",
mylocation) < 0)
return;
/*
Require DB has the following four PVs:
- $(REQUIRE_IOC):$(MODULE)_VER
- $(REQUIRE_IOC):MOD_VER
- $(REQUIRE_IOC):VERSIONS
- $(REQUIRE_IOC):MODULES
We reserved 30 chars for :$(MODULE)_VER, so MODULE has the maximum 24
chars. And we've reserved for 30 chars for $(REQUIRE_IOC). So, the whole PV
and record name in moduleversion.template has 59 + 1.
*/
if (asprintf(&argstring,
"REQUIRE_IOC=%.30s, MODULE=%.24s, VERSION=%.39s, "
"MODULE_COUNT=%lu, BUFFER_SIZE=%lu",
getenv("REQUIRE_IOC"), module, version, moduleCount,
moduleListBufferSize + maxModuleNameLength * moduleCount) < 0)
return;
printf("Loading module info records for %s\n", module);
dbLoadRecords(absLocationRequire, argstring);
free(argstring);
free(absLocationRequire);
}
#if defined(__linux)
/* This is the Linux link.h, not the EPICS link.h ! */
#include <link.h>
static int findLibRelease(struct dl_phdr_info *info, /* shared library info */
size_t size, /* size of info structure */
void *data /* user-supplied arg */
) {
void *handle;
char *location = NULL;
char *p;
char *version;
char *symname;
char name[PATH_MAX + 11]; /* get space for library path + "LibRelease" */
(void)data; /* unused */
if (size < sizeof(struct dl_phdr_info))
return 0; /* wrong version of struct dl_phdr_info */
/* find a symbol with a name like "_<module>LibRelease"
where <module> is from the library name "<location>/lib<module>.so" */
if (info->dlpi_name == NULL || info->dlpi_name[0] == 0)
return 0; /* no library name */
strcpy(name, info->dlpi_name); /* get a modifiable copy of the library name */
handle =
dlopen(info->dlpi_name, RTLD_LAZY); /* re-open already loaded library */
p = strrchr(name,
'/'); /* find file name part in "<location>/lib<module>.so" */
if (p) {
location = name;
*++p = 0;
} else
p = name; /* terminate "<location>/" (if exists) */
*(symname = p + 2) = '_'; /* replace "lib" with "_" */
p = strchr(symname, '.'); /* find ".so" extension */
if (p == NULL)
p = symname + strlen(symname); /* no file extension ? */
strcpy(p, "LibRelease"); /* append "LibRelease" to module name */
version = dlsym(handle, symname); /* find symbol "_<module>LibRelease" */
if (version) {
*p = 0;
symname++; /* get "<module>" from "_<module>LibRelease" */
if ((p = strstr(name, "/" LIBDIR)) != NULL)
p[1] = 0; /* cut "<location>" before LIBDIR */
if (getLibVersion(symname) == NULL)
registerModule(symname, version, location);
}
dlclose(handle);
return 0;
}
static int registerRequire() {
char *requireLocation = NULL;
char *requireVersion = NULL;
static void registerExternalModules() {
/* iterate over all loaded libraries */
dl_iterate_phdr(findLibRelease, NULL);
}
#elif defined(_WIN32)
static void registerExternalModules() {
HMODULE hMods[100];
HANDLE hProcess = GetCurrentProcess();
DWORD cbNeeded;
char *location = NULL;
char *p;
char *version;
char *symname;
unsigned int i;
char name[MAX_PATH + 11]; /* get space for library path + "LibRelease" */
/* iterate over all loaded libraries */
if (!EnumProcessModules(hProcess, hMods, sizeof(hMods), &cbNeeded))
return;
for (i = 0; i < (cbNeeded / sizeof(HMODULE)); i++) {
/* Get the full path to the module's file. */
if (!GetModuleFileName(hMods[i], name, MAX_PATH))
continue; /* no library name */
name[sizeof(name) - 1] = 0; /* WinXP may not terminate the string */
p = strrchr(name,
'\\'); /* find file name part in "<location>/<module>.dll" */
if (p) {
location = name;
} else
p = name; /* find end of "<location>\\" (if exists) */
symname = p;
p = strchr(symname, '.'); /* find ".dll" */
if (p == NULL)
p = symname + strlen(symname); /* no file extension ? */
memmove(symname + 2, symname, p - symname); /* make room for 0 and '_' */
*symname++ = 0; /* terminate "<location>/" */
*symname = '_'; /* prefix module name with '_' */
strcpy((p += 2), "LibRelease"); /* append "LibRelease" to module name */
version = (char *)GetProcAddress(
hMods[i], symname); /* find symbol "_<module>LibRelease" */
if (version) {
*p = 0;
symname++; /* get "<module>" from "_<module>LibRelease" */
if ((p = strstr(name, "\\" LIBDIR)) != NULL)
p[1] = 0; /* cut "<location>" before LIBDIR */
if (getLibVersion(symname) == NULL)
registerModule(symname, version, location);
}
requireLocation = getenv(E3_REQUIRE_LOCATION);
if (!requireLocation) {
errlogPrintf("require: Failed to get " E3_REQUIRE_LOCATION "\n");
return -1;
}
}
#else
static void registerExternalModules() { ; }
#endif
size_t foreachLoadedLib(size_t (*func)(const char *name, const char *version,
const char *path, void *arg),
void *arg) {
moduleitem *m;
int result;
for (m = loadedModules; m; m = m->next) {
const char *name = m->content;
const char *version = name + strlen(name) + 1;
const char *path = version + strlen(version) + 1;
result = func(name, version, path, arg);
if (result)
return result;
requireVersion = getenv(E3_REQUIRE_VERSION);
if (!requireVersion) {
errlogPrintf("require: Failed to get " E3_REQUIRE_VERSION "\n");
return -1;
}
registerModule(&loadedModules, "require", requireVersion, requireLocation);
return 0;
}
const char *getLibVersion(const char *libname) {
moduleitem *m;
for (m = loadedModules; m; m = m->next) {
if (strcmp(m->content, libname) == 0) {
return m->content + strlen(m->content) + 1;
}
}
return NULL;
}
const char *getLibLocation(const char *libname) {
moduleitem *m;
char *v;
for (m = loadedModules; m; m = m->next) {
if (strcmp(m->content, libname) == 0) {
v = m->content + strlen(m->content) + 1;
return v + strlen(v) + 1;
}
}
return NULL;
}
int isModuleLoaded(const char *libname) {
moduleitem *m;
for (m = loadedModules; m; m = m->next) {
if (strcmp(m->content, libname) == 0)
return TRUE;
}
return FALSE;
}
int libversionShow(const char *outfile) {
moduleitem *m;
size_t lm, lv;
struct module *m = NULL;
FILE *out = epicsGetStdout();
if (outfile) {
out = fopen(outfile, "w");
if (out == NULL) {
fprintf(stderr, "can't open %s: %s\n", outfile, strerror(errno));
errlogPrintf("can't open %s: %s\n", outfile, strerror(errno));
return -1;
}
}
for (m = loadedModules; m; m = m->next) {
lm = strlen(m->content) + 1;
lv = strlen(m->content + lm) + 1;
fprintf(out, "%-*s%-20s %s\n", (int)maxModuleNameLength, m->content,
m->content + lm, m->content + lm + lv);
for (m = loadedModules.head; m; m = m->next) {
fprintf(out, "%s-%20s %s\n", m->name, m->version, m->path);
}
if (fflush(out) < 0 && outfile) {
fprintf(stderr, "can't write to %s: %s\n", outfile, strerror(errno));
errlogPrintf("can't write to %s: %s\n", outfile, strerror(errno));
return -1;
}
if (outfile)
fclose(out);
if (outfile) fclose(out);
return 0;
}
#define MISMATCH -1
#define EXACT 0
#define MATCH 1
#define TESTVERS 2
#define HIGHER 3
#define debug(...) \
if (requireDebug) \
printf(__VA_ARGS__)
static int compareDigit(int found, int requested, const char *name) {
debug("require: compareDigit: found %d, requested %d for digit %s\n", found,
requested, name);
......@@ -795,9 +319,8 @@ static int compareDigit(int found, int requested, const char *name) {
return MATCH;
}
static int compareNumericVersion(semver_t *sv_found, semver_t *sv_request,
int already_matched) {
int match;
static int compareNumericVersion(semver_t *sv_found, semver_t *sv_request) {
int match = 0;
match = compareDigit(sv_found->major, sv_request->major, "major");
if (match != MATCH) {
......@@ -807,23 +330,7 @@ static int compareNumericVersion(semver_t *sv_found, semver_t *sv_request,
if (match != MATCH) {
return match;
}
match = compareDigit(sv_found->patch, sv_request->patch, "patch");
if (match != MATCH) {
return match;
}
if (sv_request->build == -1) {
if (already_matched) {
debug("require: compareVersions: No build number requested. Returning "
"HIGHER\n");
return HIGHER;
} else {
debug("require: compareVersions: No build number requested. Returning "
"MATCH\n");
return MATCH;
}
}
return compareDigit(sv_found->build, sv_request->build, "build");
return compareDigit(sv_found->patch, sv_request->patch, "patch");
}
/*
......@@ -831,10 +338,11 @@ static int compareNumericVersion(semver_t *sv_found, semver_t *sv_request,
*/
static int compareVersions(const char *found, const char *request,
int already_matched) {
semver_t *sv_found, *sv_request;
int match;
semver_t *sv_found = NULL, *sv_request = NULL;
int match = 0;
debug("require: compareVersions(found=%s, request=%s)\n", found, request);
debug("require: compareVersions(found=%s, request=%s)\n", found,
request ? request : "");
if (request == NULL || request[0] == 0) {
debug("require: compareVersions: MATCH empty version requested\n");
......@@ -845,33 +353,62 @@ static int compareVersions(const char *found, const char *request,
return MISMATCH;
}
sv_found = (semver_t *)calloc(1, sizeof(semver_t));
sv_request = (semver_t *)calloc(1, sizeof(semver_t));
sv_found = parse_semver(found);
sv_request = parse_semver(request);
if (sv_found == NULL || sv_request == NULL) {
debug("require: compareVersion: failed to allocate semver_t\n");
return MISMATCH;
}
parse_semver(found, sv_found);
parse_semver(request, sv_request);
// TODO: maybe don't do this. This is only in the case that
// we have found an installed version with no revision number.
if (already_matched && sv_request->revision == -1) sv_request->revision = 0;
// test version, look for exact.
if (strlen(sv_request->test_str) > 0) {
if (strcmp(found, request) == 0) {
debug("require: compareVersions: Test version requested and found, "
"matches exactly\n");
match = EXACT;
if (strcmp(sv_found->test_str, sv_request->test_str) == 0) {
debug(
"require: compareVersions: Test version requested and found, "
"matches\n");
match = MATCH;
} else if (strlen(sv_found->test_str) > 0) {
debug("require: compareVersions: Test versions requested and found, no "
"match\n");
debug(
"require: compareVersions: Test versions requested and found, no "
"match\n");
match = MISMATCH;
} else {
debug("require: compareVersions: found numeric version, higher than "
"test\n");
debug(
"require: compareVersions: found numeric version, higher than "
"test\n");
match = HIGHER;
}
} else if (strlen(sv_found->test_str) > 0) {
debug("require: compareVersions: Numeric version requested, test version "
"found\n");
debug(
"require: compareVersions: Numeric version requested, test version "
"found\n");
match = MISMATCH;
} else {
match = compareNumericVersion(sv_found, sv_request, already_matched);
match = compareNumericVersion(sv_found, sv_request);
}
// Finally, check revision numbers
if (match == MATCH) {
if (sv_request->revision == -1) {
if (already_matched) {
debug(
"require: compareVersions: No revision number for already found "
"version. Returning HIGHER\n");
match = HIGHER;
} else {
debug(
"require: compareVersions: No revision number requested. Returning "
"MATCH\n");
match = MATCH;
}
} else {
match =
compareDigit(sv_found->revision, sv_request->revision, "revision");
}
}
cleanup_semver(sv_found);
cleanup_semver(sv_request);
......@@ -890,192 +427,125 @@ it calls epicsExit to abort the application.
*/
/* wrapper to abort statup script */
static int require_priv(const char *module, const char *version,
const char *args, const char *versionstr);
int require(const char *module, const char *version, const char *args) {
int status;
char *versionstr;
static int firstTime = 1;
if (firstTime) {
firstTime = 0;
static int require_priv(const char *module, const char *version);
set_require_env();
putenvprintf("T_A=%s", targetArch);
putenvprintf("EPICS_HOST_ARCH=%s", targetArch);
putenvprintf("EPICS_RELEASE=%s", epicsRelease);
putenvprintf("OS_CLASS=%s", osClass);
}
int require(const char *module, const char *version) {
int status = 0;
if (module == NULL) {
printf("Usage: require \"<module>\" [, \"<version>\" | \"ifexists\"] [, "
"\"<args>\"]\n");
printf("Usage: require \"<module>\" [, \"<version>\" ]\n");
printf("Loads " PREFIX "<module>" INFIX EXT " and <libname>.dbd\n");
printf("And calls <module>_registerRecordDeviceDriver\n");
printf("If available, runs startup script snippet (only before iocInit)\n");
return -1;
}
/* either order for version and args, either may be empty or NULL */
if (version && strchr(version, '=')) {
const char *v = version;
version = args;
args = v;
if (requireDebug)
printf("require: swap version and args\n");
if (interruptAccept) {
errlogPrintf("Error! Modules can only be loaded before iocIint!\n");
return -1;
}
if (version && version[0] == 0)
version = NULL;
if (version && version[0] == 0) version = NULL;
if (version && strcmp(version, "none") == 0) {
if (requireDebug)
printf("require: skip version=none\n");
debug("require: skip version=none\n");
return 0;
}
if (version) {
/* needed for old style only: */
if (asprintf(&versionstr, "-%s", version) < 0)
return errno;
if (isdigit((unsigned char)version[0]) &&
version[strlen(version) - 1] == '+') {
/*
user may give a minimal version (e.g. "1.2.4+")
load highest matching version (here "1.2") and check later
*/
char *p = strrchr(versionstr, '.');
if (p == NULL)
p = versionstr;
*p = 0;
}
} else
versionstr = "";
if (requireDebug)
printf("require: versionstr = \"%s\"\n", versionstr);
status = require_priv(module, version, args, versionstr);
status = require_priv(module, version);
if (version)
free(versionstr);
if (status == 0)
return 0;
if (status != -1)
perror("require");
if (interruptAccept)
return status;
if (status == 0) return 0;
if (status != -1) perror("require");
if (interruptAccept) return status;
/* require failed in startup script before iocInit */
fprintf(stderr, "Aborting startup script\n");
errlogPrintf("Aborting startup script\n");
epicsExit(1);
return status;
}
static off_t fileSize(const char *filename) {
struct stat filestat;
struct stat filestat = {0};
if (stat(filename, &filestat) != 0) {
if (requireDebug)
printf("require: %s does not exist\n", filename);
debug("require: %s does not exist\n", filename);
return -1;
}
switch (filestat.st_mode & S_IFMT) {
case S_IFREG:
if (requireDebug)
printf("require: file %s exists, size %lld bytes\n", filename,
(unsigned long long)filestat.st_size);
return filestat.st_size;
case S_IFDIR:
if (requireDebug)
printf("require: directory %s exists\n", filename);
return 0;
case S_IFREG:
debug("require: file %s exists, size %lld bytes\n", filename,
(unsigned long long)filestat.st_size);
return filestat.st_size;
case S_IFDIR:
debug("require: directory %s exists\n", filename);
return 0;
#ifdef S_IFBLK
case S_IFBLK:
if (requireDebug)
printf("require: %s is a block device\n", filename);
return -1;
case S_IFBLK:
debug("require: %s is a block device\n", filename);
return -1;
#endif
#ifdef S_IFCHR
case S_IFCHR:
if (requireDebug)
printf("require: %s is a character device\n", filename);
return -1;
case S_IFCHR:
debug("require: %s is a character device\n", filename);
return -1;
#endif
#ifdef S_IFIFO
case S_IFIFO:
if (requireDebug)
printf("require: %s is a FIFO/pipe\n", filename);
return -1;
case S_IFIFO:
debug("require: %s is a FIFO/pipe\n", filename);
return -1;
#endif
#ifdef S_IFSOCK
case S_IFSOCK:
if (requireDebug)
printf("require: %s is a socket\n", filename);
return -1;
case S_IFSOCK:
debug("require: %s is a socket\n", filename);
return -1;
#endif
default:
if (requireDebug)
printf("require: %s is an unknown type of special file\n", filename);
return -1;
default:
debug("require: %s is an unknown type of special file\n", filename);
return -1;
}
}
#define fileExists(filename) (fileSize(filename) >= 0)
#define fileNotEmpty(filename) (fileSize(filename) > 0)
#define TRY_FILE(offs, ...) \
(snprintf(filename + offs, PATH_MAX - offs, __VA_ARGS__) && \
fileExists(filename))
#define TRY_NONEMPTY_FILE(offs, ...) \
(snprintf(filename + offs, PATH_MAX - offs, __VA_ARGS__) && \
fileNotEmpty(filename))
static int handleDependencies(const char *module, char *depfilename) {
FILE *depfile;
char buffer[40];
char *end; /* end of string */
char *rmodule; /* required module */
char *rversion; /* required version */
if (requireDebug)
printf("require: parsing dependency file %s\n", depfilename);
FILE *depfile = NULL;
char buffer[40] = {0};
char *end = NULL; /* end of string */
char *rmodule = NULL; /* required module */
char *rversion = NULL; /* required version */
debug("require: parsing dependency file %s\n", depfilename);
depfile = fopen(depfilename, "r");
while (fgets(buffer, sizeof(buffer) - 1, depfile)) {
rmodule = buffer;
/* ignore leading spaces */
while (isspace((unsigned char)*rmodule))
rmodule++;
while (isspace((unsigned char)*rmodule)) rmodule++;
/* ignore empty lines and comment lines */
if (*rmodule == 0 || *rmodule == '#')
continue;
if (*rmodule == 0 || *rmodule == '#') continue;
/* rmodule at start of module name */
rversion = rmodule;
/* find end of module name */
while (*rversion && !isspace((unsigned char)*rversion))
rversion++;
while (*rversion && !isspace((unsigned char)*rversion)) rversion++;
/* terminate module name */
*rversion++ = 0;
/* ignore spaces */
while (isspace((unsigned char)*rversion))
rversion++;
while (isspace((unsigned char)*rversion)) rversion++;
/* rversion at start of version */
if (*rversion) {
end = rversion;
/* find end of version */
while (*end && !isspace((unsigned char)*end))
end++;
/* add + to numerial versions if not yet there */
/*
ESS would like to use the MATCH version only, not HIGHER.
In order to touch the PSI code mininaly, disable add + from VERSION from Dep
file. At the same time, ESS use the X.X.X instead of X.X. Wednesday, May 2
00:12:18 CEST 2018, jhlee
*/
/*
if (*(end-1) != '+' && strspn(rversion, "0123456789.") ==
(size_t)(end-rversion)) *end++ = '+';
*/
while (*end && !isspace((unsigned char)*end)) end++;
/* terminate version */
*end = 0;
}
printf("Module %s depends on %s %s\n", module, rmodule, rversion);
if (require(rmodule, rversion, NULL) != 0) {
if (require(rmodule, rversion) != 0) {
fclose(depfile);
return -1;
}
......@@ -1084,416 +554,344 @@ static int handleDependencies(const char *module, char *depfilename) {
return 0;
}
static int
require_priv(const char *module, const char *version, const char *args,
const char *versionstr /* "-<version>" or "" (for old style only */
) {
int status;
const char *loaded = NULL;
/*
* Fetches the correct module version based on the requested version by
* searching through EPICS_DRIVER_PATH until it finds a matching version.
*
* Sets <filename> to be the path the the underlying module.
*/
static char *fetch_module_version(char *filename, size_t max_file_len,
const char *module, const char *version) {
const char *dirname = NULL;
const char *driverpath = NULL;
const char *end = NULL;
const char *found = NULL;
HMODULE libhandle;
int ifexists = 0;
const char *driverpath;
const char *dirname;
const char *end;
int releasediroffs;
int libdiroffs;
int extoffs;
int versionLength = 0;
char *selectedVersion = NULL;
char *founddir = NULL;
char *symbolname;
char filename[PATH_MAX];
int someVersionFound = 0;
int someArchFound = 0;
static char *globalTemplates = NULL;
if (requireDebug)
printf("require: module=\"%s\" version=\"%s\" args=\"%s\"\n", module,
version, args);
#if defined __GNUC__ && __GNUC__ < 3
#define TRY_FILE(offs, args...) \
(snprintf(filename + offs, sizeof(filename) - offs, args) && \
fileExists(filename))
#define TRY_NONEMPTY_FILE(offs, args...) \
(snprintf(filename + offs, sizeof(filename) - offs, args) && \
fileNotEmpty(filename))
#else
#define TRY_FILE(offs, ...) \
(snprintf(filename + offs, sizeof(filename) - offs, __VA_ARGS__) && \
fileExists(filename))
#define TRY_NONEMPTY_FILE(offs, ...) \
(snprintf(filename + offs, sizeof(filename) - offs, __VA_ARGS__) && \
fileNotEmpty(filename))
#endif
#if defined(_WIN32)
/* enable %n in printf */
_set_printf_count_output(1);
#endif
driverpath = getenv("EPICS_DRIVER_PATH");
if (!globalTemplates) {
char *t = getenv("TEMPLATES");
if (t)
globalTemplates = strdup(t);
}
if (driverpath == NULL)
driverpath = ".";
if (requireDebug)
printf("require: searchpath=%s\n", driverpath);
if (version && strcmp(version, "ifexists") == 0) {
ifexists = 1;
version = NULL;
versionstr = "";
}
/* check already loaded verion */
loaded = getLibVersion(module);
if (loaded) {
/* Library already loaded. Check Version. */
switch (compareVersions(loaded, version, FALSE)) {
case TESTVERS:
if (version)
printf("Warning: Module %s test version %s already loaded where %s was "
"requested\n",
module, loaded, version);
case EXACT:
case MATCH:
printf("Module %s version %s already loaded\n", module, loaded);
break;
default:
printf("Conflict between requested %s version %s and already loaded "
"version %s.\n",
module, version, loaded);
return -1;
}
dirname = getLibLocation(module);
if (dirname[0] == 0)
return 0;
if (requireDebug)
printf("require: library found in %s\n", dirname);
snprintf(filename, sizeof(filename), "%s%n", dirname, &releasediroffs);
putenvprintf("MODULE=%s", module);
pathAdd("SCRIPT_PATH", dirname);
} else {
if (requireDebug)
printf("require: no %s version loaded yet\n", module);
/* Search for module in driverpath */
for (dirname = driverpath; dirname != NULL; dirname = end) {
/* get one directory from driverpath */
int dirlen;
int modulediroffs;
DIR_HANDLE dir;
DIR_ENTRY direntry;
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 driverpath elements */
if (requireDebug)
printf("require: trying %.*s\n", dirlen, dirname);
snprintf(filename, sizeof(filename),
"%.*s" OSI_PATH_SEPARATOR "%s" OSI_PATH_SEPARATOR "%n", dirlen,
dirname, module, &modulediroffs);
dirlen++;
/* filename = "<dirname>/[dirlen]<module>/[modulediroffs]" */
/* Does the module directory exist? */
IF_OPEN_DIR(filename) {
if (requireDebug)
printf("require: found directory %s\n", filename);
/* Now look for versions. */
START_DIR_LOOP {
char *currentFilename = FILENAME(direntry);
SKIP_NON_DIR(direntry)
if (currentFilename[0] == '.')
continue; /* ignore hidden directories */
someVersionFound = 1;
/* Look for highest matching version. */
if (requireDebug)
printf("require: checking version %s against required %s\n",
currentFilename, version);
switch ((status = compareVersions(currentFilename, version, FALSE))) {
case TESTVERS: /* test version found */
case EXACT: /* exact match found */
case MATCH: /* all given numbers match. */
if (driverpath == NULL) driverpath = ".";
debug("require: searchpath=%s\n", driverpath);
for (dirname = driverpath; dirname != NULL; dirname = end) {
/* get one directory from driverpath */
int dirlen = 0;
int modulediroffs = 0;
DIR_HANDLE dir = NULL;
DIR_ENTRY direntry = NULL;
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)strnlen(dirname, PATH_MAX);
if (dirlen == 0) continue; /* ignore empty driverpath elements */
debug("require: trying %.*s\n", dirlen, dirname);
snprintf(filename, max_file_len,
"%.*s" OSI_PATH_SEPARATOR "%s" OSI_PATH_SEPARATOR "%n", dirlen,
dirname, module, &modulediroffs);
dirlen++;
/* filename = "<dirname>/[dirlen]<module>/[modulediroffs]" */
/* Does the module directory exist? */
IF_OPEN_DIR(filename) {
debug("require: found directory %s\n", filename);
/* Now look for versions. */
START_DIR_LOOP {
char *currentFilename = FILENAME(direntry);
SKIP_NON_DIR(direntry)
if (currentFilename[0] == '.') continue; /* ignore hidden directories */
someVersionFound = 1;
/* Look for highest matching version. */
debug("require: checking version %s against required %s\n",
currentFilename, version ? version : "");
switch (compareVersions(currentFilename, version, FALSE)) {
case MATCH: /* all given numbers match. */
{
someArchFound = 1;
if (requireDebug)
printf("require: %s %s may match %s\n", module, currentFilename,
version);
debug("require: %s %s may match %s\n", module, currentFilename,
version ? version : "");
/* Check if it has our EPICS version and architecture. */
/* Even if it has no library, at least it has a dep file in the lib
* dir */
/* Even if it has no library, at least it has a dep file in the
* lib dir */
/* Step 1 : library file location */
/* filename = "<dirname>/[dirlen]<module>/[modulediroffs]" */
if (!TRY_FILE(modulediroffs,
"%s" OSI_PATH_SEPARATOR LIBDIR
"%s" OSI_PATH_SEPARATOR,
currentFilename, targetArch))
/* filename =
"<dirname>/[dirlen]<module>/[modulediroffs]<version>/lib/<targetArch>/"
*/
{
if (requireDebug)
printf("require: %s %s has no support for %s %s\n", module,
currentFilename, epicsRelease, targetArch);
currentFilename, targetArch)) {
/* filename =
* "<dirname>/[dirlen]<module>/[modulediroffs]<version>/lib/<targetArch>/"
*/
debug("require: %s %s has no support for %s %s\n", module,
currentFilename, epicsRelease, targetArch);
continue;
}
if (status == EXACT) {
if (requireDebug)
printf("require: %s %s matches %s exactly\n", module,
currentFilename, version);
/* We are done. */
end = NULL;
break;
}
/* Is it higher than the one we found before? */
if (found && requireDebug)
printf("require: %s %s support for %s %s found, compare against "
"previously found %s\n",
module, currentFilename, epicsRelease, targetArch, found);
if (found)
debug(
"require: %s %s support for %s %s found, compare against "
"previously found %s\n",
module, currentFilename, epicsRelease, targetArch, found);
if (!found ||
compareVersions(currentFilename, found, TRUE) == HIGHER) {
if (requireDebug)
printf("require: %s %s looks promising\n", module,
currentFilename);
debug("require: %s %s looks promising\n", module,
currentFilename);
break;
}
if (requireDebug)
printf("require: version %s is lower than %s \n", currentFilename,
found);
debug("require: version %s is lower than %s \n", currentFilename,
found);
continue;
}
default: {
if (requireDebug)
printf("require: %s %s does not match %s\n", module,
currentFilename, version);
debug("require: %s %s does not match %s\n", module, currentFilename,
version);
continue;
}
}
/* we have found something (EXACT or MATCH) */
free(founddir);
/* filename = "<dirname>/[dirlen]<module>/[modulediroffs]..." */
if (asprintf(&founddir, "%.*s%s", modulediroffs, filename,
currentFilename) < 0)
return errno;
/* founddir = "<dirname>/[dirlen]<module>/[modulediroffs]<version>" */
found = founddir + modulediroffs; /* version part in the path */
if (status == EXACT)
break;
}
END_DIR_LOOP
/* we have found something */
if (founddir) free(founddir);
/* filename = "<dirname>/[dirlen]<module>/[modulediroffs]..." */
if (asprintf(&founddir, "%.*s%s", modulediroffs, filename,
currentFilename) < 0)
return NULL;
/* founddir = "<dirname>/[dirlen]<module>/[modulediroffs]<version>" */
found = founddir + modulediroffs; /* version part in the path */
}
else {
/* filename = "<dirname>/[dirlen]<module>/" */
if (requireDebug)
printf("require: no %s directory\n", filename);
/* try local/old style module only if no new style candidate has been
* found */
if (!found) {
/* look for dep file */
releasediroffs = libdiroffs = dirlen;
if (TRY_FILE(dirlen, "%s%s.dep", module, versionstr))
/* filename =
"<dirname>/[dirlen][releasediroffs][libdiroffs]<module>(-<version>)?.dep"
*/
{
if (requireDebug)
printf("require: found old style %s\n", filename);
printf("Module %s%s found in %.*s\n", module, versionstr, dirlen,
filename);
goto checkdep;
}
END_DIR_LOOP
}
/* filename = "<dirname>/[dirlen]..." */
if (!found)
debug("require: no matching version in %.*s\n", dirlen, filename);
}
if (!found) {
if (someArchFound)
errlogPrintf(
"Module %s%s%s not available for %s\n(but maybe for other "
"EPICS versions or architectures)\n",
module, version ? " version " : "", version ? version : "",
targetArch);
else if (someVersionFound)
errlogPrintf(
"Module %s%s%s not available (but other versions are available)\n",
module, version ? " version " : "", version ? version : "");
else
errlogPrintf("Module %s%s%s not available\n", module,
version ? " version " : "", version ? version : "");
if (founddir) free(founddir);
return NULL;
}
/* look for library file */
if (TRY_FILE(dirlen, PREFIX "%s" INFIX "%s%n" EXT, module, versionstr,
&extoffs)
/* filename =
"<dirname>/[dirlen][releasediroffs][libdiroffs]PREFIX<module>INFIX(-<version>)?[extoffs]EXT"
*/
) {
if (requireDebug)
printf("require: found old style %s\n", filename);
printf("Module %s%s found in %.*s\n", module, versionstr, dirlen,
filename);
goto loadlib;
}
}
}
/* filename = "<dirname>/[dirlen]..." */
if (!found && requireDebug)
printf("require: no matching version in %.*s\n", dirlen, filename);
/* founddir = "<dirname>/[dirlen]<module>/<version>" */
printf("Module %s version %s found in %s" OSI_PATH_SEPARATOR "\n", module,
found, founddir);
snprintf(filename, max_file_len, "%s" OSI_PATH_SEPARATOR, founddir);
versionLength = strlen(found) + 1;
selectedVersion = calloc(versionLength, sizeof(char));
memcpy(selectedVersion, found, versionLength);
free(founddir);
return selectedVersion;
}
/*
* Loads the shared library if available.
*
* Returns the actual version string for the module, and NULL if there is a
* mismatch.
*/
static const char *compare_module_version(char *filename, const char *module,
const char *version, int libdiroffs) {
HMODULE libhandle = NULL;
char *symbolname = NULL;
const char *found = NULL;
/* filename =
"<dirname>/[dirlen]<module>/<version>/[releasediroffs]/lib/<targetArch>/[libdiroffs]/PREFIX<module>INFIX(EXT)?"
*/
if (!(TRY_FILE(libdiroffs, PREFIX "%s" INFIX EXT, module))) {
errlogPrintf("Module %s has no library\n", module);
found = version;
} else {
printf("Loading library %s\n", filename);
if ((libhandle = loadlib(filename)) == NULL) {
return NULL;
}
if (!found) {
if (someArchFound)
fprintf(stderr,
"Module %s%s%s not available for %s\n(but maybe for other "
"EPICS versions or architectures)\n",
module, version ? " version " : "", version ? version : "",
targetArch);
else if (someVersionFound)
fprintf(
stderr,
"Module %s%s%s not available (but other versions are available)\n",
module, version ? " version " : "", version ? version : "");
else
fprintf(stderr, "Module %s%s%s not available\n", module,
version ? " version " : "", version ? version : "");
return ifexists ? 0 : -1;
/* now check what version we really got (with compiled-in version number)
*/
if (asprintf(&symbolname, "_%sLibRelease", module) < 0) {
return NULL;
}
versionstr = "";
found = (const char *)getAddress(libhandle, symbolname);
free(symbolname);
printf("Loaded %s version %s\n", module, found);
/* founddir = "<dirname>/[dirlen]<module>/<version>" */
printf("Module %s version %s found in %s" OSI_PATH_SEPARATOR "\n", module,
found, founddir);
/* check what we got */
debug("require: compare requested version %s with loaded version %s\n",
version, found);
if (compareVersions(found, version, FALSE) == MISMATCH) {
errlogPrintf("Requested %s version %s not available, found only %s.\n",
module, version, found);
return NULL;
}
}
return found;
}
/* Step 2 : Looking for Dep file */
if (requireDebug)
printf("require: looking for dependency file\n");
/*
* Loads the module .dbd file and runs registerRecordDeviceDriver.
*/
static int load_module_data(char *filename, const char *module,
const char *version, int releasediroffs) {
int returnvalue = 0;
char *symbolname = NULL;
/* load dbd file */
if (TRY_NONEMPTY_FILE(releasediroffs, "dbd" OSI_PATH_SEPARATOR "%s.dbd",
module)) {
printf("Loading dbd file %s\n", filename);
if (dbLoadDatabase(filename, NULL, NULL) != 0) {
errlogPrintf("Error loading %s\n", filename);
return -1;
}
if (!TRY_FILE(0,
"%s" OSI_PATH_SEPARATOR "%n" LIBDIR "%s" OSI_PATH_SEPARATOR
"%n%s.dep",
founddir, &releasediroffs, targetArch, &libdiroffs, module))
/* filename =
"<dirname>/[dirlen]<module>/<version>/R<epicsRelease>/[releasediroffs]/lib/<targetArch>/[libdiroffs]/module.dep"
*/
{
fprintf(stderr, "Dependency file %s not found\n", filename);
} else {
checkdep:
/* filename =
* "<dirname>/[dirlen]<module>/<version>/R<epicsRelease>/[releasediroffs]/lib/<targetArch>/[libdiroffs]/module.dep"
*/
/* or (old)
* "<dirname>/[dirlen]][releasediroffs][libdiroffs]<module>(-<version>)?.dep"
*/
if (handleDependencies(module, filename) == -1)
return -1;
/* when dbd is loaded call register function */
if (asprintf(&symbolname, "%s_registerRecordDeviceDriver", module) < 0) {
return -1;
}
if (requireDebug)
printf("require: looking for library file\n");
printf("Calling function %s\n", symbolname);
returnvalue = iocshCmd(symbolname);
free(symbolname);
if (returnvalue) return -1;
} else {
/* no dbd file, but that might be OK */
printf("%s has no dbd file\n", module);
}
return 0;
}
if (!(TRY_FILE(libdiroffs, PREFIX "%s" INFIX "%s%n" EXT, module, versionstr,
&extoffs)))
/* filename =
"<dirname>/[dirlen]<module>/<version>/R<epicsRelease>/[releasediroffs]/lib/<targetArch>/[libdiroffs]/PREFIX<module>INFIX[extoffs](EXT)?"
*/
/* or (old)
"<dirname>/[dirlen][releasediroffs][libdiroffs]PREFIX<module>INFIX(-<version>)?[extoffs](EXT)?"
*/
{
printf("Module %s has no library\n", module);
} else {
loadlib:
static int require_priv(const char *module, const char *version) {
int returnvalue = 0;
const char *loaded = NULL;
const char *found = NULL;
const char *dirname = NULL;
char *selectedVersion = NULL;
int dirlen = 0;
int releasediroffs = 0;
int libdiroffs = 0;
char filename[PATH_MAX] = {0};
static char *globalTemplates = NULL;
if (!globalTemplates) {
char *t = getenv("TEMPLATES");
if (t) globalTemplates = strdup(t);
}
debug("require: module=\"%s\" version=\"%s\"\n", module, version);
/* check already loaded verion */
loaded = getLibVersion(&loadedModules, module);
if (loaded) {
/* Library already loaded. Check Version. */
switch (compareVersions(loaded, version, FALSE)) {
case MATCH:
printf("Module %s version %s already loaded\n", module, loaded);
break;
default:
printf(
"Conflict between requested %s version %s and already loaded "
"version %s.\n",
module, version, loaded);
return -1;
}
dirname = getLibLocation(&loadedModules, module);
if (dirname[0] == 0) return 0;
debug("require: library found in %s\n", dirname);
snprintf(filename, sizeof(filename), "%s%n", dirname, &releasediroffs);
putenvprintf("MODULE=%s", module);
pathAdd("SCRIPT_PATH", dirname);
} else {
debug("require: no %s version loaded yet\n", module);
/* Step 1: Search for module in driverpath */
selectedVersion =
fetch_module_version(filename, sizeof(filename), module, version);
if (!selectedVersion) {
returnvalue = -1;
goto require_priv_end;
}
/* Step 2 : Looking for .dep file */
debug("require: looking for dependency file\n");
dirlen = strnlen(filename, PATH_MAX);
if (!TRY_FILE(dirlen,
OSI_PATH_SEPARATOR "%n" LIBDIR "%s" OSI_PATH_SEPARATOR
"%n%s.dep",
&releasediroffs, targetArch, &libdiroffs, module)) {
/* filename =
* "<dirname>/[dirlen]<module>/<version>/R<epicsRelease>/[releasediroffs]/lib/<targetArch>/[libdiroffs]/PREFIX<module>INFIX[extoffs]EXT"
*/
/* or (old)
* "<dirname>/[dirlen][releasediroffs][libdiroffs]PREFIX<module>INFIX(-<version>)?[extoffs]EXT"
"<dirname>/[dirlen]<module>/<version>/[releasediroffs]/lib/<targetArch>/[libdiroffs]/module.dep"
*/
printf("Loading library %s\n", filename);
if ((libhandle = loadlib(filename)) == NULL)
return -1;
/* now check what version we really got (with compiled-in version number)
errlogPrintf("Dependency file %s not found\n", filename);
} else {
/* filename =
* "<dirname>/[dirlen]<module>/<version>/[releasediroffs]/lib/<targetArch>/[libdiroffs]/module.dep"
*/
if (asprintf(&symbolname, "_%sLibRelease", module) < 0)
return errno;
found = (const char *)getAddress(libhandle, symbolname);
free(symbolname);
printf("Loaded %s version %s\n", module, found);
/* check what we got */
if (requireDebug)
printf("require: compare requested version %s with loaded version %s\n",
version, found);
if (compareVersions(found, version, FALSE) == MISMATCH) {
fprintf(stderr,
"Requested %s version %s not available, found only %s.\n",
module, version, found);
return -1;
if (handleDependencies(module, filename) == -1) {
returnvalue = -1;
goto require_priv_end;
}
}
releasediroffs += dirlen;
libdiroffs += dirlen;
/* load dbd file */
if (TRY_NONEMPTY_FILE(releasediroffs, "dbd" OSI_PATH_SEPARATOR "%s%s.dbd",
module, versionstr) ||
TRY_NONEMPTY_FILE(releasediroffs, "%s%s.dbd", module, versionstr) ||
TRY_NONEMPTY_FILE(releasediroffs,
".." OSI_PATH_SEPARATOR "dbd" OSI_PATH_SEPARATOR
"%s%s.dbd",
module, versionstr) ||
TRY_NONEMPTY_FILE(releasediroffs, ".." OSI_PATH_SEPARATOR "%s%s.dbd",
module, versionstr) ||
TRY_NONEMPTY_FILE(releasediroffs,
".." OSI_PATH_SEPARATOR ".." OSI_PATH_SEPARATOR
"dbd" OSI_PATH_SEPARATOR "%s.dbd",
module)) /* org EPICSbase */
{
printf("Loading dbd file %s\n", filename);
if (dbLoadDatabase(filename, NULL, NULL) != 0) {
fprintf(stderr, "Error loading %s\n", filename);
return -1;
}
/* when dbd is loaded call register function */
if (asprintf(&symbolname, "%s_registerRecordDeviceDriver", module) < 0)
return errno;
/* Step 3: Ensure that we have loaded the correct version */
debug("require: Check that the loaded and requested versions match\n");
found =
compare_module_version(filename, module, selectedVersion, libdiroffs);
if (!found) {
returnvalue = -1;
goto require_priv_end;
}
printf("Calling function %s\n", symbolname);
iocshCmd(symbolname);
free(symbolname);
} else {
/* no dbd file, but that might be OK */
printf("%s has no dbd file\n", module);
}
/* Step 4: Load module data */
debug("require: Load module data\n");
returnvalue = load_module_data(filename, module, found, releasediroffs);
if (returnvalue) {
goto require_priv_end;
}
/* register module with path */
filename[releasediroffs] = 0;
registerModule(module, found, filename);
registerModule(&loadedModules, module, found, filename);
}
status = 0;
if (requireDebug)
printf("require: looking for template directory\n");
debug("require: looking for template directory\n");
/* filename =
* "<dirname>/[dirlen]<module>/<version>/R<epicsRelease>/[releasediroffs]..."
* "<dirname>/[dirlen]<module>/<version>/[releasediroffs]..."
*/
if (!((TRY_FILE(releasediroffs, TEMPLATEDIR) ||
TRY_FILE(releasediroffs, ".." OSI_PATH_SEPARATOR TEMPLATEDIR)) &&
if (!(TRY_FILE(releasediroffs, TEMPLATEDIR) &&
setupDbPath(module, filename) == 0)) {
/* if no template directory found, restore TEMPLATES to initial value */
char *t;
......@@ -1502,23 +900,20 @@ require_priv(const char *module, const char *version, const char *args,
putenvprintf("TEMPLATES=%s", globalTemplates);
}
if (loaded && args == NULL)
return 0; /* no need to execute startup script twice if not with new
arguments */
return status;
require_priv_end:
free(selectedVersion);
return returnvalue;
}
static const iocshFuncDef requireDef = {
"require", 3,
"require", 2,
(const iocshArg *[]){
&(iocshArg){"module", iocshArgString},
&(iocshArg){"[version]", iocshArgString},
&(iocshArg){"[substitutions]", iocshArgString},
}};
static void requireFunc(const iocshArgBuf *args) {
require(args[0].sval, args[1].sval, args[2].sval);
require(args[0].sval, args[1].sval);
}
static const iocshFuncDef libversionShowDef = {
......@@ -1557,7 +952,12 @@ static void requireRegister(void) {
iocshRegister(&libversionShowDef, libversionShowFunc);
iocshRegister(&ldDef, ldFunc);
iocshRegister(&pathAddDef, pathAddFunc);
registerExternalModules();
if (registerRequire() != 0) {
errlogPrintf("require: Could not register require.\n");
}
set_require_env();
initHookRegister(fillModuleListRecord);
}
}
......
require-ess/src/require.h
View file @ 4560be22
#ifndef require_h
#define require_h
/* Copyright (C) 2020 Dirk Zimoch */
/* Copyright (C) 2020-2022 European Spallation Source, ERIC */
#pragma once
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
#endif // __cplusplus
#ifndef __GNUC__
#define __attribute__(dummy)
#endif
#endif // __GNUC__
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 require(const char *libname, const char *version);
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
#endif // __cplusplus
require-ess/src/runScript.c deleted 100644 → 0
View file @ 73bbc073
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <ctype.h>
#include <dbAccess.h>
#include <epicsVersion.h>
#include <errno.h>
#include <initHooks.h>
#include <macLib.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define EPICSVER \
EPICS_VERSION * 10000 + EPICS_REVISION * 100 + EPICS_MODIFICATION
#if defined(_WIN32)
#include "asprintf.h"
#endif
#include <iocsh.h>
#include <osiFileName.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 deleted 100644 → 0
View file @ 73bbc073
registrar(runScriptRegister)
variable(runScriptDebug,int)
variable(exprDebug,int)
require-ess/src/strdup.c deleted 100644 → 0
View file @ 73bbc073
#include <stdlib.h>
#include <string.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 deleted 100644 → 0
View file @ 73bbc073
#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
View file @ 4560be22
/* Copyright (C) 2020-2022 European Spallation Source, ERIC */
#include "version.h"
#include <regex.h>
#include <stdio.h>
#include <stdlib.h>
......@@ -9,15 +12,15 @@ void cleanup_semver(semver_t *s) {
free(s);
}
static void init_semver(const char *version, semver_t *s) {
static semver_t *init_semver(const char *version) {
semver_t *s = (semver_t *)calloc(1, sizeof(semver_t));
s->version_str = calloc(strlen(version) + 1, sizeof(char));
strcpy(s->version_str, version);
s->test_str = "";
s->revision = -1;
s->major = 0;
s->minor = 0;
s->patch = 0;
s->build = -1;
return s;
}
static void fetch_part(char *version_str, const regmatch_t *groups,
......@@ -30,37 +33,41 @@ static void fetch_part(char *version_str, const regmatch_t *groups,
version_str[groups[ix].rm_eo] = tmp;
}
int parse_semver(const char *version, semver_t *s) {
semver_t *parse_semver(const char *version) {
static const char *version_regex =
"^(([0-9]+)\\.([0-9]+)\\.([0-9]+)(\\+([0-9]+))?)?(.*)$";
"^(([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;
static const unsigned int test_label_ix = 5;
static const unsigned int revision_ix = 7;
semver_t *s = init_semver(version);
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;
return NULL;
}
if (regcomp(&compiled, version_regex, REG_EXTENDED)) {
return 1;
regfree(&compiled);
return NULL;
}
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);
if (groups[test_label_ix].rm_so != groups[test_label_ix].rm_eo) {
s->test_str = s->version_str;
}
if (groups[revision_ix].rm_so != (regoff_t)-1) {
fetch_part(s->version_str, groups, revision_ix, &s->revision);
s->version_str[groups[revision_ix].rm_so - 1] = 0;
}
s->test_str = s->version_str + groups[test_ix].rm_so;
}
return 0;
regfree(&compiled);
return s;
}
require-ess/src/version.h
View file @ 4560be22
/* Copyright (C) 2020-2022 European Spallation Source, ERIC */
#pragma once
typedef struct semver_t {
char *version_str;
int major;
int minor;
int patch;
int build; // can be negative; implies that build has not been specified
int revision; // can be negative; implies that revision has not been
// specified
char *test_str;
} semver_t;
void cleanup_semver(semver_t *s);
int parse_semver(const char *version, semver_t *s);
semver_t *parse_semver(const char *version);
require-ess/test/testscript deleted 100644 → 0
View file @ 73bbc073
#var exprDebug 1
x=3, !3, !!3, -3, --3, ~3, ~~3, 3?, 3??
# $(x) should be: 3, 0, 1, -3, 3, -4, 3, 1, 1
x=x, !x, !!x, -x, --x, ~x, ~~x, x?, x??
# $(x) should be: x, !x, !!x, -x, --x, ~x, ~~x, x?, x??
x=10+3, 10-3, 10*3, 10/3, 10%3, 10**3
# $(x) should be: 13, 7, 30, 3, 1, 1000
x=7**-2 7**-1 7**0 7**1 7**2 7**3 7**4 7**5 7**6
# $(x) should be: 0 0 1 7 49 343 2401 16807 117649
x=%x -10<<2, %x -10>>2, %x -10>>>2
# $(x) should be: ffffffffffffffd8, fffffffffffffffd, 3ffffffffffffffd
x=%x 0xaa & 0x0f, %x 0xaa | 0x0f, %x 0xaa ^ 0x0f
# $(x) should be: a, af, a5
x=10<20 10<=20 10==20 10>=20 10>20 10<=>20 10<?20 10>?20 10?<20 10?>20
# $(x) should be: 1 1 0 0 0 -1 10 20 1 0
x=20<20 20<=20 20==20 20>=20 20>20 20<=>20 20<?20 20>?20 20?<20 20?>20
# $(x) should be: 0 1 1 1 0 0 20 20 1 0
x=20<10 20<=10 20==10 20>=10 20>10 20<=>10 20<?10 20>?10 20?<10 20?>10
# $(x) should be: 0 0 0 1 1 1 10 20 1 0
x= (0|0)(0|1)(1|0)(1|1) (0&0)(0&1)(1&0)(1&1) (0^0)(0^1)(1^0)(1^1)
# $(x) should be: 0111 0001 0110
x=1*2*3+4*5*6-7-8
# $(x) should be: 111
x=1*2*3+4*5*6-7*8
# $(x) should be: 70
x=-3**2+1, -(3**2)+1, (-3)**2+1, -3**-2+1, (1+2), (1+2, 1+2)
# $(x) should be: 10, -8, 10, 1, 3, (1+2, 3)
x=%#X 0x5555&0xfff0|0xaf<<8^0xa00a0>>4
# $(x) should be: 0X5F5A
x=7+4*2|32
# $(x) should be: 47
x=3<5 ? 7+4*2|32 : 9 & 10
# $(x) should be: 47
x=3>5 ? 7+4*2|32 : 9 & 10
# $(x) should be: 8
x=7 ?: -1
# $(x) should be: 7
x=0 ?: -1
# $(x) should be: -1
x=7 ? -1
# $(x) should be: -1
x=0 ? -1
# $(x) should be: 0
x=1+0?7?1:2:3?4:5
# $(x) should be: 1
x=1+0?0?1:2:3?4:5
# $(x) should be: 2
x=1-1?0?1:2:3?4:5
# $(x) should be: 4
x=1-1?0?1:2:3-3?4:5
# $(x) should be: 5
x=0?; 1?; 2?; -4?; 3?+1
# $(x) should be: 0; 1; 1; 1; 4
x=a030b a(030)b a( 030 )b "a"030"b" a(%x 030)b
# $(x) should be: a030b a24b a24b a24b a18b
x=030b (030)b ( 030 )b 030"b" %x 030'b'
# $(x) should be: 030b 24b 24b 24b 18b
x=-0bla -0.1
# $(x) should be: -0bla -0.1
x=-2**2 0-2**2 0+-2**2 0--2**2
# $(x) should be: 4 -4 4 -4
x=
y=$(x)
# <$(x)><$(y)> should be: <><>
require-ess/test/teststrings deleted 100644 → 0
View file @ 73bbc073
x=string0
y=$(x)
# $(x) $(y)
x="string1"
y=$(x)
# $(x) $(y)
x="'string2'"
y=$(x)
# $(x) $(y)
x='"string3"'
y=$(x)
# $(x) $(y)
x=\"string4\"
y=$(x)
# $(x) $(y)
x=\'string5\'
y=$(x)
# $(x) $(y)
x="Hello World"[2:8]
# $(x) should be: llo Wo
x=Hello World[2:8]
# "$(x)" should be: "Hello World[2:8]"
x="Hello World"[2,3]
# $(x) should be: llo
x="Hello World"[1]
# $(x) should be: e
x="Hello World"[-1]
# $(x) should be: d
x="Hello World"[-2:]
# $(x) should be: ld
x="Hello World"[-2,6]
# $(x) should be: ld
x="Hello World"[1:1000]
# $(x) should be: ello World
x="Hello World"[1:-1000]
# "$(x)" should be: ""
x="Hello World"[:]
# "$(x)" should be: "Hello World"
x="Hello World"[1?6:0:]
# "$(x)" should be: "World"
x="Hello World"[1000]
# "$(x)" should be: ""
x="Hello World"[-1000]
# "$(x)" should be: ""
x="Hello World"[-1000,1005]
# "$(x)" should be: "World"
x="Hello World"[-1000:5]
# "$(x)" should be: "World"
x="Hello World"[7:4]
# "$(x)" should be: ""
x="Hello World"[1?3+4:0:7-8]
# "$(x)" should be: "orl"
x="Hello World"[7,-1]
# "$(x)" should be: ""
x='\"\\x'[2]
# $(x) should be: x
x=#"Hello World"
# $(x) should be: 11
x=#"Hello World"[2:8]
# $(x) should be: 6
x=#Hello World
# $(x) should be: #Hello World
x=1 ? "true" : "false"
# $(x) should be: true
require-ess/tools/README.md deleted 100644 → 0
View file @ 73bbc073
iocsh.bash
====
## E3 Unique Variables
```
E3_CMD_TOP : the absolute path where a startup script (cmd file) is
E3_IOCSH_TOP : the absolute path where the iocsh.bash is executed
```
For example, one executes the iocsh.bash ```${HOME}``` to call ```e3_local/cmds``` via
```sh
$ iocsh.bash e3_local/cmds/iocStats.cmd
```
In this case,
```E3_CMD_TOP``` is defined as ```"${HOME}/e3_local/cmds"```
```E3_IOCSH_TOP``` is defined as ```"${HOME}"```
require-ess/tools/setE3Env.bash → require-ess/tools/activate
View file @ 4560be22
......@@ -16,7 +16,6 @@
# You should have received a copy of the GNU General Public License along with
# this program. If not, see https://www.gnu.org/licenses/gpl-2.0.txt
#
# Shell : setE3Env.bash
# Author : Jeong Han Lee
# email : jeonghan.lee@gmail.com
# date : Friday, November 8 22:48:29 CET 2019
......@@ -220,7 +219,7 @@ LD_LIBRARY_PATH=$(set_variable "${old_ld_path}" "${E3_LD_LIBRARY_PATH}")
export LD_LIBRARY_PATH
# Add iocsh.bash autocompletion
# Add iocsh autocompletion
# shellcheck source=require-ess/tools/iocsh_complete.bash
source "${SRC_PATH}"/iocsh_complete.bash
......