TB9.2 Example Applications: examples/PIPS/antiword/src/asc85enc.c Source File

00001 /*
-00002  * asc85enc.c
-00003  * Copyright (C) 2000-2003 A.J. van Os; Released under GPL
-00004  *
-00005  * Description:
-00006  * Functions to for ASCII 85 encoding
-00007  *
-00008  *====================================================================
-00009  * This part of the software is based on:
-00010  * asc85ec.c - ASCII85 and Hex encoding for PostScript Level 2 and PDF
-00011  * Copyright (C) 1994-99 Thomas Merz (tm@muc.de)
-00012  *====================================================================
-00013  * The credit should go to him, but all the bugs are mine.
-00014  */
-00015 
-00016 #include <stdio.h>
-00017 #include "antiword.h"
-00018 
-00019 static const ULONG      aulPower85[5] = {
-00020         1UL, 85UL, 85UL * 85, 85UL * 85 * 85, 85UL * 85 * 85 * 85,
-00021 };
-00022 static int      iOutBytes = 0;  /* Number of characters in an output line */
-00023 static char     cCharPrev = '\0';
-00024 
-00025 /*
-00026  * Two percent characters at the start of a line will cause trouble
-00027  * with some post-processing software. In order to avoid this, we
-00028  * simply insert a line break if we encounter two percent characters
-00029  * at the start of the line. Of course, this rather simplistic
-00030  * algorithm may lead to a large line count in pathological cases,
-00031  * but the chance for hitting such a case is very small, and even
-00032  * so it's only a cosmetic flaw and not a functional restriction.
-00033  */
-00034 
-00035 /*
-00036  * vOutputByte - output one byte
-00037  */
-00038 static void
-00039 vOutputByte(ULONG ulChar, FILE *pOutFile)
-00040 {
-00041         if (iOutBytes == 1 && cCharPrev == '%' && ulChar == (ULONG)'%') {
-00042                 if (putc('\n', pOutFile) != EOF) {
-00043                         iOutBytes = 0;
-00044                 }
-00045         }
-00046         if (putc((int)ulChar, pOutFile) == EOF) {
-00047                 return;
-00048         }
-00049         iOutBytes++;
-00050         if (iOutBytes > 63) {
-00051                 if (putc('\n', pOutFile) != EOF) {
-00052                         iOutBytes = 0;
-00053                 }
-00054         }
-00055         cCharPrev = (char)ulChar;
-00056 } /* end of vOutputByte */
-00057 
-00058 /*
-00059  * vASCII85EncodeByte - ASCII 85 encode a byte
-00060  */
-00061 void
-00062 vASCII85EncodeByte(FILE *pOutFile, int iByte)
-00063 {
-00064         static ULONG    ulBuffer[4] = { 0, 0, 0, 0 };
-00065         static int      iInBuffer = 0;
-00066         ULONG   ulValue, ulTmp;
-00067         int     iIndex;
-00068 
-00069         fail(pOutFile == NULL);
-00070         fail(iInBuffer < 0);
-00071         fail(iInBuffer > 3);
-00072 
-00073         if (iByte == EOF) {
-00074                 /* End Of File, time to clean up */
-00075                 if (iInBuffer > 0 && iInBuffer < 4) {
-00076                         /* Encode the remaining bytes */
-00077                         ulValue = 0;
-00078                         for (iIndex = iInBuffer - 1; iIndex >= 0; iIndex--) {
-00079                                 ulValue |=
-00080                                         ulBuffer[iIndex] << (8 * (3 - iIndex));
-00081                         }
-00082                         for (iIndex = 4; iIndex >= 4 - iInBuffer; iIndex--) {
-00083                                 ulTmp = ulValue / aulPower85[iIndex];
-00084                                 vOutputByte(ulTmp + '!', pOutFile);
-00085                                 ulValue -= ulTmp * aulPower85[iIndex];
-00086                         }
-00087                 }
-00088                 /* Add the End Of Data marker */
-00089                 (void)putc('~', pOutFile);
-00090                 (void)putc('>', pOutFile);
-00091                 (void)putc('\n', pOutFile);
-00092                 /* Reset the control variables */
-00093                 iInBuffer = 0;
-00094                 iOutBytes = 0;
-00095                 cCharPrev = '\0';
-00096                 return;
-00097         }
-00098 
-00099         ulBuffer[iInBuffer] = (ULONG)iByte & 0xff;
-00100         iInBuffer++;
-00101 
-00102         if (iInBuffer >= 4) {
-00103                 ulValue = (ulBuffer[0] << 24) | (ulBuffer[1] << 16) |
-00104                         (ulBuffer[2] << 8) | ulBuffer[3];
-00105                 if (ulValue == 0) {
-00106                         vOutputByte((ULONG)'z', pOutFile); /* Shortcut for 0 */
-00107                 } else {
-00108                         for (iIndex = 4; iIndex >= 0; iIndex--) {
-00109                                 ulTmp = ulValue / aulPower85[iIndex];
-00110                                 vOutputByte(ulTmp + '!', pOutFile);
-00111                                 ulValue -= ulTmp * aulPower85[iIndex];
-00112                         }
-00113                 }
-00114                 /* Reset the buffer */
-00115                 iInBuffer = 0;
-00116         }
-00117 } /* end of vASCII85EncodeByte */
-00118 
-00119 /*
-00120  * vASCII85EncodeArray - ASCII 85 encode a byte array
-00121  */
-00122 void
-00123 vASCII85EncodeArray(FILE *pInFile, FILE *pOutFile, size_t tLength)
-00124 {
-00125         size_t  tCount;
-00126         int     iByte;
-00127 
-00128         fail(pInFile == NULL);
-00129         fail(pOutFile == NULL);
-00130 
-00131         DBG_DEC(tLength);
-00132 
-00133         for (tCount = 0; tCount < tLength; tCount++) {
-00134                 iByte = iNextByte(pInFile);
-00135                 if (iByte == EOF) {
-00136                         break;
-00137                 }
-00138                 vASCII85EncodeByte(pOutFile, iByte);
-00139         }
-00140 } /* end of vASCII85EncodeArray */
-00141 
-00142 /*
-00143  * vASCII85EncodeFile - ASCII 85 encode part of a file
-00144  */
-00145 void
-00146 vASCII85EncodeFile(FILE *pInFile, FILE *pOutFile, size_t tLength)
-00147 {
-00148         fail(pInFile == NULL);
-00149         fail(pOutFile == NULL);
-00150         fail(tLength == 0);
-00151 
-00152         vASCII85EncodeArray(pInFile, pOutFile, tLength);
-00153         vASCII85EncodeByte(pOutFile, EOF);
-00154 } /* end of vASCII85EncodeFile */
-