#if _PACKAGE_ast

#define UNZIP ((char*)0)

#define DISABLED ((char*)disabled)

#define DFLTZIP "delta,huffgroup"

#define ALIASES "lib/vcodex/aliases"

#define VCZIPRC ".vcziprc"

#define VCZIP "vczip"

static const char usage[] =

"and/or encodes the standard output. The \b--method\b option specifies "

"the encoding. The default encoding is \b--method=" DFLTZIP "\b. The "

"method is automatically determined when decoding.]"

"file to delta against. If \asource\a is omitted then the input file is "

"simply compressed. Delta-encoded data must be decoded with the same "

"\asource\a.]"

"[+?Method aliases may be defined in \b../" ALIASES "\b in one of the "

"directories on \b$PATH\b, or in \b$HOME/" VCZIPRC "\b, searched in "

"order. Each alias is a \aname=value\a pair where \avalue\a is a "

"\b--method\b option value, described below. Method names are searched "

"before alias names.]"

"input.]:[file]"

"separated list of \amethod\a[.\aarg\a]] elements, where \amethod\a is "

"a method alias or primitive method, \aarg\a is an optional method "

"specific argument, and \b-\b denotes the default argument. Parenthesized "

"values are implementation details. The \alibvcodex\a (\b-catalog\b) "

"denotes a method supplied by the default library. Otherwise the method "

"is a separate plugin; that plugin will be required to decode any "

"encoded data. The primitive methods and method aliases "

"are:]:[method[.arg]][,method[.arg]]...]]:=" DFLTZIP "]"

"{\fvcodex\f[vcdiff|ietf?Encode as defined in IETF RFC3284.]}"

"output.]:[file]"

"the transform must be explicitly supplied to decode.]"

"\b--method\b transformation string on the standard output. "

"If the standard input is not vczip encoded then nothing is "

"printed.]"

"\bvcodex\b(3) transform. A codex transform is a catenation of the "

"following methods, each method prefixed by \b<\b to decode the input or "

"\b>\b to encode the output. Method arguments, if any, must be prefixed "

"by \b-\b. The method are:]:[[<>]]method[-arg...]]...]"

"{\fcodex\f}"

"\amethod\a specifies an optional window matching "

"method. The window methods are:]:[window[,method]]]"

"{\fwindows\f}"

"--method=ietf.]"

"more output.]:[level]"

"{"

"[+../" ALIASES "?\b--method\b \aname=value\a alias file, found "

"on \b$PATH\b.]"

"}"

;

#include <ast.h>

#include <error.h>

#include <ccode.h>

#include <ctype.h>

#include <vcodex.h>

#include <codex.h>

static const char disabled[] = "disabled";

static int

optmethod(Void_t* obj, char* name, char* desc, Void_t* handle)

{

Sfio_t* sp = (Sfio_t*)handle;

Vcmethod_t* mt = (Vcmethod_t*)obj;

int i;

sfprintf(sp, "[+%s?", name);

optesc(sp, desc, 0);

if(mt->args)

{ sfprintf(sp, " The arguments are:]{");

for(i = 0; mt->args[i].desc; i++)

{ sfprintf(sp, "[+%s?", mt->args[i].name ? mt->args[i].name : "-");

if(mt->args[i].desc)

optesc(sp, mt->args[i].desc, 0);

sfputc(sp, ']');

if(!mt->args[i].name)

break;

}

}

else

sfputc(sp, ']');

if(mt->about)

{ if(!mt->args)

sfputc(sp, '{');

sfprintf(sp, "%s}", mt->about);

}

else if(mt->args)

sfputc(sp, '}');

return 0;

}

static int

optalias(Void_t* obj, char* name, char* desc, Void_t* handle)

{

Sfio_t* sp = (Sfio_t*)handle;

sfprintf(sp, "[+%s?Equivalent to \b%s\b.]", name, desc);

return 0;

}

static int

optwindow(Void_t* obj, char* name, char* desc, Void_t* handle)

{

Sfio_t* sp = (Sfio_t*)handle;

sfprintf(sp, "[+%s?", name);

optesc(sp, desc, 0);

sfprintf(sp, "]");

return 0;

}

static int

optinfo(Opt_t* op, Sfio_t* sp, const char* s, Optdisc_t* dp)

{

register Codexmeth_t* meth;

register const char* p;

register int c;

switch (*s)

{

case 'c':

/* codex methods */

for (meth = codexlist(NiL); meth; meth = codexlist(meth))

{

sfprintf(sp, "[+%s\b", meth->name);

p = " (";

if (meth->identf)

{

sfprintf(sp, "%sident", p);

p = ",";

}

if (!(meth->flags & CODEX_ENCODE))

{

sfprintf(sp, "%sdecode", p);

p = ",";

}

if (*p == ',')

sfputc(sp, ')');

sfputc(sp, '?');

p = meth->description;

while (c = *p++)

{

if (c == ']')

sfputc(sp, c);

sfputc(sp, c);

}

sfputc(sp, ']');

if ((p = meth->options) || meth->optionsf)

{

sfprintf(sp, "{\n");

if (meth->optionsf)

(*meth->optionsf)(meth, sp);

if (p)

sfprintf(sp, "%s", p);

sfprintf(sp, "\n}");

}

}

break;

case 'v':

/* vcodex methods */

vcwalkmeth(optmethod, sp);

/* aliases */

vcwalkalias(optalias, sp);

break;

case 'w':

/* vcodex window methods */

vcwwalkmeth(optwindow, sp);

break;

}

return 0;

}

static void

vcsferror(const char* mesg)

{

error(2, "%s", mesg);

}

static void

apply(int action, const char* vt, Vcsfdata_t* vcodexdisc, const char* ct, Codexdisc_t* codexdisc, const char* input, const char* source, const char* output, void* buf, size_t bufsize, Sfoff_t donez, Sfoff_t lastz)

{

Sfio_t* ip;

Sfio_t* op;

ssize_t n;

/*

if (!input || !*input || streq(input, "-") || streq(input, "/dev/stdin") || streq(input, "/dev/fd/0"))

{

input = "/dev/stdin";

ip = sfstdin;

sfset(ip, SF_SHARE, 0);

sfopen(ip, NiL, "rb");

}

else if (!(ip = sfopen(NiL, input, "rb")))

{

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

return;

}

/*

if (!action)

{

sfprintf(sfstdout, "%s: ", input);

output = "/dev/null";

codexdisc->identify = sfstdout;

}

if (!output || !*output || streq(output, "-") || streq(output, "/dev/stdout") || streq(output, "/dev/fd/1"))

{

output = "/dev/stdout";

op = sfstdout;

sfset(op, SF_SHARE, 0);

sfopen(op, NiL, "wb");

}

else if (!(op = sfopen(NiL, output, "wb")))

{

error(ERROR_SYSTEM|2, "%s: cannot write", output);

if (ip != sfstdin)

sfclose(ip);

return;

}

/*

error(-1, "AHA action=%s input=%s source=%s output=%s vt=%s ct=%s", action == VC_ENCODE ? "encode" : "decode", input, source, output, vt, ct);

if (ct != DISABLED)

{

if ((n = codex(ip, op, ct, action == VC_ENCODE ? CODEX_ENCODE : CODEX_DECODE, codexdisc, NiL)) < 0)

error(3, "%s: cannot push codex io stream discipline", input);

if (!action && n > 0)

sfprintf(sfstdout, ",");

}

/*

if (vt != DISABLED)

{

vcodexdisc->trans = (char*)vt;

vcodexdisc->source = (char*)source;

if (!vcsfio(action == VC_ENCODE ? op : ip, vcodexdisc, action))

error(3, "%s: cannot push vcodex io stream discipline", input);

else if (!action)

sfprintf(sfstdout, "%s", vcodexdisc->trans);

}

/*

if (action)

{

if (buf)

for (;;)

{

if ((n = sfread(ip, buf, bufsize)) <= 0)

{

if (n < 0)

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

break;

}

if (donez >= 0) /* verbose mode */

{

if (donez >= lastz + 64 * (bufsize > 1024*1024 ? bufsize : 1024*1024))

{

sfprintf(sfstderr, "done %10I*d %s\n", sizeof(donez), donez, output);

lastz = donez;

}

donez += n;

}

if ((n = sfwrite(op, buf, n)) < 0)

{

error(ERROR_SYSTEM|2, "%s: write error", output);

break;

}

}

else

{

sfmove(ip, op, SF_UNBOUND, -1);

if (!sfeof(ip))

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

else if (sfsync(op) || sferror(op))

error(ERROR_SYSTEM|2, "%s: write error", output);

}

}

else

sfprintf(sfstdout, "\n");

if (ip != sfstdin)

sfclose(ip);

if (op != sfstdout)

sfclose(op);

}

main(int argc, char** argv)

{

Vcchar_t *buf;

size_t bufsize;

int action; /* default is encoding */

int move = 0; /* sfmove() */

int vczip; /* are we vczip? */

int c;

char* vt; /* vcodex transform */

char* ct; /* codex transform */

Sfio_t* cs; /* codex transform buf */

Sfoff_t donez = -1, lastz = -1; /* amount processed */

Optdisc_t optdisc; /* optget() dscipline */

char name[256]; /* method name buffer */

/* NOTE: disciplines may be accessed after main() returns */

static Vcsfdata_t vcodexdisc; /* vcodex discipline */

static Codexdisc_t codexdisc; /* codex discipline */

error_info.id = (ct = strrchr(argv[0], '/')) ? (ct + 1) : argv[0];

if (!(cs = sfstropen()))

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

action = VC_ENCODE;

ct = error_info.id;

vt = name;

while (vt < &name[sizeof(name)-1] && (c = tolower(*ct++)))

if (c == 'u' && tolower(*ct) == 'n')

{ action = VC_DECODE;

ct++;

}

else

*vt++ = c;

*vt = 0;

vczip = streq(name, VCZIP);

if (!vczip && codexmeth(name))

{

vt = DISABLED;

sfprintf(cs, "%c%s", action == VC_DECODE ? '<' : '>', name);

}

else if (action == VC_DECODE)

vt = UNZIP;

else

vt = DFLTZIP;

memset(&vcodexdisc, 0, sizeof(vcodexdisc));

vcodexdisc.errorf = vcsferror;

codexinit(&codexdisc, errorf);

optinit(&optdisc, optinfo);

for (;;)

{

switch (optget(argv, usage))

{

case 'd':

vcodexdisc.type = VCSF_VCDIFF;

continue;

case 'i':

if (sfopen(sfstdin, opt_info.arg, "r") != sfstdin)

error(ERROR_SYSTEM|3, "%s: cannot read", opt_info.arg);

continue;

case 'm':

if (streq(opt_info.arg, "ietf") || streq(opt_info.arg, "vcdiff"))

vcodexdisc.type = VCSF_VCDIFF;

else if (streq(opt_info.arg, "-"))

vt = DISABLED;

else

vt = opt_info.arg;

continue;

case 'o':

if (sfopen(sfstdout, opt_info.arg, "w") != sfstdout)

error(ERROR_SYSTEM|3, "%s: cannot write", opt_info.arg);

continue;

case 'p':

vcodexdisc.type = VCSF_PLAIN;

continue;

case 'q':

action = 0;

continue;

case 't':

if (*opt_info.arg != '<' && *opt_info.arg != '>')

sfprintf(cs, "%c", action == VC_DECODE ? '<' : '>');

sfprintf(cs, "%s", opt_info.arg);

continue;

case 'u':

action = VC_DECODE;

if (vt)

vt = UNZIP;

continue;

case 'v':

donez = lastz = 0;

continue;

case 'w':

vcodexdisc.window = opt_info.arg;

continue;

case 'D':

error_info.trace = -(int)opt_info.num;

continue;

case 'M':

move = 1;

continue;

case 'P':

error(1, "pid %d", getpid());

sleep(10);

continue;

case ':':

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

continue;

case '?':

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

continue;

}

break;

}

argv += opt_info.index;

if (error_info.errors || argv[0] && argv[1])

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

buf = 0;

if (!move)

for (bufsize = 1024*1024; bufsize > 0; bufsize /= 2)

if (buf = malloc(bufsize))

break;

if (!(ct = sfstruse(cs)))

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

if (streq(ct+1, "-"))

ct = DISABLED;

else if (!*(ct+1))

ct = UNZIP;

apply(action, vt, &vcodexdisc, ct, &codexdisc, NiL, *argv, NiL, buf, bufsize, donez, lastz);

return error_info.errors != 0;

}

#else

#include "vchdr.h"

#define PR_METHOD ((Void_t*)1)

#define PR_ALIAS ((Void_t*)2)

#define DFLTZIP "sieve.delta,bwt,mtf,rle.0,huffgroup"

static char *Mesg[] =

{

"vczip [-Arguments] [SourceFile] < Input > Output\n",

"\nBelow are the standard 'Arguments':\n",

"-?: This prints this message.\n",

"-i[InputFile]: This redefines the standard 'Input' to be 'InputFile'.\n",

"-o[OutputFile]: This redefines the standard 'Output' to be 'OutputFile'.\n",

"-w[size[.alg]]: This argument is ignored during decoding (i.e., -u).\n",

" On encoding, it defines the window processing for a large input file.\n",

" 'size' is the window size, i.e., the size to break the input file into\n",

" chunks for processing. Units 'k' and 'm' mean kilo and megabytes.\n",

" 'alg' selects a windowing matching algorithm for delta compression:\n",

" p: matching windows by a prefix matching method (default) or\n",

" m: matching windows by simply mirroring file positions.\n",

"-E[type]: This translates between EBCDIC and ASCII during encoding or\n",

" decoding via the given 'type'. See also the 'map' transform below.\n",

"-vcdiff: This encodes data as defined in IETF RFC3284.\n",

"-plain: This means that the transformed data will not have information\n",

" about the transformation used for encoding. So, that information\n",

" will have to be supplied explicitly on decoding.\n",

"-u[transformation]: This decodes some previously encoded data.\n",

" If 'transformation' is not empty, it is the transformation used\n",

" to encode data. The data to be decoded will be treated as if it\n",

" was encoded with '-plain'. That is, '-utransformation' is the same\n",

" as '-u -plain -mtransformation'.\n",

"-m[transformation]: A 'transformation' is defined as a comma-separated list:\n",

" transform1[.arg11.arg12...],transform2[.arg21.arg22],...'\n",

" For example, '-mbwt,mtf,rle.0,huffgroup' defines a transformation that\n"

" compresses data based on the Burrows-Wheeler transform. When the first\n",

" transform in a transformation is a delta compressor such as 'delta' or\n",

" 'sieve', a 'SourceFile' can help enhancing compression. In that case,\n"

" the same source file must be given on both encoding and decoding.\n",

0

};

static char *Program; /* name of executable */

static void error(const char* mesg, ...)

{

va_list args;

va_start(args, mesg);

sfprintf(sfstderr,"%s: ",Program);

sfvprintf(sfstderr,mesg,args);

sfprintf(sfstderr,"\n");

va_end(args);

exit(1);

}

static void vcsferror(const char* mesg)

{ sfprintf(sfstderr,"%s: %s\n", Program, mesg);

}

static int printdesc(Void_t* obj, char* name, char* value, Void_t* type)

{

Vcmtarg_t *arg;

if(type == PR_METHOD)

{ if(!obj)

return -1;

sfprintf(sfstderr,"%s: %s.\n", name, value);

for(arg = ((Vcmethod_t*)obj)->args; arg && arg->name; ++arg)

sfprintf(sfstderr, " %12s: %s.\n", arg->name, arg->desc);

if(arg && !arg->name && arg->desc)

sfprintf(sfstderr, " %12s: %s.\n", "None", arg->desc);

}

else if(type == PR_ALIAS)

sfprintf(sfstderr, "-%s: %s.\n", name, value);

else return -1;

return 0;

}

static void printmesg()

{

int i;

for(i = 0; Mesg[i]; ++i)

sfprintf(sfstderr,"%s", Mesg[i]);

sfprintf(sfstderr, "\nThe default transformation is %s.\n", DFLTZIP);

sfprintf(sfstderr, "Below are short-hands for common transformations:\n");

vcwalkalias(printdesc, PR_ALIAS);

/* print the set of primitive methods */

sfprintf(sfstderr, "\nBelow are the available transforms and their arguments:\n");

vcwalkmeth(printdesc, PR_METHOD);

}

main(int argc, char** argv)

{

Vcchar_t *data, *dt;

ssize_t dtsz, n;

char buf[1024];

Vcsfdata_t sfdt; /* data passed to vcsf */

Vcsfio_t *sfio = NIL(Vcsfio_t*); /* IO handle */

Vcodex_t *eavc = NIL(Vcodex_t*); /* ebcdic <-> ascii */

int action = VC_ENCODE; /* default is encoding */

int type = 0; /* type of processing */

char *trans = DFLTZIP; /* transformation spec */

char *window = NIL(char*); /* window specification */

ssize_t donez = -1, lastz = -1; /* amount processed */

/* get program name */

for(Program = argv[0]+strlen(argv[0]); Program > argv[0]; --Program)

if(Program[-1] == '/')

break;

/* make list of default aliases */

vcaddalias(Dfltalias);

for(; argc > 1 && argv[1][0] == '-'; argc--, argv++)

{ switch(argv[1][1])

{

case '?':

printmesg();

return 0;

case 'o':

case 'i':

case 'S':

if(argv[1][1] == 'S')

; /* state file has been made obsolete */

else if(argv[1][2] == 0)

error("No file was given for %s.", argv[1]);

else if(argv[1][1] == 'i')

{ if(sfopen(sfstdin, argv[1]+2, "r") != sfstdin)

error("Can't open input file '%s'.", argv[1]+2);

}

else

{ if(sfopen(sfstdout, argv[1]+2, "w") != sfstdout)

error("Can't open output file '%s'.", argv[1]+2);

}

break;

case 'w':

window = argv[1]+2;

break;

case 'E': /* ebcdic <-> ascii translation */

if(eavc)

vcclose(eavc);

if(!(eavc = vcopen(0, Vcmap, argv[1]+2, 0, VC_ENCODE)) )

error("'%s' specifies bad translation mode.", argv[1]);

break;

case 'v':

if(strcmp(argv[1]+1,"vcdiff") == 0)

type = VCSF_VCDIFF;

else goto dflt_arg;

break;

case 'p':

if(strcmp(argv[1]+1,"plain") == 0)

type = VCSF_PLAIN;

else goto dflt_arg;

break;

case 'u':

action = VC_DECODE;

if(argv[1][2])

{ type = VCSF_PLAIN;

trans = argv[1]+2;

}

break;

case 'm':

trans = argv[1]+2;

break;

case 'V':

donez = lastz = 0;

break;

default:

dflt_arg:

trans = vcgetalias(argv[1]+1, buf, sizeof(buf));

if(!trans || trans == argv[1]+1)

error("'%s' is invalid. Use '-?' for help.", argv[1]);

}

}

if(strcmp(Program, "vcunzip") == 0)

action = VC_DECODE;

else if(strncmp(Program, "vczip", 5) != 0 )

error("Program name should be vczip or vcunzip");

if(sfsize(sfstdin) == 0) /* a potentially empty data stream */

{ Void_t *data;

/* see if this is just a pipe showing up initially empty */

if(!(data = sfreserve(sfstdin, -1, SF_LOCKR)) || sfvalue(sfstdin) == 0 )

return 0; /* empty data transforms to empty output */

else sfread(sfstdin, data, 0); /* reset stream for normal transformation */

}

/* turn off share mode to avoid peeking on unseekable devices */

sfset(sfstdin, SF_SHARE, 0);

sfset(sfstdout, SF_SHARE, 0);

#if _WIN32 /* on Windows systems, use binary mode for file I/O */

setmode(0, O_BINARY);

setmode(1, O_BINARY);

#endif

/* open stream for data processing */

sfdt.type = type;

sfdt.trans = trans;

sfdt.source = argc == 2 ? argv[1] : NIL(char*);

sfdt.window = window;

sfdt.errorf = vcsferror;

if(!(sfio = vcsfio(action == VC_ENCODE ? sfstdout : sfstdin, &sfdt, action)) )

error("Can't set up stream to encode or decode data.");

/* get buffer for IO */

data = NIL(Void_t*);

for(dtsz = 1024*1024; dtsz > 0; dtsz /= 2)

if((data = (Void_t*)malloc(dtsz)) )

break;

if(!data)

error("Can't allocate I/O buffer.");

for(;;)

{ if(action == VC_DECODE) /* get a chunk of data */

n = vcsfread(sfio, data, dtsz);

else n = sfread(sfstdin, data, dtsz);

if(n <= 0)

break;

if(donez >= 0) /* verbose mode */

{ if(donez >= lastz + 64*(dtsz > 1024*1024 ? dtsz : 1024*1024))

{ sfprintf(sfstderr, "Done %d\n", donez);

lastz = donez;

}

donez += n;

}

if(!eavc) /* do any ascii <-> ebcdic mapping required */

dt = data;

else if((n = vcapply(eavc, data, n, &dt)) <= 0)

error("Byte mapping failed.");

if(action == VC_DECODE) /* write out the data */

n = sfwrite(sfstdout, dt, n);

else n = vcsfwrite(sfio, dt, n);

if(n <= 0)

error("Error writing out data.");

}

vcsfclose(sfio);

return 0;

}

#endif