#pragma prototyped

static const char usage[] =

"lines in \afile\a. \afile\a may contain # style comments.]:[file]"

"\aindex\a-1 conditions suffixed by \b-%02d\b from 1 through "

"\aindex\a-1.]#[index]"

;

#include <ast.h>

#include <cdt.h>

#include <ccode.h>

#include <ctype.h>

#include <error.h>

#include <jcl.h>

#include <vmalloc.h>

#define CARD 80

#define circular(p) (strneq((p)->value, "$(", 2) && strneq((p)->value + 2, JCL_AUTO, sizeof(JCL_AUTO) - 1) && strneq((p)->value + sizeof(JCL_AUTO) + 1, (p)->name, strlen((p)->name)) && streq((p)->value + sizeof(JCL_AUTO) + strlen((p)->name) + 1, ")"))

struct Jcmcard_s; typedef struct Jcmcard_s Jcmcard_t;

struct Jcmevent_s; typedef struct Jcmevent_s Jcmevent_t;

struct Jcmjob_s; typedef struct Jcmjob_s Jcmjob_t;

struct Jcmlib_s; typedef struct Jcmlib_s Jcmlib_t;

struct Jcmlist_s; typedef struct Jcmlist_s Jcmlist_t;

struct Jcmset_s; typedef struct Jcmset_s Jcmset_t;

struct Jcmshout_s; typedef struct Jcmshout_s Jcmshout_t;

struct Jcmvar_s; typedef struct Jcmvar_s Jcmvar_t;

struct Jcmcard_s

{

Jcmcard_t* next;

char data[1];

};

struct Jcmvar_s

{

Dtlink_t link;

unsigned long dup;

int init;

char* value;

char name[64];

};

struct Jcmlib_s

{

Dtlink_t link;

Jcmvar_t* var;

char name[64];

};

struct Jcmset_s

{

Dtlink_t link;

Jcmset_t* next;

char* value;

char name[1];

};

struct Jcmshout_s

{

Jcmshout_t* next;

int when;

int pri;

char data[17];

char to[17];

char text[71];

};

struct Jcmjob_s

{

Jcmlib_t* memlib;

Jcmlib_t* overlib;

Jcmlib_t* doclib;

Jcmset_t* set;

Jcmshout_t* shout;

int namelen;

int relationship;

char* docmem;

char* name;

char* tag;

char base[1];

};

struct Jcmlist_s

{

Jcmlist_t* next;

Jcmevent_t* event;

};

struct Jcmevent_s

{

Dtlink_t link;

unsigned long dup;

int mark;

char date[5];

Jcmlist_t* reqs;

Jcmlist_t* deps;

Jcmjob_t* job;

char name[1];

};

static struct State_s

{

Vmalloc_t* vm;

Dt_t* events;

Dt_t* libs;

Dt_t* set;

Dt_t* vars;

Dtdisc_t eventdisc;

Dtdisc_t libdisc;

Dtdisc_t setdisc;

Dtdisc_t vardisc;

char* data;

char* last;

Jcmlib_t* dummy;

Jcmevent_t* all;

Sfio_t* tmp;

unsigned long pseudo;

unsigned long test;

int cards;

int comment;

int index;

int lowercase;

int portable;

int verbose;

} state;

static void

nospace(void)

{

error(ERROR_SYSTEM|3, "out of space");

}

static char*

stash(const char* s)

{

char* r;

if (!(r = strdup(s)))

nospace();

return r;

}

static void

lower(register char* s)

{

for (; *s; s++)

if (isupper(*s))

*s = tolower(*s);

}

static void

upper(register char* s)

{

for (; *s; s++)

if (islower(*s))

*s = toupper(*s);

}

static char*

copy(register char* t, register const char* s, size_t n)

{

register const char* e = s + n;

while (s < e && *s && *s != ' ')

*t++ = *s++;

*t = 0;

return t;

}

static char*

card(Sfio_t* sp, register unsigned char* map)

{

register char* s;

register char* t;

register int c;

register int o;

size_t z;

size_t n;

size_t m;

s = state.data;

z = CARD;

for (;;)

{

if (s >= state.last)

{

n = s - state.data;

m = (state.last - state.data) + 32 * CARD;

if (!(state.data = newof(state.data, char, m, 0)))

nospace();

state.last = state.data + m - CARD - 1;

s = state.data + n;

}

if (sfread(sp, s, z) != z)

break;

error_info.line++;

if (s == state.data)

o = *(unsigned char*)s;

ccmapstr(map, s, z);

for (t = s, s += z; s > t && (*(s - 1) == ' ' || *(s - 1) == 0 || !isprint(*(s - 1))); s--);

if ((c = sfgetc(sp)) == EOF)

break;

if (c != o)

{

sfungetc(sp, c);

break;

}

if (ccmapchr(map, c) == 'T')

{

if ((c = sfgetc(sp)) == EOF)

{

sfungetc(sp, o);

break;

}

if (ccmapchr(map, c) == '%')

{

sfungetc(sp, c);

sfungetc(sp, o);

break;

}

}

z = CARD - 1;

}

if (s == state.data)

return 0;

*s = 0;

while (s > state.data)

if (!*--s)

*s = ' ';

return state.data;

}

static const char*

prefix(const char* s, const char* e, int d)

{

register Jcmvar_t* v;

register int n;

Jcmvar_t var;

n = (e ? (e - s) : strlen(s)) + 1;

if (n >= sizeof(var.name))

n = sizeof(var.name);

strlcpy(var.name, s, n);

if (!(v = (Jcmvar_t*)dtprev(state.vars, &var)))

v = (Jcmvar_t*)dtsearch(state.vars, &var);

if (*v->name != *s)

v = (Jcmvar_t*)dtnext(state.vars, v);

for (; v && *v->name == *s; v = (Jcmvar_t*)dtnext(state.vars, v))

{

n = strlen(v->name);

if (strneq(s, v->name, n))

return s + n;

}

while (s < e && *s != d && isalnum(*s))

s++;

return s;

}

static char*

parameterize(register Sfio_t* sp, register const char* s, register const char* e, int append, int index)

{

register int c;

register int d;

register const char* t;

if (e)

d = ' ';

else

{

e = s + strlen(s);

d = 0;

}

while (s < e && (c = *s++) != d)

{

if (c == '~' && s < e && *s != d)

{

sfputr(sp, "$(" JCL_AUTO, -1);

switch (c = *s++)

{

case '#':

sfputr(sp, "pound", -1);

break;

case '@':

sfputr(sp, "at", -1);

break;

case '&':

sfputr(sp, "and", -1);

break;

case '!':

sfputr(sp, "bang", -1);

break;

default:

if (isalnum(c) && (t = prefix(s - 1, e, d)))

{

sfwrite(sp, s - 1, t - s + 1);

s = t;

}

else

sfprintf(sp, "special_%02x", c);

break;

}

c = ')';

}

else if (c == '%' && s < e && *s == c)

{

sfputr(sp, "$(" JCL_AUTO, -1);

for (s++; s < e && (c = *s) != d && (isalnum(c) || c == '$' && (c = '_')); s++)

sfputc(sp, c);

c = ')';

}

else if (state.portable && (c == '#' || c == '$' || c == ':'))

c = '_';

sfputc(sp, c);

}

if (index)

sfprintf(sp, "-%02d", index);

if (append)

{

if (sfputc(sp, 0) < 0)

nospace();

sfstrseek(sp, -1, SEEK_CUR);

return sfstrbase(sp);

}

if (!(s = (const char*)sfstruse(sp)))

nospace();

return (char*)s;

}

static Jcmevent_t*

getevent(const char* s, const char* d, int uniq, int string, int index)

{

register Jcmevent_t* event;

if (s)

{

s = (const char*)parameterize(state.tmp, s, string ? (const char*)0 : s + 20, 1, index);

if (event = (Jcmevent_t*)dtmatch(state.events, s))

{

if (!uniq)

{

sfstrseek(state.tmp, 0, SEEK_SET);

return event;

}

sfprintf(state.tmp, "{%lu}", ++event->dup);

}

}

else

sfprintf(state.tmp, "{%lu}", ++state.pseudo);

if (!(s = (const char*)sfstruse(state.tmp)) || !(event = newof(0, Jcmevent_t, 1, strlen(s))))

nospace();

strcpy(event->name, s);

dtinsert(state.events, event);

if (d)

copy(event->date, d, 4);

return event;

}

static Jcmjob_t*

getjob(const char* s)

{

register Jcmjob_t* job;

s = (const char*)parameterize(state.tmp, s, s + 8, 0, 0);

if (!(job = newof(0, Jcmjob_t, 1, strlen(s))))

nospace();

strcpy(job->base, s);

if (state.lowercase)

lower(job->base);

job->name = stash(parameterize(state.tmp, s, s + 27, 0, 0));

if (state.lowercase)

lower(job->name);

return job;

}

static Jcmvar_t*

setvar(const char* s, const char* v, int init)

{

register Jcmvar_t* var;

if (var = (Jcmvar_t*)dtmatch(state.vars, s))

{

if (!v || !init && var->init)

return var;

free(var->value);

}

else

{

if (!(var = newof(0, Jcmvar_t, 1, 0)))

nospace();

var->dup = 1;

strcpy(var->name, s);

dtinsert(state.vars, var);

}

var->init = init;

var->value = stash(v ? v : "");

return var;

}

static Jcmlib_t*

getlib(const char* s)

{

register Jcmlib_t* lib;

register Jcmvar_t* var;

register char* t;

char name[64];

copy(name, s, 44);

if (!*name)

return 0;

if (state.lowercase)

lower(name);

if (!(lib = (Jcmlib_t*)dtmatch(state.libs, name)))

{

if (!(lib = newof(0, Jcmlib_t, 1, 0)))

nospace();

strcpy(lib->name, name);

dtinsert(state.libs, lib);

if (!(t = strchr(lib->name, '%')) || *++t != '%')

{

if (!(t = strrchr(lib->name, '.')) || !*++t)

t = lib->name;

sfsprintf(name, sizeof(name), "lib_%s", t);

if (state.lowercase)

upper(name);

if (var = (Jcmvar_t*)dtmatch(state.vars, name))

do

{

sfsprintf(name, sizeof(name), "lib_%s_%lu", t, ++var->dup);

if (state.lowercase)

upper(name);

} while (dtmatch(state.vars, name));

lib->var = setvar(name, lib->name, 0);

}

}

return lib;

}

static Jcmlist_t*

append(Jcmlist_t* list, Jcmevent_t* event)

{

register Jcmlist_t* p;

register Jcmlist_t* q;

for (p = list; p; p = p->next)

{

if (p->event == event)

return list;

if (!p->next)

break;

}

if (!(q = newof(0, Jcmlist_t, 1, 0)))

nospace();

q->event = event;

if (p)

{

p->next = q;

return list;

}

return q;

}

static void

assert(register Jcmjob_t* job, register Jcmlist_t* reqs, register Jcmlist_t* deps, Jcmevent_t* group)

{

register Jcmevent_t* event;

event = getevent(job ? sfprints("JOB-%s", job->name) : NiL, NiL, 1, 1, 0);

event->job = job;

event->reqs = reqs;

event->deps = deps;

if (group)

group->reqs = append(group->reqs, event);

}

static int

init(const char* path)

{

register char* s;

register char* t;

register char* e;

register int i;

Sfio_t* sp;

char* file;

size_t line;

if (!(sp = sfopen(NiL, path, "r")))

{

error(ERROR_SYSTEM|2, "%s: cannot read initialization file", path);

return -1;

}

file = error_info.file;

error_info.file = (char*)path;

line = error_info.line;

error_info.line = 0;

while (s = sfgetr(sp, '\n', 1))

{

error_info.line++;

e = s + sfvalue(sp) - 1;

while (isspace(*s))

s++;

if (!*s || *s == '#')

continue;

i = 0;

for (t = s; *s; s++)

if (*s == '=')

{

i = 1;

*s++ = 0;

break;

}

else if (isspace(*s) && !i)

{

i = -1;

*s = 0;

}

if (i > 0 && isalpha(*t))

{

while (isspace(*s))

s++;

while (e > s && isspace(*(e - 1)))

e--;

*e = 0;

if (strneq(t, JCL_AUTO, sizeof(JCL_AUTO) - 1))

t += sizeof(JCL_AUTO) - 1;

if (*t)

setvar(t, s, 1);

}

else

error(1, "invalid initialization line ignored: %s", t);

}

sfclose(sp);

error_info.file = file;

error_info.line = line;

return 0;

}

static void

dump(Sfio_t* sp, register Jcmevent_t* event)

{

register Jcmlist_t* p;

register Jcmset_t* v;

event->mark = 1;

sfprintf(sp, "%s : .VIRTUAL", event->name);

if (event->job)

{

if (event->job->overlib && streq(event->job->overlib->name, "DUMMY"))

{

sfprintf(sp, " .DO.NOTHING");

for (p = event->reqs; p; p = p->next)

sfprintf(sp, " %s", p->event->name);

}

else

{

sfprintf(sp, " .JOB");

for (v = event->job->set; v; v = v->next)

if (v->value)

sfprintf(sp, " %s%s=%s", JCL_AUTO, v->name, fmtquote(v->value, "$'", "'", strlen(v->value), 0));

else

sfprintf(sp, " (%s%s)", JCL_AUTO, v->name);

for (p = event->reqs; p; p = p->next)

sfprintf(sp, " %s", p->event->name);

sfprintf(sp, " %s", event->job->base);

}

}

else if (!event->reqs)

sfprintf(sp, " .EVENT.WAIT");

else

for (p = event->reqs; p; p = p->next)

sfprintf(sp, " %s", p->event->name);

if (event->deps)

for (p = event->deps; p; p = p->next)

sfprintf(sp, " %s.RAISE", p->event->name);

sfprintf(sp, "\n");

if (event->deps)

{

for (p = event->deps; p; p = p->next)

sfprintf(sp, "%s.RAISE ", p->event->name);

sfprintf(sp, ": .AFTER .EVENT.RAISE\n");

}

for (p = event->reqs; p; p = p->next)

if (!p->event->mark)

dump(sp, p->event);

}

main(int argc, char** argv)

{

register char* file;

register char* s;

register char* t;

register Jcmcard_t* cp;

register Jcmevent_t* appl;

register Jcmevent_t* base;

register Jcmevent_t* group;

register Jcmjob_t* job;

register Jcmlist_t* deps;

register Jcmlist_t* reqs;

Jcmcard_t* firstcard;

Jcmcard_t* lastcard;

Jcmset_t* set;

Jcmset_t* lastset;

Jcmset_t* global;

Jcmshout_t* shout;

Jcmshout_t* lastshout;

Jcmvar_t* var;

unsigned char* map;

Sfio_t* sp;

int n;

int index;

error_info.id = "jcm";

if (!(state.vm = vmopen(Vmdcheap, Vmlast, 0)) || !(state.tmp = sfstropen()))

nospace();

state.eventdisc.link = offsetof(Jcmevent_t, link);

state.eventdisc.key = offsetof(Jcmevent_t, name);

state.libdisc.link = offsetof(Jcmlib_t, link);

state.libdisc.key = offsetof(Jcmlib_t, name);

state.setdisc.link = offsetof(Jcmset_t, link);

state.setdisc.key = offsetof(Jcmset_t, name);

state.vardisc.link = offsetof(Jcmvar_t, link);

state.vardisc.key = offsetof(Jcmvar_t, name);

if (!(state.events = dtopen(&state.eventdisc, Dtoset)) ||

!(state.libs = dtopen(&state.libdisc, Dtoset)) ||

!(state.set = dtopen(&state.setdisc, Dtoset)) ||

!(state.vars = dtopen(&state.vardisc, Dtoset)))

nospace();

index = 0;

for (;;)

{

switch (optget(argv, usage))

{

case 'c':

state.cards = opt_info.number;

continue;

case 'd':

error_info.trace = -opt_info.number;

continue;

case 'h':

state.comment = 1;

continue;

case 'i':

if (init(opt_info.arg))

return 1;

continue;

case 'I':

index = opt_info.number;

continue;

case 'l':

state.lowercase = opt_info.number;

continue;

case 'p':

state.portable = opt_info.number;

continue;

case 'v':

state.verbose = opt_info.number;

continue;

case 'T':

state.test |= opt_info.number;

continue;

case ':':

error(2, "%s", opt_info.arg);

break;

case '?':

error(ERROR_USAGE|4, "%s", opt_info.arg);

break;

}

break;

}

argv += opt_info.index;

if (error_info.errors)

error(ERROR_USAGE, "%s", optusage(NiL));

state.dummy = getlib("DUMMY");

state.all = getevent("all", NiL, 0, 1, 0);

file = *argv;

if (!state.cards)

{

sfprintf(sfstdout, ":JCL:\n\n");

n = 0;

for (var = (Jcmvar_t*)dtfirst(state.vars); var; var = (Jcmvar_t*)dtnext(state.vars, var))

if (var->init)

{

sfprintf(sfstdout, "%s%s == %s\n", JCL_AUTO, var->name, var->value);

n = 1;

}

if (n)

sfprintf(sfstdout, "\n");

}

do

{

if (!file)

sp = sfstdin;

else if (!(sp = sfopen(NiL, file, "r")))

{

error(ERROR_SYSTEM|2, "%s: cannot read", file);

continue;

}

else if (state.cards || state.verbose)

sfprintf(sfstdout, "=== %s ===\n", file);

n = sfgetc(sp);

sfungetc(sp, n);

map = isupper(n) ? (unsigned char*)0 : ccmap(CC_EBCDIC_O, CC_NATIVE);

error_info.file = file;

error_info.line = 0;

vmclear(state.vm);

firstcard = lastcard = 0;

while (s = card(sp, map))

{

if (state.cards || state.verbose)

{

sfprintf(sfstdout, "%s\n", s);

if (state.cards)

continue;

}

if (*s == 'T' && (t = strchr(s + 3, '=')) && *++t == '~')

setvar(t + 1, NiL, 0);

if (!(cp = vmnewof(state.vm, 0, Jcmcard_t, 1, strlen(s))))

nospace();

strcpy(cp->data, s);

if (lastcard)

lastcard = lastcard->next = cp;

else

lastcard = firstcard = cp;

}

if (cp = firstcard)

{

appl = base = group = 0;

job = 0;

deps = reqs = 0;

cp = firstcard;

do

{

s = cp->data;

if (state.cards || state.verbose)

{

sfprintf(sfstdout, "%s\n", s);

if (state.cards)

continue;

}

switch (s[0])

{

case 'B':

/* XXX: unknown per-job sparse */

break;

case 'C':

/* XXX: event control */

break;

case 'D':

case 'J':

case 'K':

case 'W':

/* XXX: cron info */

break;

case 'E':

/* XXX: event relationships */

break;

case 'G':

/* XXX: group info */

break;

case 'H':

if (state.comment)

sfprintf(sfstdout, "# %s\n\n", parameterize(state.tmp, s+1, NiL, 0, 0));

break;

case 'I':

if (job)

{

if (index)

{

s++;

for (n = 0; n < index; n++)

reqs = append(reqs, getevent(s, s+20, 0, 0, n));

s += 23;

}

for (s++; *s; s += 24)

reqs = append(reqs, getevent(s, s+20, 0, 0, 0));

}

break;

case 'L':

if (job)

job->memlib = getlib(s+1);

break;

case 'M':

if (job || deps || reqs)

assert(job, reqs, deps, group);

deps = reqs = 0;

appl = getevent(s+9, 0, 0, 0, 0);

state.all->reqs = append(state.all->reqs, appl);

if (s[60] == 'G')

{

base = appl;

group = getevent(s+1, NiL, 1, 0, 0);

appl->reqs = append(appl->reqs, group);

job = 0;

}

else

{

group = appl;

job = getjob(s+1);

job->relationship = s[64];

if (base && base != appl)

appl->reqs = append(appl->reqs, base);

}

break;

case 'N':

if (job)

job->tag = stash(parameterize(state.tmp, s+1, s+21, 0, 0));

break;

case 'O':

if (job)

{

if (*(s + 4) == '-')

{

job->name = stash(parameterize(state.tmp, s+5, s+13, 0, 0));

if (t = strchr(job->name, '-'))

*t = 0;

if (state.lowercase)

lower(job->name);

}

for (s++; *s; s += 25)

if ((state.test & 0x0010) || s[24] != '-')

deps = append(deps, getevent(s, s+20, 0, 0, 0));

}

break;

case 'Q':

if (state.verbose)

for (s++; *s; s += 24)

sfprintf(sfstdout, "Q='%-20.20s'\n", s);

break;

case 'R':

/* XXX: unknown per-job sparse */

break;

case 'S':

if (job)

{

if (lastshout = job->shout)

while (lastshout->next)

lastshout = lastshout->next;

s++;

while (*s)

{

if (!(shout = newof(0, Jcmshout_t, 1, 0)))

nospace();

if (lastshout)

lastshout->next = shout;

else

job->shout = shout;

lastshout = shout;

shout->when = *s++;

for (t = shout->data; !isalpha(*s); s++)

if (t < &shout->data[sizeof(shout->data)-1])

*t++ = *s;

*t = 0;

for (s += (copy(shout->to, s, 16) - shout->to); *s == ' '; s++);

shout->pri = *s++;

n = 0;

while (*s >= '0' && *s <= '9')

n = n * 10 + (*s++ - '0');

if (n >= sizeof(shout->text))

n = sizeof(shout->text) - 1;

memcpy(shout->text, s, n);

s += n;

}

}

break;

case 'T':

if (job)

{

s = parameterize(state.tmp, s + 3, NiL, 0, 0);

n = strlen(s) + 2;

if (!(set = newof(0, Jcmset_t, 1, n)))

nospace();

strcpy(set->name, s);

if (s = strchr(set->name, '='))

{

*s++ = 0;

set->value = s;

}

else

set->value = "";

var = (Jcmvar_t*)dtmatch(state.vars, set->name);

if ((!(var = (Jcmvar_t*)dtmatch(state.vars, set->name)) || !var->init) && (!(global = (Jcmset_t*)dtmatch(state.set, set->name)) || streq(global->value, set->value) || circular(set)))

{

if (!global)

{

if (!state.cards)

sfprintf(sfstdout, "%s%s == %s\n", JCL_AUTO, set->name, circular(set) ? "1" : set->value);

dtinsert(state.set, global = set);

if (!(set = newof(0, Jcmset_t, 1, n)))

nospace();

memcpy(set, global, sizeof(Jcmset_t) + n);

}

set->value = 0;

}

if (lastset = job->set)

{

while (lastset->next)

lastset = lastset->next;

lastset->next = set;

}

else

job->set = set;

}

break;

case 'V':

if (job)

job->overlib = getlib(s+1);

break;

case 'Z':

if (job)

{

job->docmem = stash(parameterize(state.tmp, s+1, s+9, 0, 0));

job->doclib = getlib(s+9);

}

break;

default:

error(1, "%c: unknown op", s[0]);

break;

}

} while (cp = cp->next);

if (job || deps || reqs)

assert(job, reqs, deps, group);

}

if (sp != sfstdin)

sfclose(sp);

error_info.file = 0;

error_info.line = 0;

} while (file && (file = *++argv));

if (!state.cards)

{

sfprintf(sfstdout, "\n");

dump(sfstdout, state.all);

}

return error_info.errors != 0;

}