merge trunktip_405_impl_td

5 files changed, 1193 insertions, 427 deletions

diff --git a/generic/tcl.decls b/generic/tcl.decls
index b421ae2..1829249 100644
--- a/generic/tcl.decls
+++ b/generic/tcl.decls
@@ -2318,6 +2318,12 @@ declare 629 {
     int Tcl_FSUnloadFile(Tcl_Interp *interp, Tcl_LoadHandle handlePtr)
 }
 
+# TIP #400
+declare 630 {
+    void Tcl_ZlibStreamSetCompressionDictionary(Tcl_ZlibStream zhandle,
+	    Tcl_Obj *compressionDictionaryObj)
+}
+
 # ----- BASELINE -- FOR -- 8.6.0 ----- #
 
 ##############################################################################
diff --git a/generic/tclDecls.h b/generic/tclDecls.h
index 1e2a68b..3ae8b33 100644
--- a/generic/tclDecls.h
+++ b/generic/tclDecls.h
@@ -1807,6 +1807,10 @@ EXTERN void *		Tcl_FindSymbol(Tcl_Interp *interp,
 /* 629 */
 EXTERN int		Tcl_FSUnloadFile(Tcl_Interp *interp,
 				Tcl_LoadHandle handlePtr);
+/* 630 */
+EXTERN void		Tcl_ZlibStreamSetCompressionDictionary(
+				Tcl_ZlibStream zhandle,
+				Tcl_Obj *compressionDictionaryObj);
 
 typedef struct TclStubHooks {
     const struct TclPlatStubs *tclPlatStubs;
@@ -2472,6 +2476,7 @@ typedef struct TclStubs {
     int (*tcl_LoadFile) (Tcl_Interp *interp, Tcl_Obj *pathPtr, const char *const symv[], int flags, void *procPtrs, Tcl_LoadHandle *handlePtr); /* 627 */
     void * (*tcl_FindSymbol) (Tcl_Interp *interp, Tcl_LoadHandle handle, const char *symbol); /* 628 */
     int (*tcl_FSUnloadFile) (Tcl_Interp *interp, Tcl_LoadHandle handlePtr); /* 629 */
+    void (*tcl_ZlibStreamSetCompressionDictionary) (Tcl_ZlibStream zhandle, Tcl_Obj *compressionDictionaryObj); /* 630 */
 } TclStubs;
 
 #ifdef __cplusplus
@@ -3764,6 +3769,8 @@ extern const TclStubs *tclStubsPtr;
 	(tclStubsPtr->tcl_FindSymbol) /* 628 */
 #define Tcl_FSUnloadFile \
 	(tclStubsPtr->tcl_FSUnloadFile) /* 629 */
+#define Tcl_ZlibStreamSetCompressionDictionary \
+	(tclStubsPtr->tcl_ZlibStreamSetCompressionDictionary) /* 630 */
 
 #endif /* defined(USE_TCL_STUBS) */
 
diff --git a/generic/tclDictObj.c b/generic/tclDictObj.c
index b64b776..d1087b2 100644
--- a/generic/tclDictObj.c
+++ b/generic/tclDictObj.c
@@ -975,6 +975,7 @@ Tcl_DictObjGet(
     if (dictPtr->typePtr != &tclDictType) {
 	int result = SetDictFromAny(interp, dictPtr);
 	if (result != TCL_OK) {
+	    *valuePtrPtr = NULL;
 	    return result;
 	}
     }
diff --git a/generic/tclStubInit.c b/generic/tclStubInit.c
index a8d74ee..75af3b7 100644
--- a/generic/tclStubInit.c
+++ b/generic/tclStubInit.c
@@ -1287,6 +1287,7 @@ const TclStubs tclStubs = {
     Tcl_LoadFile, /* 627 */
     Tcl_FindSymbol, /* 628 */
     Tcl_FSUnloadFile, /* 629 */
+    Tcl_ZlibStreamSetCompressionDictionary, /* 630 */
 };
 
 /* !END!: Do not edit above this line. */
diff --git a/generic/tclZlib.c b/generic/tclZlib.c
index 544fb6e..11490f1 100644
--- a/generic/tclZlib.c
+++ b/generic/tclZlib.c
@@ -5,7 +5,7 @@
  *
  * Copyright (C) 2004-2005 Pascal Scheffers <pascal@scheffers.net>
  * Copyright (C) 2005 Unitas Software B.V.
- * Copyright (c) 2008-2009 Donal K. Fellows
+ * Copyright (c) 2008-2012 Donal K. Fellows
  *
  * Parts written by Jean-Claude Wippler, as part of Tclkit, placed in the
  * public domain March 2003.
@@ -74,8 +74,27 @@ typedef struct {
     int wbits;			/* The encoded compression mode, so we can
 				 * restart the stream if necessary. */
     Tcl_Command cmd;		/* Token for the associated Tcl command. */
+    Tcl_Obj *compDictObj;	/* Byte-array object containing compression
+				 * dictionary (not dictObj!) to use if
+				 * necessary. */
+    int flags;			/* Miscellaneous flag bits. */
+    GzipHeader *gzHeaderPtr;	/* If we've allocated a gzip header
+				 * structure. */
 } ZlibStreamHandle;
 
+#define DICT_TO_SET	0x1	/* If we need to set a compression dictionary
+				 * in the low-level engine at the next
+				 * opportunity. */
+
+/*
+ * Macros to make it clearer in some of the twiddlier accesses what is
+ * happening.
+ */
+
+#define IsRawStream(zshPtr)	((zshPtr)->format == TCL_ZLIB_FORMAT_RAW)
+#define HaveDictToSet(zshPtr)	((zshPtr)->flags & DICT_TO_SET)
+#define DictWasSet(zshPtr)	((zshPtr)->flags |= ~DICT_TO_SET)
+
 /*
  * Structure used for stacked channel compression and decompression.
  */
@@ -88,6 +107,11 @@ typedef struct {
 				 * for compression on output, or
 				 * TCL_ZLIB_STREAM_INFLATE for decompression
 				 * on input. */
+    int format;			/* What format of data is going on the wire.
+				 * Needed so that the correct [fconfigure]
+				 * options can be enabled. */
+    int readAheadLimit;		/* The maximum number of bytes to read from
+				 * the underlying stream in one go. */
     z_stream inStream;		/* Structure used by zlib for decompression of
 				 * input. */
     z_stream outStream;		/* Structure used by zlib for compression of
@@ -101,6 +125,9 @@ typedef struct {
 				 * compressing a gzip stream. */
     Tcl_TimerToken timer;	/* Timer used for keeping events fresh. */
     Tcl_DString decompressed;	/* Buffer for decompression results. */
+    Tcl_Obj *compDictObj;	/* Byte-array object containing compression
+				 * dictionary (not dictObj!) to use if
+				 * necessary. */
 } ZlibChannelData;
 
 /*
@@ -117,10 +144,15 @@ typedef struct {
 #define OUT_HEADER		0x4
 
 /*
- * Size of buffers allocated by default. Should be enough...
+ * Size of buffers allocated by default, and the range it can be set to.  The
+ * same sorts of values apply to streams, except with different limits (they
+ * permit byte-level activity). Channels always use bytes unless told to use
+ * larger buffers.
  */
 
 #define DEFAULT_BUFFER_SIZE	4096
+#define MIN_NONSTREAM_BUFFER_SIZE 16
+#define MAX_BUFFER_SIZE		65536
 
 /*
  * Prototypes for private procedures defined later in this file:
@@ -138,19 +170,29 @@ static Tcl_DriverSetOptionProc	ZlibTransformSetOption;
 static Tcl_DriverWatchProc	ZlibTransformWatch;
 static Tcl_ObjCmdProc		ZlibCmd;
 static Tcl_ObjCmdProc		ZlibStreamCmd;
+static Tcl_ObjCmdProc		ZlibStreamAddCmd;
+static Tcl_ObjCmdProc		ZlibStreamHeaderCmd;
+static Tcl_ObjCmdProc		ZlibStreamPutCmd;
 
-static void		ConvertError(Tcl_Interp *interp, int code);
+static void		ConvertError(Tcl_Interp *interp, int code,
+			    uLong adler);
+static Tcl_Obj *	ConvertErrorToList(int code, uLong adler);
 static void		ExtractHeader(gz_header *headerPtr, Tcl_Obj *dictObj);
 static int		GenerateHeader(Tcl_Interp *interp, Tcl_Obj *dictObj,
 			    GzipHeader *headerPtr, int *extraSizePtr);
+static int		ZlibPushSubcmd(Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
 static inline int	ResultCopy(ZlibChannelData *cd, char *buf,
 			    int toRead);
 static int		ResultGenerate(ZlibChannelData *cd, int n, int flush,
 			    int *errorCodePtr);
 static Tcl_Channel	ZlibStackChannelTransform(Tcl_Interp *interp,
-			    int mode, int format, int level,
-			    Tcl_Channel channel, Tcl_Obj *gzipHeaderDictPtr);
+			    int mode, int format, int level, int limit,
+			    Tcl_Channel channel, Tcl_Obj *gzipHeaderDictPtr,
+			    Tcl_Obj *compDictObj);
 static void		ZlibStreamCleanup(ZlibStreamHandle *zshPtr);
+static int		ZlibStreamSubcmd(Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
 static inline void	ZlibTransformEventTimerKill(ZlibChannelData *cd);
 static void		ZlibTransformTimerRun(ClientData clientData);
 
@@ -198,38 +240,139 @@ static void
 ConvertError(
     Tcl_Interp *interp,		/* Interpreter to store the error in. May be
 				 * NULL, in which case nothing happens. */
-    int code)			/* The zlib error code. */
+    int code,			/* The zlib error code. */
+    uLong adler)		/* The checksum expected (for Z_NEED_DICT) */
 {
+    const char *codeStr, *codeStr2 = NULL;
+    char codeStrBuf[TCL_INTEGER_SPACE];
+
     if (interp == NULL) {
 	return;
     }
 
-    if (code == Z_ERRNO) {
+    switch (code) {
+	/*
+	 * Firstly, the case that is *different* because it's really coming
+	 * from the OS and is just being reported via zlib. It should be
+	 * really uncommon because Tcl handles all I/O rather than delegating
+	 * it to zlib, but proving it can't happen is hard.
+	 */
+
+    case Z_ERRNO:
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(Tcl_PosixError(interp),-1));
-    } else {
-	const char *codeStr, *codeStr2 = NULL;
-	char codeStrBuf[TCL_INTEGER_SPACE];
-
-	switch (code) {
-	case Z_STREAM_ERROR:	codeStr = "STREAM";	break;
-	case Z_DATA_ERROR:	codeStr = "DATA";	break;
-	case Z_MEM_ERROR:	codeStr = "MEM";	break;
-	case Z_BUF_ERROR:	codeStr = "BUF";	break;
-	case Z_VERSION_ERROR:	codeStr = "VERSION";	break;
-	default:
-	    codeStr = "unknown";
-	    codeStr2 = codeStrBuf;
-	    sprintf(codeStrBuf, "%d", code);
-	    break;
-	}
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(zError(code), -1));
+	return;
+
+	/*
+	 * Normal errors/conditions, some of which have additional detail and
+	 * some which don't. (This is not defined by array lookup because zlib
+	 * error codes are sometimes negative.)
+	 */
+
+    case Z_STREAM_ERROR:
+	codeStr = "STREAM";
+	break;
+    case Z_DATA_ERROR:
+	codeStr = "DATA";
+	break;
+    case Z_MEM_ERROR:
+	codeStr = "MEM";
+	break;
+    case Z_BUF_ERROR:
+	codeStr = "BUF";
+	break;
+    case Z_VERSION_ERROR:
+	codeStr = "VERSION";
+	break;
+    case Z_NEED_DICT:
+	codeStr = "NEED_DICT";
+	codeStr2 = codeStrBuf;
+	sprintf(codeStrBuf, "%lu", adler);
+	break;
+
+	/*
+	 * These should _not_ happen! This function is for dealing with error
+	 * cases, not non-errors!
+	 */
+
+    case Z_OK:
+	Tcl_Panic("unexpected zlib result in error handler: Z_OK");
+    case Z_STREAM_END:
+	Tcl_Panic("unexpected zlib result in error handler: Z_STREAM_END");
+
+	/*
+	 * Anything else is bad news; it's unexpected. Convert to generic
+	 * error.
+	 */
+
+    default:
+	codeStr = "UNKNOWN";
+	codeStr2 = codeStrBuf;
+	sprintf(codeStrBuf, "%d", code);
+	break;
+    }
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(zError(code), -1));
+
+    /*
+     * Tricky point! We might pass NULL twice here (and will when the error
+     * type is known).
+     */
+
+    Tcl_SetErrorCode(interp, "TCL", "ZLIB", codeStr, codeStr2, NULL);
+}
+
+static Tcl_Obj *
+ConvertErrorToList(
+    int code,			/* The zlib error code. */
+    uLong adler)		/* The checksum expected (for Z_NEED_DICT) */
+{
+    Tcl_Obj *objv[4];
+
+    TclNewLiteralStringObj(objv[0], "TCL");
+    TclNewLiteralStringObj(objv[1], "ZLIB");
+    switch (code) {
+    case Z_STREAM_ERROR:
+	TclNewLiteralStringObj(objv[2], "STREAM");
+	return Tcl_NewListObj(3, objv);
+    case Z_DATA_ERROR:
+	TclNewLiteralStringObj(objv[2], "DATA");
+	return Tcl_NewListObj(3, objv);
+    case Z_MEM_ERROR:
+	TclNewLiteralStringObj(objv[2], "MEM");
+	return Tcl_NewListObj(3, objv);
+    case Z_BUF_ERROR:
+	TclNewLiteralStringObj(objv[2], "BUF");
+	return Tcl_NewListObj(3, objv);
+    case Z_VERSION_ERROR:
+	TclNewLiteralStringObj(objv[2], "VERSION");
+	return Tcl_NewListObj(3, objv);
+    case Z_ERRNO:
+	TclNewLiteralStringObj(objv[2], "POSIX");
+	objv[3] = Tcl_NewStringObj(Tcl_ErrnoId(), -1);
+	return Tcl_NewListObj(4, objv);
+    case Z_NEED_DICT:
+	TclNewLiteralStringObj(objv[2], "NEED_DICT");
+	objv[3] = Tcl_NewWideIntObj((Tcl_WideInt) adler);
+	return Tcl_NewListObj(4, objv);
+
+	/*
+	 * These should _not_ happen! This function is for dealing with error
+	 * cases, not non-errors!
+	 */
+
+    case Z_OK:
+	Tcl_Panic("unexpected zlib result in error handler: Z_OK");
+    case Z_STREAM_END:
+	Tcl_Panic("unexpected zlib result in error handler: Z_STREAM_END");
 
 	/*
-	 * Tricky point! We might pass NULL twice here (and will when the
-	 * error type is known).
+	 * Catch-all. Should be unreachable because all cases are already
+	 * listed above.
 	 */
 
-	Tcl_SetErrorCode(interp, "TCL", "ZLIB", codeStr, codeStr2, NULL);
+    default:
+	TclNewLiteralStringObj(objv[2], "UNKNOWN");
+	TclNewIntObj(objv[3], code);
+	return Tcl_NewListObj(4, objv);
     }
 }
 
@@ -301,7 +444,9 @@ GenerateHeader(
 		NULL);
 	headerPtr->nativeCommentBuf[len] = '\0';
 	headerPtr->header.comment = (Bytef *) headerPtr->nativeCommentBuf;
-	*extraSizePtr += len;
+	if (extraSizePtr != NULL) {
+	    *extraSizePtr += len;
+	}
     }
 
     if (GetValue(interp, dictObj, "crc", &value) != TCL_OK) {
@@ -319,7 +464,9 @@ GenerateHeader(
 		headerPtr->nativeFilenameBuf, MAXPATHLEN-1, NULL, &len, NULL);
 	headerPtr->nativeFilenameBuf[len] = '\0';
 	headerPtr->header.name = (Bytef *) headerPtr->nativeFilenameBuf;
-	*extraSizePtr += len;
+	if (extraSizePtr != NULL) {
+	    *extraSizePtr += len;
+	}
     }
 
     if (GetValue(interp, dictObj, "os", &value) != TCL_OK) {
@@ -441,6 +588,34 @@ ExtractHeader(
     }
 }
 
+static int
+SetInflateDictionary(
+    z_streamp strm,
+    Tcl_Obj *compDictObj)
+{
+    if (compDictObj != NULL) {
+	int length;
+	unsigned char *bytes = Tcl_GetByteArrayFromObj(compDictObj, &length);
+
+	return inflateSetDictionary(strm, bytes, (unsigned) length);
+    }
+    return Z_OK;
+}
+
+static int
+SetDeflateDictionary(
+    z_streamp strm,
+    Tcl_Obj *compDictObj)
+{
+    if (compDictObj != NULL) {
+	int length;
+	unsigned char *bytes = Tcl_GetByteArrayFromObj(compDictObj, &length);
+
+	return deflateSetDictionary(strm, bytes, (unsigned) length);
+    }
+    return Z_OK;
+}
+
 /*
  *----------------------------------------------------------------------
  *
@@ -479,6 +654,7 @@ Tcl_ZlibStreamInit(
     ZlibStreamHandle *zshPtr = NULL;
     Tcl_DString cmdname;
     Tcl_CmdInfo cmdinfo;
+    GzipHeader *gzHeaderPtr = NULL;
 
     switch (mode) {
     case TCL_ZLIB_STREAM_DEFLATE:
@@ -493,6 +669,15 @@ Tcl_ZlibStreamInit(
 	    break;
 	case TCL_ZLIB_FORMAT_GZIP:
 	    wbits = WBITS_GZIP;
+	    if (dictObj) {
+		gzHeaderPtr = ckalloc(sizeof(GzipHeader));
+		memset(gzHeaderPtr, 0, sizeof(GzipHeader));
+		if (GenerateHeader(interp, dictObj, gzHeaderPtr,
+			NULL) != TCL_OK) {
+		    ckfree(gzHeaderPtr);
+		    return TCL_ERROR;
+		}
+	    }
 	    break;
 	case TCL_ZLIB_FORMAT_ZLIB:
 	    wbits = WBITS_ZLIB;
@@ -519,6 +704,14 @@ Tcl_ZlibStreamInit(
 	    break;
 	case TCL_ZLIB_FORMAT_GZIP:
 	    wbits = WBITS_GZIP;
+	    gzHeaderPtr = ckalloc(sizeof(GzipHeader));
+	    memset(gzHeaderPtr, 0, sizeof(GzipHeader));
+	    gzHeaderPtr->header.name = (Bytef *)
+		    gzHeaderPtr->nativeFilenameBuf;
+	    gzHeaderPtr->header.name_max = MAXPATHLEN - 1;
+	    gzHeaderPtr->header.comment = (Bytef *)
+		    gzHeaderPtr->nativeCommentBuf;
+	    gzHeaderPtr->header.name_max = MAX_COMMENT_LEN - 1;
 	    break;
 	case TCL_ZLIB_FORMAT_ZLIB:
 	    wbits = WBITS_ZLIB;
@@ -545,6 +738,9 @@ Tcl_ZlibStreamInit(
     zshPtr->wbits = wbits;
     zshPtr->currentInput = NULL;
     zshPtr->streamEnd = 0;
+    zshPtr->compDictObj = NULL;
+    zshPtr->flags = 0;
+    zshPtr->gzHeaderPtr = gzHeaderPtr;
     memset(&zshPtr->stream, 0, sizeof(z_stream));
     zshPtr->stream.adler = 1;
 
@@ -555,12 +751,20 @@ Tcl_ZlibStreamInit(
     if (mode == TCL_ZLIB_STREAM_DEFLATE) {
 	e = deflateInit2(&zshPtr->stream, level, Z_DEFLATED, wbits,
 		MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY);
+	if (e == Z_OK && zshPtr->gzHeaderPtr) {
+	    e = deflateSetHeader(&zshPtr->stream,
+		    &zshPtr->gzHeaderPtr->header);
+	}
     } else {
 	e = inflateInit2(&zshPtr->stream, wbits);
+	if (e == Z_OK && zshPtr->gzHeaderPtr) {
+	    e = inflateGetHeader(&zshPtr->stream,
+		    &zshPtr->gzHeaderPtr->header);
+	}
     }
 
     if (e != Z_OK) {
-	ConvertError(interp, e);
+	ConvertError(interp, e, zshPtr->stream.adler);
 	goto error;
     }
 
@@ -620,7 +824,14 @@ Tcl_ZlibStreamInit(
     }
 
     return TCL_OK;
- error:
+
+  error:
+    if (zshPtr->compDictObj) {
+	Tcl_DecrRefCount(zshPtr->compDictObj);
+    }
+    if (zshPtr->gzHeaderPtr) {
+	ckfree(zshPtr->gzHeaderPtr);
+    }
     ckfree(zshPtr);
     return TCL_ERROR;
 }
@@ -728,6 +939,12 @@ ZlibStreamCleanup(
     if (zshPtr->currentInput) {
 	Tcl_DecrRefCount(zshPtr->currentInput);
     }
+    if (zshPtr->compDictObj) {
+	Tcl_DecrRefCount(zshPtr->compDictObj);
+    }
+    if (zshPtr->gzHeaderPtr) {
+	ckfree(zshPtr->gzHeaderPtr);
+    }
 
     ckfree(zshPtr);
 }
@@ -780,12 +997,24 @@ Tcl_ZlibStreamReset(
     if (zshPtr->mode == TCL_ZLIB_STREAM_DEFLATE) {
 	e = deflateInit2(&zshPtr->stream, zshPtr->level, Z_DEFLATED,
 		zshPtr->wbits, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY);
+	if (e == Z_OK && HaveDictToSet(zshPtr)) {
+	    e = SetDeflateDictionary(&zshPtr->stream, zshPtr->compDictObj);
+	    if (e == Z_OK) {
+		DictWasSet(zshPtr);
+	    }
+	}
     } else {
 	e = inflateInit2(&zshPtr->stream, zshPtr->wbits);
+	if (IsRawStream(zshPtr) && HaveDictToSet(zshPtr) && e == Z_OK) {
+	    e = SetInflateDictionary(&zshPtr->stream, zshPtr->compDictObj);
+	    if (e == Z_OK) {
+		DictWasSet(zshPtr);
+	    }
+	}
     }
 
     if (e != Z_OK) {
-	ConvertError(zshPtr->interp, e);
+	ConvertError(zshPtr->interp, e, zshPtr->stream.adler);
 	/* TODO:cleanup */
 	return TCL_ERROR;
     }
@@ -878,6 +1107,41 @@ Tcl_ZlibStreamChecksum(
 /*
  *----------------------------------------------------------------------
  *
+ * Tcl_ZlibStreamSetCompressionDictionary --
+ *
+ *	Sets the compression dictionary for a stream. This will be used as
+ *	appropriate for the next compression or decompression action performed
+ *	on the stream.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_ZlibStreamSetCompressionDictionary(
+    Tcl_ZlibStream zshandle,
+    Tcl_Obj *compressionDictionaryObj)
+{
+    ZlibStreamHandle *zshPtr = (ZlibStreamHandle *) zshandle;
+
+    if (compressionDictionaryObj != NULL) {
+	if (Tcl_IsShared(compressionDictionaryObj)) {
+	    compressionDictionaryObj =
+		    Tcl_DuplicateObj(compressionDictionaryObj);
+	}
+	Tcl_IncrRefCount(compressionDictionaryObj);
+	zshPtr->flags |= DICT_TO_SET;
+    } else {
+	zshPtr->flags &= ~DICT_TO_SET;
+    }
+    if (zshPtr->compDictObj != NULL) {
+	Tcl_DecrRefCount(zshPtr->compDictObj);
+    }
+    zshPtr->compDictObj = compressionDictionaryObj;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * Tcl_ZlibStreamPut --
  *
  *	Add data to the stream for compression or decompression from a
@@ -911,6 +1175,17 @@ Tcl_ZlibStreamPut(
 	zshPtr->stream.next_in = Tcl_GetByteArrayFromObj(data, &size);
 	zshPtr->stream.avail_in = size;
 
+	if (HaveDictToSet(zshPtr)) {
+	    e = SetDeflateDictionary(&zshPtr->stream, zshPtr->compDictObj);
+	    if (e != Z_OK) {
+		if (zshPtr->interp) {
+		    ConvertError(zshPtr->interp, e, zshPtr->stream.adler);
+		}
+		return TCL_ERROR;
+	    }
+	    DictWasSet(zshPtr);
+	}
+
 	/*
 	 * Deflatebound doesn't seem to take various header sizes into
 	 * account, so we add 100 extra bytes.
@@ -948,6 +1223,12 @@ Tcl_ZlibStreamPut(
 
 	    e = deflate(&zshPtr->stream, flush);
 	}
+	if (e != Z_OK && !(flush==Z_FINISH && e==Z_STREAM_END)) {
+	    if (zshPtr->interp) {
+		ConvertError(zshPtr->interp, e, zshPtr->stream.adler);
+	    }
+	    return TCL_ERROR;
+	}
 
 	/*
 	 * And append the final data block.
@@ -1025,7 +1306,7 @@ Tcl_ZlibStreamGet(
 	     * panic for out of memory if we just kept growing the buffer.
 	     */
 
-	    count = 65536;
+	    count = MAX_BUFFER_SIZE;
 	}
 
 	/*
@@ -1073,7 +1354,30 @@ Tcl_ZlibStreamGet(
 	    }
 	}
 
+	/*
+	 * When dealing with a raw stream, we set the dictionary here, once.
+	 * (You can't do it in response to getting Z_NEED_DATA as raw streams
+	 * don't ever issue that.)
+	 */
+
+	if (IsRawStream(zshPtr) && HaveDictToSet(zshPtr)) {
+	    e = SetInflateDictionary(&zshPtr->stream, zshPtr->compDictObj);
+	    if (e != Z_OK) {
+		if (zshPtr->interp) {
+		    ConvertError(zshPtr->interp, e, zshPtr->stream.adler);
+		}
+		return TCL_ERROR;
+	    }
+	    DictWasSet(zshPtr);
+	}
 	e = inflate(&zshPtr->stream, zshPtr->flush);
+	if (e == Z_NEED_DICT && HaveDictToSet(zshPtr)) {
+	    e = SetInflateDictionary(&zshPtr->stream, zshPtr->compDictObj);
+	    if (e == Z_OK) {
+		DictWasSet(zshPtr);
+		e = inflate(&zshPtr->stream, zshPtr->flush);
+	    }
+	};
 	Tcl_ListObjLength(NULL, zshPtr->inData, &listLen);
 
 	while ((zshPtr->stream.avail_out > 0)
@@ -1127,7 +1431,14 @@ Tcl_ZlibStreamGet(
 	     * And call inflate again.
 	     */
 
-	    e = inflate(&zshPtr->stream, zshPtr->flush);
+	    do {
+		e = inflate(&zshPtr->stream, zshPtr->flush);
+		if (e != Z_NEED_DICT || !HaveDictToSet(zshPtr)) {
+		    break;
+		}
+		e = SetInflateDictionary(&zshPtr->stream,zshPtr->compDictObj);
+		DictWasSet(zshPtr);
+	    } while (e == Z_OK);
 	}
 	if (zshPtr->stream.avail_out > 0) {
 	    Tcl_SetByteArrayLength(data,
@@ -1135,7 +1446,7 @@ Tcl_ZlibStreamGet(
 	}
 	if (!(e==Z_OK || e==Z_STREAM_END || e==Z_BUF_ERROR)) {
 	    Tcl_SetByteArrayLength(data, existing);
-	    ConvertError(zshPtr->interp, e);
+	    ConvertError(zshPtr->interp, e, zshPtr->stream.adler);
 	    return TCL_ERROR;
 	}
 	if (e == Z_STREAM_END) {
@@ -1351,7 +1662,7 @@ Tcl_ZlibDeflate(
     return TCL_OK;
 
   error:
-    ConvertError(interp, e);
+    ConvertError(interp, e, stream.adler);
     TclDecrRefCount(obj);
     return TCL_ERROR;
 }
@@ -1530,7 +1841,7 @@ Tcl_ZlibInflate(
 
   error:
     TclDecrRefCount(obj);
-    ConvertError(interp, e);
+    ConvertError(interp, e, stream.adler);
     if (nameBuf) {
 	ckfree(nameBuf);
     }
@@ -1586,11 +1897,10 @@ ZlibCmd(
     int objc,
     Tcl_Obj *const objv[])
 {
-    int command, dlen, mode, format, i, option, level = -1;
+    int command, dlen, i, option, level = -1;
     unsigned start, buffersize = 0;
-    Tcl_ZlibStream zh;
     Byte *data;
-    Tcl_Obj *headerDictObj, *headerVarObj;
+    Tcl_Obj *headerDictObj;
     const char *extraInfoStr = NULL;
     static const char *const commands[] = {
 	"adler32", "compress", "crc32", "decompress", "deflate", "gunzip",
@@ -1601,14 +1911,6 @@ ZlibCmd(
 	CMD_ADLER, CMD_COMPRESS, CMD_CRC, CMD_DECOMPRESS, CMD_DEFLATE,
 	CMD_GUNZIP, CMD_GZIP, CMD_INFLATE, CMD_PUSH, CMD_STREAM
     };
-    static const char *const stream_formats[] = {
-	"compress", "decompress", "deflate", "gunzip", "gzip", "inflate",
-	NULL
-    };
-    enum zlibFormats {
-	FMT_COMPRESS, FMT_DECOMPRESS, FMT_DEFLATE, FMT_GUNZIP, FMT_GZIP,
-	FMT_INFLATE
-    };
 
     if (objc < 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "command arg ?...?");
@@ -1635,7 +1937,7 @@ ZlibCmd(
 	}
 	data = Tcl_GetByteArrayFromObj(objv[2], &dlen);
 	Tcl_SetObjResult(interp, Tcl_NewWideIntObj((Tcl_WideInt)
-		Tcl_ZlibAdler32(start, data, dlen)));
+		(uLong) Tcl_ZlibAdler32(start, data, dlen)));
 	return TCL_OK;
     case CMD_CRC:			/* crc32 str ?startvalue?
 					 * -> checksum */
@@ -1652,7 +1954,7 @@ ZlibCmd(
 	}
 	data = Tcl_GetByteArrayFromObj(objv[2], &dlen);
 	Tcl_SetObjResult(interp, Tcl_NewWideIntObj((Tcl_WideInt)
-		Tcl_ZlibCRC32(start, data, dlen)));
+		(uLong) Tcl_ZlibCRC32(start, data, dlen)));
 	return TCL_OK;
     case CMD_DEFLATE:			/* deflate data ?level?
 					 * -> rawCompressedData */
@@ -1688,12 +1990,27 @@ ZlibCmd(
 		NULL);
     case CMD_GZIP:			/* gzip data ?level?
 					 * -> gzippedCompressedData */
+	headerDictObj = NULL;
+
+	/*
+	 * Legacy argument format support.
+	 */
+
+	if (objc == 4
+		&& Tcl_GetIntFromObj(interp, objv[3], &level) == TCL_OK) {
+	    if (level < 0 || level > 9) {
+		extraInfoStr = "\n    (in -level option)";
+		goto badLevel;
+	    }
+	    return Tcl_ZlibDeflate(interp, TCL_ZLIB_FORMAT_GZIP, objv[2],
+		    level, NULL);
+	}
+
 	if (objc < 3 || objc > 7 || ((objc & 1) == 0)) {
 	    Tcl_WrongNumArgs(interp, 2, objv,
 		    "data ?-level level? ?-header header?");
 	    return TCL_ERROR;
 	}
-	headerDictObj = NULL;
 	for (i=3 ; i<objc ; i+=2) {
 	    static const char *const gzipopts[] = {
 		"-header", "-level", NULL
@@ -1732,7 +2049,8 @@ ZlibCmd(
 		    (int *) &buffersize) != TCL_OK) {
 		return TCL_ERROR;
 	    }
-	    if (buffersize < 16 || buffersize > 65536) {
+	    if (buffersize < MIN_NONSTREAM_BUFFER_SIZE
+		    || buffersize > MAX_BUFFER_SIZE) {
 		goto badBuffer;
 	    }
 	}
@@ -1750,14 +2068,17 @@ ZlibCmd(
 		    (int *) &buffersize) != TCL_OK) {
 		return TCL_ERROR;
 	    }
-	    if (buffersize < 16 || buffersize > 65536) {
+	    if (buffersize < MIN_NONSTREAM_BUFFER_SIZE
+		    || buffersize > MAX_BUFFER_SIZE) {
 		goto badBuffer;
 	    }
 	}
 	return Tcl_ZlibInflate(interp, TCL_ZLIB_FORMAT_ZLIB, objv[2],
 		buffersize, NULL);
-    case CMD_GUNZIP:			/* gunzip gzippeddata ?bufferSize?
+    case CMD_GUNZIP: {			/* gunzip gzippeddata ?bufferSize?
 					 *	-> decompressedData */
+	Tcl_Obj *headerVarObj;
+
 	if (objc < 3 || objc > 5 || ((objc & 1) == 0)) {
 	    Tcl_WrongNumArgs(interp, 2, objv, "data ?-headerVar varName?");
 	    return TCL_ERROR;
@@ -1778,7 +2099,8 @@ ZlibCmd(
 			(int *) &buffersize) != TCL_OK) {
 		    return TCL_ERROR;
 		}
-		if (buffersize < 16 || buffersize > 65536) {
+		if (buffersize < MIN_NONSTREAM_BUFFER_SIZE
+			|| buffersize > MAX_BUFFER_SIZE) {
 		    goto badBuffer;
 		}
 		break;
@@ -1803,209 +2125,353 @@ ZlibCmd(
 	    return TCL_ERROR;
 	}
 	return TCL_OK;
+    }
     case CMD_STREAM:			/* stream deflate/inflate/...gunzip \
-					 *    ?level?
+					 *    ?options...?
 					 *	-> handleCmd */
-	if (objc < 3 || objc > 4) {
-	    Tcl_WrongNumArgs(interp, 2, objv, "mode ?level?");
-	    return TCL_ERROR;
-	}
-	if (Tcl_GetIndexFromObj(interp, objv[2], stream_formats, "mode", 0,
-		&format) != TCL_OK) {
-	    return TCL_ERROR;
-	}
-	mode = TCL_ZLIB_STREAM_INFLATE;
-	switch ((enum zlibFormats) format) {
-	case FMT_DEFLATE:
-	    mode = TCL_ZLIB_STREAM_DEFLATE;
-	case FMT_INFLATE:
-	    format = TCL_ZLIB_FORMAT_RAW;
-	    break;
-	case FMT_COMPRESS:
-	    mode = TCL_ZLIB_STREAM_DEFLATE;
-	case FMT_DECOMPRESS:
-	    format = TCL_ZLIB_FORMAT_ZLIB;
-	    break;
-	case FMT_GZIP:
-	    mode = TCL_ZLIB_STREAM_DEFLATE;
-	case FMT_GUNZIP:
-	    format = TCL_ZLIB_FORMAT_GZIP;
-	    break;
-	}
-	if (objc == 4) {
-	    if (Tcl_GetIntFromObj(interp, objv[3],
-		    (int *) &level) != TCL_OK) {
-		return TCL_ERROR;
-	    }
-	    if (level < 0 || level > 9) {
-		goto badLevel;
-	    }
-	} else {
-	    level = Z_DEFAULT_COMPRESSION;
-	}
-	if (Tcl_ZlibStreamInit(interp, mode, format, level, NULL,
-		&zh) != TCL_OK) {
-	    return TCL_ERROR;
-	}
-	Tcl_SetObjResult(interp, Tcl_ZlibStreamGetCommandName(zh));
-	return TCL_OK;
-    case CMD_PUSH: {			/* push mode channel options...
+	return ZlibStreamSubcmd(interp, objc, objv);
+    case CMD_PUSH:			/* push mode channel options...
 					 *	-> channel */
-	Tcl_Channel chan;
-	int chanMode;
-	static const char *const pushOptions[] = {
-	    "-header", "-level", "-limit",
-	    NULL
-	};
-	enum pushOptions {poHeader, poLevel, poLimit};
-	Tcl_Obj *headerObj = NULL;
-	int limit = 1, dummy;
+	return ZlibPushSubcmd(interp, objc, objv);
+    };
 
-	if (objc < 4) {
-	    Tcl_WrongNumArgs(interp, 2, objv, "mode channel ?options...?");
-	    return TCL_ERROR;
-	}
+    return TCL_ERROR;
 
-	if (Tcl_GetIndexFromObj(interp, objv[2], stream_formats, "mode", 0,
-		&format) != TCL_OK) {
-	    return TCL_ERROR;
-	}
-	switch ((enum zlibFormats) format) {
-	case FMT_DEFLATE:
-	    mode = TCL_ZLIB_STREAM_DEFLATE;
-	    format = TCL_ZLIB_FORMAT_RAW;
-	    break;
-	case FMT_INFLATE:
-	    mode = TCL_ZLIB_STREAM_INFLATE;
-	    format = TCL_ZLIB_FORMAT_RAW;
-	    break;
-	case FMT_COMPRESS:
-	    mode = TCL_ZLIB_STREAM_DEFLATE;
-	    format = TCL_ZLIB_FORMAT_ZLIB;
-	    break;
-	case FMT_DECOMPRESS:
-	    mode = TCL_ZLIB_STREAM_INFLATE;
-	    format = TCL_ZLIB_FORMAT_ZLIB;
-	    break;
-	case FMT_GZIP:
-	    mode = TCL_ZLIB_STREAM_DEFLATE;
-	    format = TCL_ZLIB_FORMAT_GZIP;
-	    break;
-	case FMT_GUNZIP:
-	    mode = TCL_ZLIB_STREAM_INFLATE;
-	    format = TCL_ZLIB_FORMAT_GZIP;
-	    break;
-	default:
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj("impossible!", -1));
-	    return TCL_ERROR;
-	}
+  badLevel:
+    Tcl_SetObjResult(interp, Tcl_NewStringObj("level must be 0 to 9", -1));
+    Tcl_SetErrorCode(interp, "TCL", "VALUE", "COMPRESSIONLEVEL", NULL);
+    if (extraInfoStr) {
+	Tcl_AddErrorInfo(interp, extraInfoStr);
+    }
+    return TCL_ERROR;
+  badBuffer:
+    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+	    "buffer size must be %d to %d",
+	    MIN_NONSTREAM_BUFFER_SIZE, MAX_BUFFER_SIZE));
+    Tcl_SetErrorCode(interp, "TCL", "VALUE", "BUFFERSIZE", NULL);
+    return TCL_ERROR;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ZlibStreamSubcmd --
+ *
+ *	Implementation of the [zlib stream] subcommand.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+ZlibStreamSubcmd(
+    Tcl_Interp *interp,
+    int objc,
+    Tcl_Obj *const objv[])
+{
+    static const char *const stream_formats[] = {
+	"compress", "decompress", "deflate", "gunzip", "gzip", "inflate",
+	NULL
+    };
+    enum zlibFormats {
+	FMT_COMPRESS, FMT_DECOMPRESS, FMT_DEFLATE, FMT_GUNZIP, FMT_GZIP,
+	FMT_INFLATE
+    };
+    int i, format, mode = 0, option, level;
+    typedef struct {
+	const char *name;
+	Tcl_Obj **valueVar;
+    } OptDescriptor;
+    Tcl_Obj *compDictObj = NULL;
+    Tcl_Obj *gzipHeaderObj = NULL;
+    Tcl_Obj *levelObj = NULL;
+    const OptDescriptor compressionOpts[] = {
+	{ "-dictionary", &compDictObj },
+	{ "-level", &levelObj },
+	{ NULL, NULL }
+    };
+    const OptDescriptor gzipOpts[] = {
+	{ "-header", &gzipHeaderObj },
+	{ "-level", &levelObj },
+	{ NULL, NULL }
+    };
+    const OptDescriptor expansionOpts[] = {
+	{ "-dictionary", &compDictObj },
+	{ NULL, NULL }
+    };
+    const OptDescriptor gunzipOpts[] = {
+	{ NULL, NULL }
+    };
+    const OptDescriptor *desc = NULL;
+    Tcl_ZlibStream zh;
 
-	if (TclGetChannelFromObj(interp, objv[3], &chan, &chanMode,
-		0) != TCL_OK) {
+    if (objc < 3 || !(objc & 1)) {
+	Tcl_WrongNumArgs(interp, 2, objv, "mode ?-option value...?");
+	return TCL_ERROR;
+    }
+    if (Tcl_GetIndexFromObj(interp, objv[2], stream_formats, "mode", 0,
+	    &format) != TCL_OK) {
+	return TCL_ERROR;
+    }
+
+    /*
+     * The format determines the compression mode and the options that may be
+     * specified.
+     */
+
+    switch ((enum zlibFormats) format) {
+    case FMT_DEFLATE:
+	desc = compressionOpts;
+	mode = TCL_ZLIB_STREAM_DEFLATE;
+	format = TCL_ZLIB_FORMAT_RAW;
+	break;
+    case FMT_INFLATE:
+	desc = expansionOpts;
+	mode = TCL_ZLIB_STREAM_INFLATE;
+	format = TCL_ZLIB_FORMAT_RAW;
+	break;
+    case FMT_COMPRESS:
+	desc = compressionOpts;
+	mode = TCL_ZLIB_STREAM_DEFLATE;
+	format = TCL_ZLIB_FORMAT_ZLIB;
+	break;
+    case FMT_DECOMPRESS:
+	desc = expansionOpts;
+	mode = TCL_ZLIB_STREAM_INFLATE;
+	format = TCL_ZLIB_FORMAT_ZLIB;
+	break;
+    case FMT_GZIP:
+	desc = gzipOpts;
+	mode = TCL_ZLIB_STREAM_DEFLATE;
+	format = TCL_ZLIB_FORMAT_GZIP;
+	break;
+    case FMT_GUNZIP:
+	desc = gunzipOpts;
+	mode = TCL_ZLIB_STREAM_INFLATE;
+	format = TCL_ZLIB_FORMAT_GZIP;
+	break;
+    default:
+	Tcl_Panic("should be unreachable");
+    }
+
+    /*
+     * Parse the options.
+     */
+
+    for (i=3 ; i<objc ; i+=2) {
+	if (Tcl_GetIndexFromObjStruct(interp, objv[i], desc,
+		sizeof(OptDescriptor), "option", 0, &option) != TCL_OK) {
 	    return TCL_ERROR;
 	}
+	*desc[option].valueVar = objv[i+1];
 
 	/*
-	 * Sanity checks.
+	 * Drop the cache on the option name; table address not constant.
 	 */
 
-	if (mode == TCL_ZLIB_STREAM_DEFLATE && !(chanMode & TCL_WRITABLE)) {
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "compression may only be applied to writable channels",
-		    -1));
-	    Tcl_SetErrorCode(interp, "TCL", "ZIP", "UNWRITABLE", NULL);
+	TclFreeIntRep(objv[i]);
+    }
+
+    /*
+     * If a compression level was given, parse it (integral: 0..9). Otherwise
+     * use the default.
+     */
+
+    if (levelObj == NULL) {
+	level = Z_DEFAULT_COMPRESSION;
+    } else if (Tcl_GetIntFromObj(interp, levelObj, &level) != TCL_OK) {
+	return TCL_ERROR;
+    } else if (level < 0 || level > 9) {
+	Tcl_SetObjResult(interp, Tcl_NewStringObj("level must be 0 to 9",-1));
+	Tcl_SetErrorCode(interp, "TCL", "VALUE", "COMPRESSIONLEVEL", NULL);
+	Tcl_AddErrorInfo(interp, "\n    (in -level option)");
+	return TCL_ERROR;
+    }
+
+    /*
+     * Construct the stream now we know its configuration.
+     */
+
+    if (Tcl_ZlibStreamInit(interp, mode, format, level, gzipHeaderObj,
+	    &zh) != TCL_OK) {
+	return TCL_ERROR;
+    }
+    if (compDictObj != NULL) {
+	Tcl_ZlibStreamSetCompressionDictionary(zh, compDictObj);
+    }
+    Tcl_SetObjResult(interp, Tcl_ZlibStreamGetCommandName(zh));
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ZlibPushSubcmd --
+ *
+ *	Implementation of the [zlib push] subcommand.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+ZlibPushSubcmd(
+    Tcl_Interp *interp,
+    int objc,
+    Tcl_Obj *const objv[])
+{
+    static const char *const stream_formats[] = {
+	"compress", "decompress", "deflate", "gunzip", "gzip", "inflate",
+	NULL
+    };
+    enum zlibFormats {
+	FMT_COMPRESS, FMT_DECOMPRESS, FMT_DEFLATE, FMT_GUNZIP, FMT_GZIP,
+	FMT_INFLATE
+    };
+    Tcl_Channel chan;
+    int chanMode, format, mode = 0, level, i, option;
+    static const char *const pushCompressOptions[] = {
+	"-dictionary", "-header", "-level", NULL
+    };
+    static const char *const pushDecompressOptions[] = {
+	"-dictionary", "-header", "-level", "-limit", NULL
+    };
+    const char *const *pushOptions = pushDecompressOptions;
+    enum pushOptions {poDictionary, poHeader, poLevel, poLimit};
+    Tcl_Obj *headerObj = NULL, *compDictObj = NULL;
+    int limit = 1, dummy;
+
+    if (objc < 4) {
+	Tcl_WrongNumArgs(interp, 2, objv, "mode channel ?options...?");
+	return TCL_ERROR;
+    }
+
+    if (Tcl_GetIndexFromObj(interp, objv[2], stream_formats, "mode", 0,
+	    &format) != TCL_OK) {
+	return TCL_ERROR;
+    }
+    switch ((enum zlibFormats) format) {
+    case FMT_DEFLATE:
+	mode = TCL_ZLIB_STREAM_DEFLATE;
+	format = TCL_ZLIB_FORMAT_RAW;
+	pushOptions = pushCompressOptions;
+	break;
+    case FMT_INFLATE:
+	mode = TCL_ZLIB_STREAM_INFLATE;
+	format = TCL_ZLIB_FORMAT_RAW;
+	break;
+    case FMT_COMPRESS:
+	mode = TCL_ZLIB_STREAM_DEFLATE;
+	format = TCL_ZLIB_FORMAT_ZLIB;
+	pushOptions = pushCompressOptions;
+	break;
+    case FMT_DECOMPRESS:
+	mode = TCL_ZLIB_STREAM_INFLATE;
+	format = TCL_ZLIB_FORMAT_ZLIB;
+	break;
+    case FMT_GZIP:
+	mode = TCL_ZLIB_STREAM_DEFLATE;
+	format = TCL_ZLIB_FORMAT_GZIP;
+	pushOptions = pushCompressOptions;
+	break;
+    case FMT_GUNZIP:
+	mode = TCL_ZLIB_STREAM_INFLATE;
+	format = TCL_ZLIB_FORMAT_GZIP;
+	break;
+    default:
+	Tcl_Panic("should be unreachable");
+    }
+
+    if (TclGetChannelFromObj(interp, objv[3], &chan, &chanMode, 0) != TCL_OK){
+	return TCL_ERROR;
+    }
+
+    /*
+     * Sanity checks.
+     */
+
+    if (mode == TCL_ZLIB_STREAM_DEFLATE && !(chanMode & TCL_WRITABLE)) {
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(
+		"compression may only be applied to writable channels", -1));
+	Tcl_SetErrorCode(interp, "TCL", "ZIP", "UNWRITABLE", NULL);
+	return TCL_ERROR;
+    }
+    if (mode == TCL_ZLIB_STREAM_INFLATE && !(chanMode & TCL_READABLE)) {
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(
+		"decompression may only be applied to readable channels",-1));
+	Tcl_SetErrorCode(interp, "TCL", "ZIP", "UNREADABLE", NULL);
+	return TCL_ERROR;
+    }
+
+    /*
+     * Parse options.
+     */
+
+    level = Z_DEFAULT_COMPRESSION;
+    for (i=4 ; i<objc ; i++) {
+	if (Tcl_GetIndexFromObj(interp, objv[i], pushOptions, "option", 0,
+		&option) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	if (mode == TCL_ZLIB_STREAM_INFLATE && !(chanMode & TCL_READABLE)) {
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "decompression may only be applied to readable channels",
-		    -1));
-	    Tcl_SetErrorCode(interp, "TCL", "ZIP", "UNREADABLE", NULL);
+	if (++i > objc-1) {
+	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+		    "value missing for %s option", pushOptions[option]));
+	    Tcl_SetErrorCode(interp, "TCL", "ZIP", "NOVAL", NULL);
 	    return TCL_ERROR;
 	}
-
-	/*
-	 * Parse options.
-	 */
-
-	level = Z_DEFAULT_COMPRESSION;
-	for (i=4 ; i<objc ; i++) {
-	    if (Tcl_GetIndexFromObj(interp, objv[i], pushOptions, "option", 0,
-		    &option) != TCL_OK) {
-		return TCL_ERROR;
+	switch ((enum pushOptions) option) {
+	case poHeader:
+	    headerObj = objv[i];
+	    if (Tcl_DictObjSize(interp, headerObj, &dummy) != TCL_OK) {
+		goto genericOptionError;
 	    }
-	    switch ((enum pushOptions) option) {
-	    case poHeader:
-		if (++i > objc-1) {
-		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "value missing for -header option", -1));
-		    Tcl_SetErrorCode(interp, "TCL", "ZIP", "NOVAL", NULL);
-		    return TCL_ERROR;
-		}
-		headerObj = objv[i];
-		if (Tcl_DictObjSize(interp, headerObj, &dummy) != TCL_OK) {
-		    Tcl_AddErrorInfo(interp, "\n    (in -header option)");
-		    return TCL_ERROR;
-		}
-		break;
-	    case poLevel:
-		if (++i > objc-1) {
-		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "value missing for -level option", -1));
-		    Tcl_SetErrorCode(interp, "TCL", "ZIP", "NOVAL", NULL);
-		    return TCL_ERROR;
-		}
-		if (Tcl_GetIntFromObj(interp, objv[i],
-			(int *) &level) != TCL_OK) {
-		    Tcl_AddErrorInfo(interp, "\n    (in -level option)");
-		    return TCL_ERROR;
-		}
-		if (level < 0 || level > 9) {
-		    extraInfoStr = "\n    (in -level option)";
-		    goto badLevel;
-		}
-		break;
-	    case poLimit:
-		if (++i > objc-1) {
-		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "value missing for -limit option", -1));
-		    Tcl_SetErrorCode(interp, "TCL", "ZIP", "NOVAL", NULL);
-		    return TCL_ERROR;
-		}
-		if (Tcl_GetIntFromObj(interp, objv[i],
-			(int *) &limit) != TCL_OK) {
-		    Tcl_AddErrorInfo(interp, "\n    (in -limit option)");
-		    return TCL_ERROR;
-		}
-		if (limit < 1) {
-		    limit = 1;
-		}
-		break;
+	    break;
+	case poLevel:
+	    if (Tcl_GetIntFromObj(interp, objv[i], (int*) &level) != TCL_OK) {
+		goto genericOptionError;
 	    }
+	    if (level < 0 || level > 9) {
+		Tcl_SetObjResult(interp, Tcl_NewStringObj(
+			"level must be 0 to 9", -1));
+		Tcl_SetErrorCode(interp, "TCL", "VALUE", "COMPRESSIONLEVEL",
+			NULL);
+		goto genericOptionError;
+	    }
+	    break;
+	case poLimit:
+	    if (Tcl_GetIntFromObj(interp, objv[i], (int*) &limit) != TCL_OK) {
+		goto genericOptionError;
+	    }
+	    if (limit < 1 || limit > MAX_BUFFER_SIZE) {
+		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+			"read ahead limit must be 1 to %d",
+			MAX_BUFFER_SIZE));
+		Tcl_SetErrorCode(interp, "TCL", "VALUE", "BUFFERSIZE", NULL);
+		goto genericOptionError;
+	    }
+	    break;
+	case poDictionary:
+	    if (format == TCL_ZLIB_FORMAT_GZIP) {
+		Tcl_SetObjResult(interp, Tcl_NewStringObj(
+			"a compression dictionary may not be set in the "
+			"gzip format", -1));
+		Tcl_SetErrorCode(interp, "TCL", "ZIP", "BADOPT", NULL);
+		goto genericOptionError;
+	    }
+	    compDictObj = objv[i];
+	    break;
 	}
-
-	if (ZlibStackChannelTransform(interp, mode, format, level, chan,
-		headerObj) == NULL) {
-	    return TCL_ERROR;
-	}
-	Tcl_SetObjResult(interp, objv[3]);
-	return TCL_OK;
     }
-    };
 
-    return TCL_ERROR;
-
-  badLevel:
-    Tcl_SetObjResult(interp, Tcl_NewStringObj("level must be 0 to 9", -1));
-    Tcl_SetErrorCode(interp, "TCL", "VALUE", "COMPRESSIONLEVEL", NULL);
-    if (extraInfoStr) {
-	Tcl_AddErrorInfo(interp, extraInfoStr);
+    if (ZlibStackChannelTransform(interp, mode, format, level, limit, chan,
+	    headerObj, compDictObj) == NULL) {
+	return TCL_ERROR;
     }
-    return TCL_ERROR;
-  badBuffer:
-    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-	    "buffer size must be 32 to 65536", -1));
-    Tcl_SetErrorCode(interp, "TCL", "VALUE", "BUFFERSIZE", NULL);
+    Tcl_SetObjResult(interp, objv[3]);
+    return TCL_OK;
+
+  genericOptionError:
+    Tcl_AddErrorInfo(interp, "\n    (in ");
+    Tcl_AddErrorInfo(interp, pushOptions[option]);
+    Tcl_AddErrorInfo(interp, " option)");
     return TCL_ERROR;
 }
 
@@ -2027,22 +2493,16 @@ ZlibStreamCmd(
     Tcl_Obj *const objv[])
 {
     Tcl_ZlibStream zstream = cd;
-    int command, index, count, code, buffersize = -1, flush = -1, i;
+    int command, count, code;
     Tcl_Obj *obj;
     static const char *const cmds[] = {
 	"add", "checksum", "close", "eof", "finalize", "flush",
-	"fullflush", "get", "put", "reset",
+	"fullflush", "get", "header", "put", "reset",
 	NULL
     };
     enum zlibStreamCommands {
 	zs_add, zs_checksum, zs_close, zs_eof, zs_finalize, zs_flush,
-	zs_fullflush, zs_get, zs_put, zs_reset
-    };
-    static const char *const add_options[] = {
-	"-buffer", "-finalize", "-flush", "-fullflush", NULL
-    };
-    enum addOptions {
-	ao_buffer, ao_finalize, ao_flush, ao_fullflush
+	zs_fullflush, zs_get, zs_header, zs_put, zs_reset
     };
 
     if (objc < 2) {
@@ -2057,125 +2517,11 @@ ZlibStreamCmd(
 
     switch ((enum zlibStreamCommands) command) {
     case zs_add:		/* $strm add ?$flushopt? $data */
-	for (i=2; i<objc-1; i++) {
-	    if (Tcl_GetIndexFromObj(interp, objv[i], add_options, "option", 0,
-		    &index) != TCL_OK) {
-		return TCL_ERROR;
-	    }
-
-	    switch ((enum addOptions) index) {
-	    case ao_flush: /* -flush */
-		if (flush > -1) {
-		    flush = -2;
-		} else {
-		    flush = Z_SYNC_FLUSH;
-		}
-		break;
-	    case ao_fullflush: /* -fullflush */
-		if (flush > -1) {
-		    flush = -2;
-		} else {
-		    flush = Z_FULL_FLUSH;
-		}
-		break;
-	    case ao_finalize: /* -finalize */
-		if (flush > -1) {
-		    flush = -2;
-		} else {
-		    flush = Z_FINISH;
-		}
-		break;
-	    case ao_buffer: /* -buffer */
-		if (i == objc-2) {
-		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "\"-buffer\" option must be followed by integer"
-			    " decompression buffersize", -1));
-		    Tcl_SetErrorCode(interp, "TCL", "ZIP", "NOVAL", NULL);
-		    return TCL_ERROR;
-		}
-		if (Tcl_GetIntFromObj(interp, objv[i+1],
-			&buffersize) != TCL_OK) {
-		    return TCL_ERROR;
-		}
-		if (buffersize < 1 || buffersize > 65536) {
-		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "buffer size must be 32 to 65536", -1));
-		    Tcl_SetErrorCode(interp, "TCL", "VALUE", "BUFFERSIZE",
-			    NULL);
-		    return TCL_ERROR;
-		}
-	    }
-
-	    if (flush == -2) {
-		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"\"-flush\", \"-fullflush\" and \"-finalize\" options"
-			" are mutually exclusive", -1));
-		Tcl_SetErrorCode(interp, "TCL", "ZIP", "EXCLUSIVE", NULL);
-		return TCL_ERROR;
-	    }
-	}
-	if (flush == -1) {
-	    flush = 0;
-	}
-
-	if (Tcl_ZlibStreamPut(zstream, objv[objc-1], flush) != TCL_OK) {
-	    return TCL_ERROR;
-	}
-	TclNewObj(obj);
-	code = Tcl_ZlibStreamGet(zstream, obj, buffersize);
-	if (code == TCL_OK) {
-	    Tcl_SetObjResult(interp, obj);
-	} else {
-	    TclDecrRefCount(obj);
-	}
-	return code;
-
+	return ZlibStreamAddCmd(zstream, interp, objc, objv);
+    case zs_header:		/* $strm header */
+	return ZlibStreamHeaderCmd(zstream, interp, objc, objv);
     case zs_put:		/* $strm put ?$flushopt? $data */
-	for (i=2; i<objc-1; i++) {
-	    if (Tcl_GetIndexFromObj(interp, objv[i], add_options, "option", 0,
-		    &index) != TCL_OK) {
-		return TCL_ERROR;
-	    }
-
-	    switch ((enum addOptions) index) {
-	    case ao_flush: /* -flush */
-		if (flush > -1) {
-		    flush = -2;
-		} else {
-		    flush = Z_SYNC_FLUSH;
-		}
-		break;
-	    case ao_fullflush: /* -fullflush */
-		if (flush > -1) {
-		    flush = -2;
-		} else {
-		    flush = Z_FULL_FLUSH;
-		}
-		break;
-	    case ao_finalize: /* -finalize */
-		if (flush > -1) {
-		    flush = -2;
-		} else {
-		    flush = Z_FINISH;
-		}
-		break;
-	    case ao_buffer:
-		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"\"-buffer\" option not supported here", -1));
-		return TCL_ERROR;
-	    }
-	    if (flush == -2) {
-		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"\"-flush\", \"-fullflush\" and \"-finalize\" options"
-			" are mutually exclusive", -1));
-		Tcl_SetErrorCode(interp, "TCL", "ZIP", "EXCLUSIVE", NULL);
-		return TCL_ERROR;
-	    }
-	}
-	if (flush == -1) {
-	    flush = 0;
-	}
-	return Tcl_ZlibStreamPut(zstream, objv[objc-1], flush);
+	return ZlibStreamPutCmd(zstream, interp, objc, objv);
 
     case zs_get:		/* $strm get ?count? */
 	if (objc > 3) {
@@ -2252,7 +2598,7 @@ ZlibStreamCmd(
 	    return TCL_ERROR;
 	}
 	Tcl_SetObjResult(interp, Tcl_NewWideIntObj((Tcl_WideInt)
-		Tcl_ZlibStreamChecksum(zstream)));
+		(uLong) Tcl_ZlibStreamChecksum(zstream)));
 	return TCL_OK;
     case zs_reset:		/* $strm reset */
 	if (objc != 2) {
@@ -2264,6 +2610,246 @@ ZlibStreamCmd(
 
     return TCL_OK;
 }
+
+static int
+ZlibStreamAddCmd(
+    ClientData cd,
+    Tcl_Interp *interp,
+    int objc,
+    Tcl_Obj *const objv[])
+{
+    Tcl_ZlibStream zstream = cd;
+    int index, code, buffersize = -1, flush = -1, i;
+    Tcl_Obj *obj, *compDictObj = NULL;
+    static const char *const add_options[] = {
+	"-buffer", "-dictionary", "-finalize", "-flush", "-fullflush", NULL
+    };
+    enum addOptions {
+	ao_buffer, ao_dictionary, ao_finalize, ao_flush, ao_fullflush
+    };
+
+    for (i=2; i<objc-1; i++) {
+	if (Tcl_GetIndexFromObj(interp, objv[i], add_options, "option", 0,
+		&index) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+
+	switch ((enum addOptions) index) {
+	case ao_flush: /* -flush */
+	    if (flush > -1) {
+		flush = -2;
+	    } else {
+		flush = Z_SYNC_FLUSH;
+	    }
+	    break;
+	case ao_fullflush: /* -fullflush */
+	    if (flush > -1) {
+		flush = -2;
+	    } else {
+		flush = Z_FULL_FLUSH;
+	    }
+	    break;
+	case ao_finalize: /* -finalize */
+	    if (flush > -1) {
+		flush = -2;
+	    } else {
+		flush = Z_FINISH;
+	    }
+	    break;
+	case ao_buffer: /* -buffer */
+	    if (i == objc-2) {
+		Tcl_SetObjResult(interp, Tcl_NewStringObj(
+			"\"-buffer\" option must be followed by integer "
+			"decompression buffersize", -1));
+		Tcl_SetErrorCode(interp, "TCL", "ZIP", "NOVAL", NULL);
+		return TCL_ERROR;
+	    }
+	    if (Tcl_GetIntFromObj(interp, objv[++i], &buffersize) != TCL_OK) {
+		return TCL_ERROR;
+	    }
+	    if (buffersize < 1 || buffersize > MAX_BUFFER_SIZE) {
+		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+			"buffer size must be 1 to %d",
+			MAX_BUFFER_SIZE));
+		Tcl_SetErrorCode(interp, "TCL", "VALUE", "BUFFERSIZE", NULL);
+		return TCL_ERROR;
+	    }
+	    break;
+	case ao_dictionary:
+	    if (i == objc-2) {
+		Tcl_SetObjResult(interp, Tcl_NewStringObj(
+			"\"-dictionary\" option must be followed by"
+			" compression dictionary bytes", -1));
+		Tcl_SetErrorCode(interp, "TCL", "ZIP", "NOVAL", NULL);
+		return TCL_ERROR;
+	    }
+	    compDictObj = objv[++i];
+	    break;
+	}
+
+	if (flush == -2) {
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
+		    "\"-flush\", \"-fullflush\" and \"-finalize\" options"
+		    " are mutually exclusive", -1));
+	    Tcl_SetErrorCode(interp, "TCL", "ZIP", "EXCLUSIVE", NULL);
+	    return TCL_ERROR;
+	}
+    }
+    if (flush == -1) {
+	flush = 0;
+    }
+
+    /*
+     * Set the compression dictionary if requested.
+     */
+
+    if (compDictObj != NULL) {
+	int len;
+
+	(void) Tcl_GetByteArrayFromObj(compDictObj, &len);
+	if (len == 0) {
+	    compDictObj = NULL;
+	}
+	Tcl_ZlibStreamSetCompressionDictionary(zstream, compDictObj);
+    }
+
+    /*
+     * Send the data to the stream core, along with any flushing directive.
+     */
+
+    if (Tcl_ZlibStreamPut(zstream, objv[objc-1], flush) != TCL_OK) {
+	return TCL_ERROR;
+    }
+
+    /*
+     * Get such data out as we can (up to the requested length).
+     */
+
+    TclNewObj(obj);
+    code = Tcl_ZlibStreamGet(zstream, obj, buffersize);
+    if (code == TCL_OK) {
+	Tcl_SetObjResult(interp, obj);
+    } else {
+	TclDecrRefCount(obj);
+    }
+    return code;
+}
+
+static int
+ZlibStreamPutCmd(
+    ClientData cd,
+    Tcl_Interp *interp,
+    int objc,
+    Tcl_Obj *const objv[])
+{
+    Tcl_ZlibStream zstream = cd;
+    int index, flush = -1, i;
+    Tcl_Obj *compDictObj = NULL;
+    static const char *const put_options[] = {
+	"-dictionary", "-finalize", "-flush", "-fullflush", NULL
+    };
+    enum putOptions {
+	po_dictionary, po_finalize, po_flush, po_fullflush
+    };
+
+    for (i=2; i<objc-1; i++) {
+	if (Tcl_GetIndexFromObj(interp, objv[i], put_options, "option", 0,
+		&index) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+
+	switch ((enum putOptions) index) {
+	case po_flush: /* -flush */
+	    if (flush > -1) {
+		flush = -2;
+	    } else {
+		flush = Z_SYNC_FLUSH;
+	    }
+	    break;
+	case po_fullflush: /* -fullflush */
+	    if (flush > -1) {
+		flush = -2;
+	    } else {
+		flush = Z_FULL_FLUSH;
+	    }
+	    break;
+	case po_finalize: /* -finalize */
+	    if (flush > -1) {
+		flush = -2;
+	    } else {
+		flush = Z_FINISH;
+	    }
+	    break;
+	case po_dictionary:
+	    if (i == objc-2) {
+		Tcl_SetObjResult(interp, Tcl_NewStringObj(
+			"\"-dictionary\" option must be followed by"
+			" compression dictionary bytes", -1));
+		Tcl_SetErrorCode(interp, "TCL", "ZIP", "NOVAL", NULL);
+		return TCL_ERROR;
+	    }
+	    compDictObj = objv[++i];
+	    break;
+	}
+	if (flush == -2) {
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
+		    "\"-flush\", \"-fullflush\" and \"-finalize\" options"
+		    " are mutually exclusive", -1));
+	    Tcl_SetErrorCode(interp, "TCL", "ZIP", "EXCLUSIVE", NULL);
+	    return TCL_ERROR;
+	}
+    }
+    if (flush == -1) {
+	flush = 0;
+    }
+
+    /*
+     * Set the compression dictionary if requested.
+     */
+
+    if (compDictObj != NULL) {
+	int len;
+
+	(void) Tcl_GetByteArrayFromObj(compDictObj, &len);
+	if (len == 0) {
+	    compDictObj = NULL;
+	}
+	Tcl_ZlibStreamSetCompressionDictionary(zstream, compDictObj);
+    }
+
+    /*
+     * Send the data to the stream core, along with any flushing directive.
+     */
+
+    return Tcl_ZlibStreamPut(zstream, objv[objc-1], flush);
+}
+
+static int
+ZlibStreamHeaderCmd(
+    ClientData cd,
+    Tcl_Interp *interp,
+    int objc,
+    Tcl_Obj *const objv[])
+{
+    ZlibStreamHandle *zshPtr = cd;
+    Tcl_Obj *resultObj;
+
+    if (objc != 2) {
+	Tcl_WrongNumArgs(interp, 2, objv, NULL);
+	return TCL_ERROR;
+    } else if (zshPtr->mode != TCL_ZLIB_STREAM_INFLATE
+	    || zshPtr->format != TCL_ZLIB_FORMAT_GZIP) {
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(
+		"only gunzip streams can produce header information", -1));
+	Tcl_SetErrorCode(interp, "TCL", "ZIP", "BADOP", NULL);
+	return TCL_ERROR;
+    }
+
+    TclNewObj(resultObj);
+    ExtractHeader(&zshPtr->gzHeaderPtr->header, resultObj);
+    Tcl_SetObjResult(interp, resultObj);
+    return TCL_OK;
+}
 
 /*
  *----------------------------------------------------------------------
@@ -2304,7 +2890,7 @@ ZlibTransformClose(
 	    if (e != Z_OK && e != Z_STREAM_END) {
 		/* TODO: is this the right way to do errors on close? */
 		if (!TclInThreadExit()) {
-		    ConvertError(interp, e);
+		    ConvertError(interp, e, cd->outStream.adler);
 		}
 		result = TCL_ERROR;
 		break;
@@ -2315,12 +2901,10 @@ ZlibTransformClose(
 		    /* TODO: is this the right way to do errors on close?
 		     * Note: when close is called from FinalizeIOSubsystem
 		     * then interp may be NULL */
-		    if (!TclInThreadExit()) {
-			if (interp) {
-			    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-				    "error while finalizing file: %s",
-				    Tcl_PosixError(interp)));
-			}
+		    if (!TclInThreadExit() && interp) {
+			Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+				"error while finalizing file: %s",
+				Tcl_PosixError(interp)));
 		    }
 		    result = TCL_ERROR;
 		    break;
@@ -2406,7 +2990,7 @@ ZlibTransformInput(
 	 * reading over the border.
 	 */
 
-	readBytes = Tcl_ReadRaw(cd->parent, cd->inBuffer, 1);
+	readBytes = Tcl_ReadRaw(cd->parent, cd->inBuffer, cd->readAheadLimit);
 
 	/*
 	 * Three cases here:
@@ -2520,6 +3104,7 @@ ZlibTransformOutput(
     Tcl_DriverOutputProc *outProc =
 	    Tcl_ChannelOutputProc(Tcl_GetChannelType(cd->parent));
     int e, produced;
+    Tcl_Obj *errObj;
 
     if (cd->mode == TCL_ZLIB_STREAM_INFLATE) {
 	return outProc(Tcl_GetChannelInstanceData(cd->parent), buf, toWrite,
@@ -2543,14 +3128,19 @@ ZlibTransformOutput(
 	}
     } while (e == Z_OK && produced > 0 && cd->outStream.avail_in > 0);
 
-    if (e != Z_OK) {
-	Tcl_SetChannelError(cd->parent,
-		Tcl_NewStringObj(cd->outStream.msg, -1));
-	*errorCodePtr = EINVAL;
-	return -1;
+    if (e == Z_OK) {
+	return toWrite - cd->outStream.avail_in;
     }
 
-    return toWrite - cd->outStream.avail_in;
+    errObj = Tcl_NewListObj(0, NULL);
+    Tcl_ListObjAppendElement(NULL, errObj, Tcl_NewStringObj("-errorcode",-1));
+    Tcl_ListObjAppendElement(NULL, errObj,
+	    ConvertErrorToList(e, cd->outStream.adler));
+    Tcl_ListObjAppendElement(NULL, errObj,
+	    Tcl_NewStringObj(cd->outStream.msg, -1));
+    Tcl_SetChannelError(cd->parent, errObj);
+    *errorCodePtr = EINVAL;
+    return -1;
 }
 
 /*
@@ -2573,58 +3163,113 @@ ZlibTransformSetOption(			/* not used */
     ZlibChannelData *cd = instanceData;
     Tcl_DriverSetOptionProc *setOptionProc =
 	    Tcl_ChannelSetOptionProc(Tcl_GetChannelType(cd->parent));
-    static const char *chanOptions = "flush";
+    static const char *compressChanOptions = "dictionary flush";
+    static const char *gzipChanOptions = "flush";
+    static const char *decompressChanOptions = "dictionary limit";
+    static const char *gunzipChanOptions = "flush limit";
     int haveFlushOpt = (cd->mode == TCL_ZLIB_STREAM_DEFLATE);
 
-    if (haveFlushOpt && optionName && strcmp(optionName, "-flush") == 0) {
-	int flushType;
+    if (optionName && (strcmp(optionName, "-dictionary") == 0)
+	    && (cd->format != TCL_ZLIB_FORMAT_GZIP)) {
+	Tcl_Obj *compDictObj;
+	int code;
 
-	if (value[0] == 'f' && strcmp(value, "full") == 0) {
-	    flushType = Z_FULL_FLUSH;
-	} else if (value[0] == 's' && strcmp(value, "sync") == 0) {
-	    flushType = Z_SYNC_FLUSH;
-	} else {
-	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-		    "unknown -flush type \"%s\": must be full or sync",
-		    value));
-	    Tcl_SetErrorCode(interp, "TCL", "VALUE", "FLUSH", NULL);
-	    return TCL_ERROR;
+	TclNewStringObj(compDictObj, value, strlen(value));
+	Tcl_IncrRefCount(compDictObj);
+	(void) Tcl_GetByteArrayFromObj(compDictObj, NULL);
+	if (cd->compDictObj) {
+	    TclDecrRefCount(cd->compDictObj);
+	}
+	cd->compDictObj = compDictObj;
+	code = Z_OK;
+	if (cd->mode == TCL_ZLIB_STREAM_DEFLATE) {
+	    code = SetDeflateDictionary(&cd->outStream, compDictObj);
+	    if (code != Z_OK) {
+		ConvertError(interp, code, cd->outStream.adler);
+		return TCL_ERROR;
+	    }
+	} else if (cd->format == TCL_ZLIB_FORMAT_RAW) {
+	    code = SetInflateDictionary(&cd->inStream, compDictObj);
+	    if (code != Z_OK) {
+		ConvertError(interp, code, cd->inStream.adler);
+		return TCL_ERROR;
+	    }
 	}
+	return TCL_OK;
+    }
 
-	/*
-	 * Try to actually do the flush now.
-	 */
+    if (haveFlushOpt) {
+	if (optionName && strcmp(optionName, "-flush") == 0) {
+	    int flushType;
 
-	cd->outStream.avail_in = 0;
-	while (1) {
-	    int e;
+	    if (value[0] == 'f' && strcmp(value, "full") == 0) {
+		flushType = Z_FULL_FLUSH;
+	    } else if (value[0] == 's' && strcmp(value, "sync") == 0) {
+		flushType = Z_SYNC_FLUSH;
+	    } else {
+		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+			"unknown -flush type \"%s\": must be full or sync",
+			value));
+		Tcl_SetErrorCode(interp, "TCL", "VALUE", "FLUSH", NULL);
+		return TCL_ERROR;
+	    }
 
-	    cd->outStream.next_out = (Bytef *) cd->outBuffer;
-	    cd->outStream.avail_out = cd->outAllocated;
+	    /*
+	     * Try to actually do the flush now.
+	     */
 
-	    e = deflate(&cd->outStream, flushType);
-	    if (e == Z_BUF_ERROR) {
-		break;
-	    } else if (e != Z_OK) {
-		ConvertError(interp, e);
-		return TCL_ERROR;
-	    } else if (cd->outStream.avail_out == 0) {
-		break;
+	    cd->outStream.avail_in = 0;
+	    while (1) {
+		int e;
+
+		cd->outStream.next_out = (Bytef *) cd->outBuffer;
+		cd->outStream.avail_out = cd->outAllocated;
+
+		e = deflate(&cd->outStream, flushType);
+		if (e == Z_BUF_ERROR) {
+		    break;
+		} else if (e != Z_OK) {
+		    ConvertError(interp, e, cd->outStream.adler);
+		    return TCL_ERROR;
+		} else if (cd->outStream.avail_out == 0) {
+		    break;
+		}
+
+		if (Tcl_WriteRaw(cd->parent, cd->outBuffer,
+			cd->outStream.next_out - (Bytef *) cd->outBuffer)<0) {
+		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+			    "problem flushing channel: %s",
+			    Tcl_PosixError(interp)));
+		    return TCL_ERROR;
+		}
 	    }
+	    return TCL_OK;
+	}
+    } else {
+	if (optionName && strcmp(optionName, "-limit") == 0) {
+	    int newLimit;
 
-	    if (Tcl_WriteRaw(cd->parent, cd->outBuffer,
-		    cd->outStream.next_out - (Bytef *) cd->outBuffer) < 0) {
-		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-			"problem flushing channel: %s",
-			Tcl_PosixError(interp)));
+	    if (Tcl_GetInt(interp, value, &newLimit) != TCL_OK) {
+		return TCL_ERROR;
+	    } else if (newLimit < 1 || newLimit > MAX_BUFFER_SIZE) {
+		Tcl_SetObjResult(interp, Tcl_NewStringObj(
+			"-limit must be between 1 and 65536", -1));
+		Tcl_SetErrorCode(interp, "TCL", "VALUE", "READLIMIT", NULL);
 		return TCL_ERROR;
 	    }
 	}
-	return TCL_OK;
     }
 
     if (setOptionProc == NULL) {
-	return Tcl_BadChannelOption(interp, optionName, chanOptions);
+	if (cd->format == TCL_ZLIB_FORMAT_GZIP) {
+	    return Tcl_BadChannelOption(interp, optionName,
+		    (cd->mode == TCL_ZLIB_STREAM_DEFLATE)
+		    ? gzipChanOptions : gunzipChanOptions);
+	} else {
+	    return Tcl_BadChannelOption(interp, optionName,
+		    (cd->mode == TCL_ZLIB_STREAM_DEFLATE)
+		    ? compressChanOptions : decompressChanOptions);
+	}
     }
 
     /*
@@ -2656,7 +3301,10 @@ ZlibTransformGetOption(
     ZlibChannelData *cd = instanceData;
     Tcl_DriverGetOptionProc *getOptionProc =
 	    Tcl_ChannelGetOptionProc(Tcl_GetChannelType(cd->parent));
-    static const char *chanOptions = "checksum header";
+    static const char *compressChanOptions = "checksum dictionary";
+    static const char *gzipChanOptions = "checksum";
+    static const char *decompressChanOptions = "checksum dictionary limit";
+    static const char *gunzipChanOptions = "checksum header limit";
 
     /*
      * The "crc" option reports the current CRC (calculated with the Adler32
@@ -2684,6 +3332,28 @@ ZlibTransformGetOption(
 	}
     }
 
+    if ((cd->format != TCL_ZLIB_FORMAT_GZIP) &&
+	    (optionName == NULL || strcmp(optionName, "-dictionary") == 0)) {
+	/*
+	 * Embedded NUL bytes are ok; they'll be C080-encoded.
+	 */
+
+	if (optionName == NULL) {
+	    Tcl_DStringAppendElement(dsPtr, "-dictionary");
+	    if (cd->compDictObj) {
+		Tcl_DStringAppendElement(dsPtr,
+			Tcl_GetString(cd->compDictObj));
+	    } else {
+		Tcl_DStringAppendElement(dsPtr, "");
+	    }
+	} else {
+	    int len;
+	    const char *str = Tcl_GetStringFromObj(cd->compDictObj, &len);
+
+	    Tcl_DStringAppend(dsPtr, str, len);
+	}
+    }
+
     /*
      * The "header" option, which is only valid on inflating gzip channels,
      * reports the header that has been read from the start of the stream.
@@ -2716,7 +3386,15 @@ ZlibTransformGetOption(
     if (optionName == NULL) {
 	return TCL_OK;
     }
-    return Tcl_BadChannelOption(interp, optionName, chanOptions);
+    if (cd->format == TCL_ZLIB_FORMAT_GZIP) {
+	return Tcl_BadChannelOption(interp, optionName,
+		(cd->mode == TCL_ZLIB_STREAM_DEFLATE)
+		? gzipChanOptions : gunzipChanOptions);
+    } else {
+	return Tcl_BadChannelOption(interp, optionName,
+		(cd->mode == TCL_ZLIB_STREAM_DEFLATE)
+		? compressChanOptions : decompressChanOptions);
+    }
 }
 
 /*
@@ -2861,10 +3539,15 @@ ZlibStackChannelTransform(
 				 * decompressing transforms. */
     int level,			/* What compression level to use. Ignored for
 				 * decompressing transforms. */
+    int limit,			/* The limit on the number of bytes to read
+				 * ahead; always at least 1. */
     Tcl_Channel channel,	/* The channel to attach to. */
-    Tcl_Obj *gzipHeaderDictPtr)	/* A description of header to use, or NULL to
+    Tcl_Obj *gzipHeaderDictPtr,	/* A description of header to use, or NULL to
 				 * use a default. Ignored if not compressing
 				 * to produce gzip-format data. */
+    Tcl_Obj *compDictObj)	/* Byte-array object containing compression
+				 * dictionary (not dictObj!) to use if
+				 * necessary. */
 {
     ZlibChannelData *cd = ckalloc(sizeof(ZlibChannelData));
     Tcl_Channel chan;
@@ -2877,15 +3560,15 @@ ZlibStackChannelTransform(
 
     memset(cd, 0, sizeof(ZlibChannelData));
     cd->mode = mode;
+    cd->format = format;
+    cd->readAheadLimit = limit;
 
     if (format == TCL_ZLIB_FORMAT_GZIP || format == TCL_ZLIB_FORMAT_AUTO) {
 	if (mode == TCL_ZLIB_STREAM_DEFLATE) {
 	    if (gzipHeaderDictPtr) {
-		int dummy = 0;
-
 		cd->flags |= OUT_HEADER;
 		if (GenerateHeader(interp, gzipHeaderDictPtr, &cd->outHeader,
-			&dummy) != TCL_OK) {
+			NULL) != TCL_OK) {
 		    goto error;
 		}
 	    }
@@ -2900,6 +3583,12 @@ ZlibStackChannelTransform(
 	}
     }
 
+    if (compDictObj != NULL) {
+	cd->compDictObj = Tcl_DuplicateObj(compDictObj);
+	Tcl_IncrRefCount(cd->compDictObj);
+	Tcl_GetByteArrayFromObj(cd->compDictObj, NULL);
+    }
+
     if (format == TCL_ZLIB_FORMAT_RAW) {
 	wbits = WBITS_RAW;
     } else if (format == TCL_ZLIB_FORMAT_ZLIB) {
@@ -2929,6 +3618,14 @@ ZlibStackChannelTransform(
 		goto error;
 	    }
 	}
+	if (cd->format == TCL_ZLIB_FORMAT_RAW && cd->compDictObj) {
+	    e = SetInflateDictionary(&cd->inStream, cd->compDictObj);
+	    if (e != Z_OK) {
+		goto error;
+	    }
+	    TclDecrRefCount(cd->compDictObj);
+	    cd->compDictObj = NULL;
+	}
     } else {
 	e = deflateInit2(&cd->outStream, level, Z_DEFLATED, wbits,
 		MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY);
@@ -2943,6 +3640,12 @@ ZlibStackChannelTransform(
 		goto error;
 	    }
 	}
+	if (cd->compDictObj) {
+	    e = SetDeflateDictionary(&cd->outStream, cd->compDictObj);
+	    if (e != Z_OK) {
+		goto error;
+	    }
+	}
     }
 
     Tcl_DStringInit(&cd->decompressed);
@@ -2966,6 +3669,9 @@ ZlibStackChannelTransform(
 	ckfree(cd->outBuffer);
 	deflateEnd(&cd->outStream);
     }
+    if (cd->compDictObj) {
+	Tcl_DecrRefCount(cd->compDictObj);
+    }
     ckfree(cd);
     return NULL;
 }
@@ -3055,6 +3761,7 @@ ResultGenerate(
 #define MAXBUF	1024
     unsigned char buf[MAXBUF];
     int e, written;
+    Tcl_Obj *errObj;
 
     cd->inStream.next_in = (Bytef *) cd->inBuffer;
     cd->inStream.avail_in = n;
@@ -3064,6 +3771,18 @@ ResultGenerate(
 	cd->inStream.avail_out = MAXBUF;
 
 	e = inflate(&cd->inStream, flush);
+	if (e == Z_NEED_DICT && cd->compDictObj) {
+	    e = SetInflateDictionary(&cd->inStream, cd->compDictObj);
+	    if (e == Z_OK) {
+		/*
+		 * A repetition of Z_NEED_DICT is just an error.
+		 */
+
+		cd->inStream.next_out = (Bytef *) buf;
+		cd->inStream.avail_out = MAXBUF;
+		e = inflate(&cd->inStream, flush);
+	    }
+	}
 
 	/*
 	 * avail_out is now the left over space in the output.  Therefore
@@ -3095,13 +3814,7 @@ ResultGenerate(
 	 */
 
 	if ((e != Z_OK) && (e != Z_BUF_ERROR)) {
-	    Tcl_Obj *errObj = Tcl_NewListObj(0, NULL);
-
-	    Tcl_ListObjAppendElement(NULL, errObj,
-		    Tcl_NewStringObj(cd->inStream.msg, -1));
-	    Tcl_SetChannelError(cd->parent, errObj);
-	    *errorCodePtr = EINVAL;
-	    return TCL_ERROR;
+	    goto handleError;
 	}
 
 	/*
@@ -3112,6 +3825,17 @@ ResultGenerate(
 	    return TCL_OK;
 	}
     }
+
+  handleError:
+    errObj = Tcl_NewListObj(0, NULL);
+    Tcl_ListObjAppendElement(NULL, errObj, Tcl_NewStringObj("-errorcode",-1));
+    Tcl_ListObjAppendElement(NULL, errObj,
+	    ConvertErrorToList(e, cd->inStream.adler));
+    Tcl_ListObjAppendElement(NULL, errObj,
+	    Tcl_NewStringObj(cd->inStream.msg, -1));
+    Tcl_SetChannelError(cd->parent, errObj);
+    *errorCodePtr = EINVAL;
+    return TCL_ERROR;
 }
 
 /*
@@ -3124,6 +3848,8 @@ int
 TclZlibInit(
     Tcl_Interp *interp)
 {
+    Tcl_Config cfg[2];
+
     /*
      * This does two things. It creates a counter used in the creation of
      * stream commands, and it creates the namespace that will contain those
@@ -3137,6 +3863,23 @@ TclZlibInit(
      */
 
     Tcl_CreateObjCommand(interp, "zlib", ZlibCmd, 0, 0);
+
+    /*
+     * Store the underlying configuration information.
+     *
+     * TODO: Describe whether we're using the system version of the library or
+     * a compatibility version built into Tcl?
+     */
+
+    cfg[0].key = "zlibVersion";
+    cfg[0].value = zlibVersion();
+    cfg[1].key = NULL;
+    Tcl_RegisterConfig(interp, "zlib", cfg, "ascii");
+
+    /*
+     * Formally provide the package as a Tcl built-in.
+     */
+
     return Tcl_PkgProvide(interp, "zlib", TCL_ZLIB_VERSION);
 }
 
@@ -3258,6 +4001,14 @@ Tcl_ZlibAdler32(
 {
     return 0;
 }
+
+void
+Tcl_ZlibStreamSetCompressionDictionary(
+    Tcl_ZlibStream zshandle,
+    Tcl_Obj *compressionDictionaryObj)
+{
+    /* Do nothing. */
+}
 #endif /* HAVE_ZLIB */
 
 /*