#pragma prototyped
#include "jcl.h"
#include <tm.h>
static const char usage[] =
"[-?\n@(#)$Id: jcl (AT&T Research) 2006-11-11 $\n]"
USAGE_LICENSE
"[+NAME?jcl - jcl deck interpreter]"
"[+DESCRIPTION?\bjcl\b interprets the JCL decks named by the \afile\a"
" operands. The standard input is read if no \afile\a operands"
" are specified. If \b--map\b is not specified then"
" \b--map=" JCL_MAPFILE "\b is assumed. The \aname\a=\avalue\a"
" operands override any values specified JCL decks.]"
"[+?control-M scheduler auto edit variable \b%%\b\aname\a values"
" may be initialized by exporting \b" JCL_AUTO "\b\aname\a=\avalue\a"
" or by \b%%\b\aname\a=\avalue\a on the command line.]"
"[d:debug?Set the debug trace level. Higher levels produce more"
" output.]#[level]"
"[g:global?Like \b--map\b=\afile\a except that the default "
JCL_MAPFILE ", if it exists, is still read after the command"
" line options are processed.]:[file]"
"[i:import?Environment variable definitions take precedence over"
" corresponding \b--map\b file definitions.]"
"[I:include?Search \adirectory\a for DSN names. More than one"
" \b--include\b option may be specified.]:[directory]"
"[k:marklength?Mark fixed length record file names by appending"
" \b%\b\alrecl\a to the names.]"
"[l:list?List all referenced \aitem\as. Only the last \b--list\b"
" \aitem\a is listed. \aitem\a may be:]:[item]{"
" [a:autoedit?List the %%\aname\a autoedit variables.]"
" [c:count?List the \aitem\a dup counts too.]"
" [e:exec?List the EXEC job and command names.]"
" [i:inputs?List the DD input data file paths.]"
" [o:outputs?List the DD output data file paths.]"
" [p:programs?List the EXEC PGM=\aprogram\a program names.]"
" [s:scripts?List the EXEC [PROC=]]\ascript\a script names.]"
" [v:variables?List the &\aname\a variables.]"
"}"
"[m:map?Read the dataset file path prefix map \afile\a. Each line in \afile\a"
" contains an operation followed by 0 or more space separated fields."
" \b#\b in the first column denotes a comment; comments and blank lines"
" are ignored. If \afile\a is \b-\b then \b/dev/null\b is assumed."
" If \afile\a is not found and contains no \b/\b then"
" \b../lib/jcl/\b\afile\a is searched for on \b$PATH\b. If no \b--map\b"
" option is specified then the default " JCL_MAPFILE ", if it exists,"
" is read after the command line options are processed. The operations"
" are:]:[file]{"
" [+export \aname\a=\avalue ...?Set export variable values."
" Export variable expansions are preserved in the"
" generated scripts.]"
" [+map \aprefix\a \amap\a [\asuffix\a]]?Dataset paths are"
" mapped by doing a longest prefix match on the"
" prefixes. The matching dataset prefix is replaced"
" by \amap\a, and \asuffix\a, if specified, is"
" appended. The prefix \b\"\"\b matches when no other"
" prefix matches. Leading \b*.\b and trailing \b.*\b"
" match any \b.\b-separated component. \b${\b\an\a\b}\b"
" in \amap\a expands to the component matched by the"
" \an\a-th \b*\b in \aprefix\a, counting from 1, left"
" to right.]"
" [+set --[no]]\aoption\a[=\avalue]] ...?Set command line options.]"
" [+set %%\aname\a=\avalue ...?Set auto edit variable values.]"
" [+set \aname\a=\avalue ...?Set variable values.]"
" }"
"[n!:exec?Enable command execution. \b--noexec\b disables.]"
"[N:never?Disable all command and recursive script execution.]"
"[p:parameterize?Parameterize simple &\aname\a variable references by"
" substituting the \bsh\b(1) equivalent ${\aname\a}.]"
"[r:resolve?Resolve each operand as a path name using the \b--map\b files"
" and print the resulting path on the standard output, one path per line.]"
"[s:subdir?Execute each job in a separate subdirectory named"
" \ajobname\a.\ayy-mm-dd.n\a]]. \an\a starts at \b1\b and"
" is incremeted by \b1\b for each run of \ajobname\a within"
" the same day.]"
"[v:verbose?For \b--noexec\b the equivalent \bsh\b(1) script is listed"
" on the standard output. For \b--exec\b verbose execution output,"
" like start and completion times, is enabled.]"
"[w:warn?Enable verbose warning messages.]"
"[x:trace?Enable command execution trace.]"
"[O:odate?Set the control-M original date to \adate\a.]:[date:=now]"
"[R:rdate?Set the control-M current run date to \adate\a.]:[date:=now]"
"[S:date?Set the control-M system date to \adate\a.]:[date:=now]"
"\n"
"\n[ name=value ... ] [ file ... ]\n"
"\n"
"[+FILES]{"
" [+../lib/jcl/prefix?Default \b--map\b file, found on \b$PATH\b.]"
"}"
"[+SEE ALSO?\bsh\b(1)]"
;
#include <tm.h>
struct Map_s; typedef struct Map_s Map_t;
struct Map_s
{
Map_t* next;
char* arg;
int map;
};
typedef struct State_s
{
Jcldisc_t disc;
int resolve;
Map_t* map;
Map_t* lastmap;
} State_t;
static int
optset(Jcl_t* jcl, int c, Jcldisc_t* disc)
{
State_t* state = (State_t*)disc;
unsigned long f;
char* s;
time_t* t;
Map_t* p;
switch (c)
{
case 'd':
error_info.trace = -opt_info.number;
return 1;
case 'g':
case 'm':
if (!(p = newof(0, Map_t, 1, 0)))
{
error(ERROR_SYSTEM|2, "out of space");
return 0;
}
p->arg = opt_info.arg;
p->map = c == 'm';
if (!state->map)
state->map = p;
else
state->lastmap->next = p;
state->lastmap = p;
return 1;
case 'i':
f = JCL_IMPORT;
break;
case 'I':
jclinclude(NiL, opt_info.arg, JCL_JOB|JCL_PROC, disc);
return 1;
case 'k':
f = JCL_MARKLENGTH;
break;
case 'l':
switch (opt_info.num)
{
case 'a':
jcl->flags |= JCL_LISTAUTOEDITS;
break;
case 'c':
jcl->flags |= JCL_LISTCOUNTS;
break;
case 'e':
jcl->flags |= JCL_LISTEXEC;
break;
case 'i':
jcl->flags |= JCL_LISTINPUTS;
break;
case 'o':
jcl->flags |= JCL_LISTOUTPUTS;
break;
case 'p':
jcl->flags |= JCL_LISTPROGRAMS;
break;
case 's':
jcl->flags |= JCL_LISTSCRIPTS;
break;
case 'v':
jcl->flags |= JCL_LISTVARIABLES;
break;
}
return 1;
case 'n':
jcl->roflags |= JCL_EXEC;
if (!opt_info.number)
jcl->flags &= ~JCL_EXEC;
return 1;
case 'N':
jcl->roflags |= JCL_RECURSE;
if (!opt_info.number)
jcl->flags &= ~JCL_RECURSE;
return 1;
case 'O':
t = &jcl->disc->odate;
date:
*t = tmdate(opt_info.arg, &s, NiL);
if (*s)
{
error(2, "%s: %s: invalid date", opt_info.name, opt_info.arg);
return 0;
}
return 1;
case 'p':
f = JCL_PARAMETERIZE;
break;
case 'r':
((State_t*)disc)->resolve = !!opt_info.number;
return 1;
case 'R':
t = &jcl->disc->rdate;
goto date;
case 's':
f = JCL_SUBDIR;
break;
case 'S':
t = &jcl->disc->date;
goto date;
case 'v':
f = JCL_VERBOSE;
break;
case 'w':
f = JCL_WARN;
break;
case 'x':
f = JCL_TRACE;
break;
case ':':
error(2, "%s", opt_info.arg);
return 0;
case '?':
error(ERROR_USAGE|4, "%s", opt_info.arg);
return 0;
}
if ((jcl->roflags & (JCL_MAPPED|f)) != (JCL_MAPPED|f))
{
if (!(jcl->roflags & JCL_MAPPED))
jcl->roflags |= f;
if (opt_info.number)
jcl->flags |= f;
else
jcl->flags &= ~f;
}
return 1;
}
int
main(int argc, char** argv)
{
char* s;
char* t;
Jcl_t* jcl;
Map_t* p;
int c;
State_t state;
error_info.id = "jcl";
memset(&state, 0, sizeof(state));
jclinit(&state.disc, errorf);
state.disc.usage = usage;
state.disc.optsetf = optset;
if (jcl = jclopen(NiL, NiL, JCL_EXEC|JCL_JOB|JCL_RECURSE|JCL_STANDARD|JCL_SCOPE, &state.disc))
{
while ((c = optget(argv, usage)) && optset(jcl, c, &state.disc));
argv += opt_info.index;
if (error_info.errors)
error(ERROR_USAGE|4, "%s", optusage(NiL));
while (jclsym(jcl, *argv, NiL, JCL_SYM_READONLY))
argv++;
c = 0;
while (p = state.map)
{
state.map = state.map->next;
if (jclmap(jcl, p->arg, &state.disc))
return 1;
c |= p->map;
free(p);
}
if (!c && jclmap(jcl, NiL, &state.disc))
return 1;
if (state.resolve)
{
while (s = *argv++)
if (t = jclpath(jcl, s))
sfprintf(sfstdout, "%s\n", t);
else
error(2, "%s: cannot resolve", s);
}
else
{
jcl->step->command = *argv;
while (!jclrun(jcl) && jcl->step->command && (jcl->step->command = *++argv));
}
}
if (!(c = jclclose(jcl)) && error_info.errors)
c = 1;
return c;
}
