#ifndef _VCODEX_H

#define _VCODEX_H 1

#define VC_VERSION 20081104L /* ILU-NDV */

#define VC_ID "vcodex" /* package identification */

#define VC_LIB "vcodex_lib" /* function name */

#if _PACKAGE_ast

#include <ast_std.h>

#undef VCSFIO

#define VCSFIO 1

#undef VCPROPRIETARY

#define VCPROPRIETARY 0

#else

#include <ast_common.h>

#define VCSFIO 0

#define VCPROPRIETARY 1

#endif

#define VCODEX_PLUGIN_VERSION AST_PLUGIN_VERSION(VC_VERSION)

#if VCSFIO == 1

#include <sfio.h>

#else

#include <stdio.h>

#endif

#include <cdt.h> /* container data types */

#if !_SFIO_H /* emulate Sfio features */

#define Sfoff_t off_t /* file offset type */

#define Sfio_t FILE /* stream structure */

#define Sfdisc_t int /* Sfio discipline */

#define sfstderr stderr /* standard streams */

#define sfstdout stdout

#define sfstdin stdin

#define SF_IOCHECK 010

#define SF_LOCKR 001

#define SF_LASTR 002

#define SF_SYNC 001

#define SF_CLOSING 002

#define SF_DPOP 004

#define SF_ATEXIT 010

#define sfprintf fprintf

#define sfvprintf vfprintf

#define sfopen(s,f,m) ((s) ? freopen((f),(m),(s)) : fopen((f), (m)) )

#define sfread(s,b,n) fread((b), 1, (n), (s))

#define sfwrite(s,b,n) fwrite((b), 1, (n), (s))

#define sfrd(s,b,n,d) fread((b), 1, (n), (s))

#define sfwr(s,b,n,d) fwrite((b), 1, (n), (s))

#define sfseek(s,p,t) (fseek((s),(long)(p),(t)) >= 0 ? (Sfoff_t)ftell(s) : (Sfoff_t)(-1))

#define sfdisc(s,d) (d)

#define sfset(f,m,t) (0)

#define sfsetbuf(f,b,n) (0)

#define sffileno(f) fileno(f)

#define sftmp(n) tmpfile()

extern Void_t* sfreserve _ARG_((Sfio_t*, ssize_t, int));

extern char* sfgetr _ARG_((Sfio_t*, int, int));

extern ssize_t sfvalue _ARG_((Sfio_t*));

extern Sfoff_t sfsize _ARG_((Sfio_t*));

extern int sfclose _ARG_((Sfio_t*));

#endif /*_SFIO_H*/

#if !defined(Vcint32_t) && _typ_int32_t

#define Vcint32_t int32_t

#endif

#if !defined(Vcint32_t) && defined(_ast_int4_t)

#define Vcint32_t _ast_int4_t

#endif

#if !defined(Vcint32_t)

Help needed to define signed 32-bit integer type.

#endif

#if !defined(Vcuint32_t) && _typ_uint32_t

#define Vcuint32_t uint32_t

#endif

#if !defined(Vcuint32_t) && defined(_ast_int4_t)

#define Vcuint32_t unsigned _ast_int4_t

#endif

#if !defined(Vcuint32_t)

Help needed to define unsigned 32-bit integer type.

#endif

typedef unsigned char Vcchar_t;

typedef struct _vcodex_s Vcodex_t;

typedef struct _vcdisc_s Vcdisc_t;

typedef struct _vcmethod_s Vcmethod_t;

typedef struct _vcmtarg_s Vcmtarg_t;

typedef struct _vcmtcode_s Vcmtcode_t;

typedef struct _vccontext_s Vccontext_t;

typedef int (*Vcevent_f)_ARG_((Vcodex_t*, int, Void_t*, Vcdisc_t*));

typedef ssize_t (*Vcapply_f)_ARG_((Vcodex_t*, const Void_t*, size_t, Void_t**));

typedef int (*Vcwalk_f)_ARG_((Void_t*, char*, char*, Void_t*));

typedef struct _vcbuffer_s Vcbuffer_t;

typedef Vcuint32_t Vcbit_t; /* 32-bit accumulator */

#define VC_BITSIZE (sizeof(Vcbit_t)*8 )

typedef Vcint32_t Vcint_t; /* 32-bit integers */

#define VC_INTSIZE (sizeof(Vcint_t)*8 )

typedef struct _vcio_s

{ Vcchar_t* data; /* the data buffer */

Vcchar_t* next; /* current position in buffer */

Vcchar_t* endb; /* end of buffer or data in it */

Vcbit_t bits; /* buffer usable for bit-coding */

ssize_t nbits; /* # of bits cached in "bits" */

} Vcio_t;

struct _vcdisc_s

{ Void_t* data; /* data, key string, etc. */

ssize_t size; /* size of data or just an int */

Vcevent_f eventf; /* call-back function on events */

};

struct _vcmtarg_s

{ char* name; /* argument name - alphanumeric */

char* desc; /* short description of arg */

Void_t* data; /* predefined data, if any */

};

struct _vcmtcode_s

{ Vcchar_t* data; /* the encoding data for handle */

ssize_t size; /* the data size */

Vcodex_t* coder; /* the reconstructed coder */

};

struct _vcmethod_s

{ Vcapply_f encodef; /* function to encode */

Vcapply_f decodef; /* function to decode */

int (*eventf)_ARG_((Vcodex_t*, int, Void_t*));

char* name; /* string name, 0-terminated */

char* desc; /* description, 0-terminated */

char* about; /* [-name?value]...0-terminated */

Vcmtarg_t* args; /* list of possible arguments */

ssize_t window; /* suggested window size */

int type; /* flags telling type of method */

};

struct _vccontext_s

{ Vccontext_t *next;

};

struct _vcodex_s

{ Vcapply_f applyf; /* function to process data */

Vcdisc_t* disc; /* supplied discipline */

Vcmethod_t* meth; /* selected coding method */

Vcodex_t* coder; /* continuation coder */

size_t undone; /* left-over after vcapply() */

unsigned int flags; /* bits to control operations */

Vccontext_t* ctxt; /* list of contexts */

Void_t* data; /* private method data */

ssize_t head; /* required buffer head size */

char* file; /* file with allocation request */

int line; /* line number in file */

#ifdef _VCODEX_PRIVATE

_VCODEX_PRIVATE

#endif

};

#define VC_FLAGS 007777 /* all supported flags */

#define VC_ENCODE 000001 /* handle for encoding data */

#define VC_DECODE 000002 /* handle to decode data */

#define VC_CLOSECODER 000010 /* 2nd-ary coders to be closed */

#define VC_OPENING 1 /* opening event */

#define VC_CLOSING 2 /* closing event */

#define VC_DISC 3 /* changing discipline */

#define VC_DATA 4 /* on getting data for method */

#define VC_INITCONTEXT 101 /* setting/creating a context */

#define VC_FREECONTEXT 102 /* freeing one or all contexts */

#define VC_FREEBUFFER 103 /* free all associated buffers */

#define VC_SETMTARG 104 /* set argument(s) to a method */

#define VC_EXTRACT 105 /* extract code for handle */

#define VC_RESTORE 106 /* restoring a handle from code */

#define VC_MTSOURCE 000001 /* use source data (Vcdelta) */

#define VC_ARGSEP '.' /* separator for method args */

#define VC_METHSEP ',' /* separator for methods */

#define VCDISC(dc,dt,sz,fn) \

((dc)->data = (dt), (dc)->size = (sz), (dc)->eventf = (fn) )

#define VCSF_DISC ((((int)('V'))<<7)|((int)('C')))

#if _BLD_vcodex && defined(__EXPORT__)

#define extern extern __EXPORT__

#endif

#if !_BLD_vcodex && defined(__IMPORT__)

#define extern extern __IMPORT__

#endif

#include <vcmethods.h>

#undef extern

#if _BLD_vcodex && defined(__EXPORT__)

#define extern __EXPORT__

#endif

extern Vcodex_t* vcopen _ARG_((Vcdisc_t*, Vcmethod_t*, Void_t*, Vcodex_t*, int));

extern Vcodex_t* vcmake _ARG_((char*, int));

extern ssize_t vcextract _ARG_((Vcodex_t*, Void_t**));

extern Vcodex_t* vcrestore _ARG_((Void_t*, size_t));

extern int vcclose _ARG_((Vcodex_t*));

extern ssize_t vcapply _ARG_((Vcodex_t*, Void_t*, size_t, Void_t**));

extern size_t vcundone _ARG_((Vcodex_t*));

extern Vcdisc_t* vcdisc _ARG_((Vcodex_t*, Vcdisc_t*));

extern int vcaddmeth _ARG_((Vcmethod_t**, ssize_t));

extern Vcmethod_t* vcgetmeth _ARG_((char*, int));

extern int vcwalkmeth _ARG_((Vcwalk_f, Void_t*));

extern void vcaddalias _ARG_((char**));

extern char* vcgetalias _ARG_((char*, char*, ssize_t));

extern int vcwalkalias _ARG_((Vcwalk_f, Void_t*));

extern char* vcgetfname _ARG_((char*, char*, ssize_t));

extern int vcwalkfname _ARG_((Vcwalk_f, Void_t*));

extern char* vcgetident _ARG_((Vcmethod_t*, char*, ssize_t));

extern char* vcgetmtarg _ARG_((char*, char*, ssize_t, Vcmtarg_t*, Vcmtarg_t**));

extern int vcsetmtarg _ARG_((Vcodex_t*, char*, Void_t*, int));

extern char* vcsubstring _ARG_((char*, int, char*, ssize_t, int));

extern double vclog _ARG_((size_t)); /* fast log2 */

extern size_t vclogi _ARG_((size_t)); /* integer part of log2 */

extern ssize_t vcbcktsort _ARG_((ssize_t*, ssize_t*, ssize_t, Vcchar_t*, ssize_t*));

typedef int (*Vccompare_f)_ARG_((Void_t*, Void_t*, Void_t*));

extern Void_t vcqsort _ARG_((Void_t*, ssize_t, ssize_t, Vccompare_f, Void_t*));

#undef extern

#define vcapply(vc,s,sz,b) (*(vc)->applyf)((vc), (Void_t*)(s), (size_t)(sz), (Void_t**)(b) )

#define vcundone(vc) ((vc)->undone) /* amount left unprocessed by transform */

#if _BLD_vcodex && defined(__EXPORT__)

#define extern __EXPORT__

#endif

extern Vcint_t vcatoi _ARG_((char*));

extern ssize_t vcitoa _ARG_((Vcint_t, char*, ssize_t));

extern Vcint_t vcintcode _ARG_((Vcint_t, Vcint_t, Vcint_t, Vcint_t, int));

extern char* vcstrcode _ARG_((char*, char*, ssize_t));

extern ssize_t vchexcode _ARG_((Vcchar_t*, ssize_t, Vcchar_t*, ssize_t, int));

extern ssize_t vcstr2list _ARG_((char*, int, ssize_t**));

extern ssize_t vcioputc _ARG_((Vcio_t*, int));

extern int vciogetc _ARG_((Vcio_t*));

extern ssize_t vcioputs _ARG_((Vcio_t*, Void_t*, size_t));

extern ssize_t vciogets _ARG_((Vcio_t*, Void_t*, size_t));

extern ssize_t vcioputu _ARG_((Vcio_t*, Vcint_t));

extern Vcint_t vciogetu _ARG_((Vcio_t*));

extern ssize_t vcioputm _ARG_((Vcio_t*, Vcint_t, Vcint_t));

extern Vcint_t vciogetm _ARG_((Vcio_t*, Vcint_t));

extern ssize_t vcioput2 _ARG_((Vcio_t*, Vcchar_t, Vcchar_t, Vcint_t));

extern Vcint_t vcioget2 _ARG_((Vcio_t*, Vcchar_t, Vcchar_t));

extern ssize_t vcioputg _ARG_((Vcio_t*, Vcint_t));

extern Vcint_t vciogetg _ARG_((Vcio_t*));

extern ssize_t vcioputlist _ARG_((Vcio_t*, Vcint_t*, ssize_t));

extern ssize_t vciogetlist _ARG_((Vcio_t*, Vcint_t*, ssize_t));

extern ssize_t _vcioputu _ARG_((Vcio_t*, Vcint_t));

extern Vcint_t _vciogetu _ARG_((Vcio_t*));

extern ssize_t _vcioputm _ARG_((Vcio_t*, Vcint_t, Vcint_t));

extern Vcint_t _vciogetm _ARG_((Vcio_t*, Vcint_t));

extern ssize_t _vcioput2 _ARG_((Vcio_t*, Vcint_t, Vcchar_t, Vcchar_t));

extern Vcint_t _vcioget2 _ARG_((Vcio_t*, Vcchar_t, Vcchar_t));

extern ssize_t _vcioputg _ARG_((Vcio_t*, Vcint_t));

extern Vcint_t _vciogetg _ARG_((Vcio_t*));

#undef extern

#define vcioinit(io,b,n) ((io)->data = (io)->next = (Vcchar_t*)(b), \

(io)->endb = (io)->data + (n) )

#define vciosize(io) ((io)->next - (io)->data)

#define vciomore(io) ((io)->endb - (io)->next)

#define vcioextent(io) ((io)->endb - (io)->data)

#define vciodata(io) ((io)->data)

#define vcionext(io) ((io)->next)

#define vcioskip(io, n) ((io)->next += (n))

#define vcioputc(io, v) (*(io)->next++ = (Vcchar_t)(v) )

#define vciogetc(io) (*(io)->next++)

#define vcioputs(io, str, sz) (memcpy((io)->next, (str), (sz)), (io)->next += (sz) )

#define vciogets(io, str, sz) (memcpy((str), (io)->next, (sz)), (io)->next += (sz) )

#define vciomove(io1, io2, sz) (memcpy((io2)->next, (io1)->next, (sz)), \

(io1)->next += (sz), (io2)->next += (sz) )

#define vcioputm(io, v, m) _vcioputm((io), (Vcint_t)(v), (Vcint_t)(m))

#define vciogetm(io, m) _vciogetm((io), (Vcint_t)(m))

#define vcioputu(io, v) \

((Vcint_t)(v) < (Vcint_t)(1<<7) ? (*(io)->next++ = (Vcchar_t)(v), 1) : \

_vcioputu((io), (Vcint_t)(v)) )

#define vciogetu(io) _vciogetu((io))

#define vcioput2(io, v, a, z) _vcioput2((io),(Vcint_t)(v),(Vcchar_t)(a),(Vcchar_t)(z))

#define vcioget2(io, a, z) _vcioget2((io),(Vcchar_t)(a),(Vcchar_t)(z))

#define vcioputg(io, v) _vcioputg((io), (Vcint_t)(v))

#define vciogetg(io) _vciogetg((io))

#define vcsizeu(v) ((v)<(1<<7) ? 1 : (v)<(1<<14) ? 2 : \

(v)<(1<<21) ? 3 : (v)<(1<<28) ? 4 : 5 )

#define vcsizem(v) ((v)<(1<<8) ? 1 : (v)<(1<<16) ? 2 : \

(v)<(1<<24) ? 3 : 4 )

#define vciosetb(io, bt, nb, tp) /* (tp) is only for symmetry with vcioendb */ \

do { (bt) = 0; (nb) = 0; \

} while(0)

#define vciofilb(io, bt, nb, mb) /* getting bits from stream into (bt) */ \

do { if((nb) < (mb)) while((nb) <= (VC_BITSIZE-8) && (io)->next < (io)->endb) \

{ (nb) += 8; (bt) |= (*(io)->next++ << (VC_BITSIZE - (nb))); } \

} while(0)

#define vciodelb(io, bt, nb, nd) /* consume bits already read */ \

do { (bt) <<= (nd); (nb) -= (nd); \

} while(0)

#define vcioflsb(io, bt, nb) /* putting accumulated bits out to stream */ \

do { for(; (nb) >= 8 && (io)->next < (io)->endb; (nb) -= 8) \

{ *(io)->next++ = (Vcchar_t)((bt) >> (VC_BITSIZE-8)); (bt) <<= 8; } \

} while(0)

#define vcioaddb(io, bt, nb, ad, na) /* add new bits to accumulator */ \

do { if(((nb)+(na)) > VC_BITSIZE ) \

vcioflsb((io), (bt), (nb)); \

(bt) |= (ad) >> (nb); (nb) += (na); \

} while(0)

#define vcioendb(io, bt, nb, tp) /* finishing bit operations */ \

do { if((tp) == VC_ENCODE) \

{ vcioflsb(io, bt, nb); \

if((nb) > 0) /* finish up the partial last byte */ \

{ *(io)->next++ = (Vcchar_t)((bt) >> (VC_BITSIZE-8)); (bt) = 0; } \

} else \

{ while(((nb) -= 8) >= 0) \

(io)->next--;\

(bt) = 0; (nb) = 0; \

} \

} while(0)

typedef Vcuint32_t Vchash_t; /* 32-bit hash value */

#define VCHASH(ky) (((ky)>>13)^0x1add2b3^(ky) )

#define VCINDEX(ky,msk) (VCHASH(ky) & (msk) )

#define vcgetmtdata(vc, tp) ((tp)(vc)->data)

#define vcsetmtdata(vc, mt) ((vc)->data = (Void_t*)(mt))

#define vcgetdisc(vc) ((vc)->disc)

#define vcgetcontext(vc, tp) ((tp)(vc)->ctxt)

#if defined(__FILE__) && defined(__LINE__)

#define vcbuffer(vv,bb,zz,hh) \

(!(vv) ? ((Vcchar_t*)0) : \

((vv)->file = __FILE__, (vv)->line = __LINE__, \

_vcbuffer((vv),(bb),(zz),(hh)) ) )

#else

#define vcbuffer(vv,bb,zz,hh) _vcbuffer((vv),(bb),(zz),(hh))

#endif

struct _vcbuffer_s /* type of a buffer */

{ Vcbuffer_t* next;

size_t size; /* total buffer size */

char* file; /* file allocating it */

int line; /* line number in file */

unsigned char buf[1]; /* actual data buffer */

};

#if _BLD_vcodex && defined(__EXPORT__)

#define extern __EXPORT__

#endif

extern Vcchar_t* _vcbuffer _ARG_((Vcodex_t*, Vcchar_t*, ssize_t, ssize_t));

extern int vcrecode _ARG_((Vcodex_t*, Vcchar_t**, ssize_t*, ssize_t, int));

extern Vccontext_t* vcinitcontext _ARG_((Vcodex_t*, Vccontext_t*));

extern int vcfreecontext _ARG_((Vcodex_t*, Vccontext_t*));

#undef extern

#if VCSFXINT /* may be desirable when sizeof(int) < sizeof(ssize_t) */

#define Vcsfxint_t int

#else

#define Vcsfxint_t ssize_t

#endif

typedef struct _vcsfx_s

{ Vcsfxint_t* idx; /* the sorted suffix array */

Vcsfxint_t* inv; /* the inverted indices/ranks */

Vcchar_t* str; /* the source string */

Vcsfxint_t nstr;

} Vcsfx_t;

#if _BLD_vcodex && defined(__EXPORT__)

#define extern __EXPORT__

#endif

extern Vcsfx_t* vcsfxsort _ARG_((const Void_t*, ssize_t));

extern ssize_t vcperiod _ARG_((const Void_t*, ssize_t));

#undef extern

#define VCLZ_REVERSE 0001 /* use/do reverse matching */

#define VCLZ_MAP 0002 /* matching by mapping bytes */

typedef struct _vclzparse_s Vclzparse_t;

typedef struct _vclzmatch_s Vclzmatch_t;

typedef ssize_t (*Vclzparse_f)_ARG_((Vclzparse_t*,int,Vclzmatch_t*,ssize_t));

struct _vclzmatch_s

{ ssize_t tpos; /* position in target to match */

ssize_t mpos; /* match pos or <0 for none */

ssize_t size; /* length of data involved */

};

struct _vclzparse_s

{ Vclzparse_f parsef; /* function to process parsed segments */

Vcchar_t* src; /* source string, if any, to learn from */

ssize_t nsrc;

Vcchar_t* tar; /* target string to be parsed */

ssize_t ntar;

ssize_t mmin; /* minimum acceptable match length */

Vcchar_t* cmap; /* character map for matching */

int type; /* VCP_REVERSE, VCP_MAP */

};

#if _BLD_vcodex && defined(__EXPORT__)

#define extern __EXPORT__

#endif

extern int vclzparse _ARG_((Vclzparse_t*, ssize_t));

#undef extern

#define VC_HEADER0 (0126|0200) /* ASCII 'V' | 0200 */

#define VC_HEADER1 (0103|0200) /* ASCII 'C' | 0200 */

#define VC_HEADER2 (0104|0200) /* ASCII 'D' | 0200 */

#define VC_HEADER3 (0130|0200) /* ASCII 'X' | 0200 */

#define VCD_COMPRESSOR (1<<0) /* using a secondary compressor */

#define VCD_CODETABLE (1<<1) /* alternative code table */

#define VC_EXTRAHEADER (1<<2) /* application-defined header */

#define VC_CHECKSUM (1<<3) /* window has a checksum */

#define VC_INITS (0xf)

#define VCD_SOURCEFILE (1<<0) /* match window in source file */

#define VCD_TARGETFILE (1<<1) /* match window in target file */

#define VC_RAW (1<<2) /* data was left uncoded */

#define VC_EOF (1<<7) /* end-of-file */

#include <vcwindow.h>

#if _PACKAGE_ast

#include <vcsfio.h>

#endif

#ifdef _BLD_vcodex

#ifdef __STDC__

#define VCLIB(m) Vcmethod_t* m = &_##m;

#else

#define VCLIB(m) Vcmethod_t* m = &_/**/m;

#endif

#else

#ifdef __STDC__

#if defined(__EXPORT__)

#define VCLIB(m) Vcmethod_t* m = &_##m; extern __EXPORT__ Vcmethod_t* vcodex_lib(const char* path) { return m; } \

unsigned long plugin_version(void) { return VCODEX_PLUGIN_VERSION; }

#else

#define VCLIB(m) Vcmethod_t* m = &_##m; extern Vcmethod_t* vcodex_lib(const char* path) { return m; } \

unsigned long plugin_version(void) { return VCODEX_PLUGIN_VERSION; }

#endif

#else

#define VCLIB(m) Vcmethod_t* m = &_/**/m; extern Vcmethod_t* vcodex_lib(path) char* path; { return m; } \

unsigned long plugin_version() { return VCODEX_PLUGIN_VERSION; }

#endif

#endif

#endif /*_VCODEX_H*/