diff options
Diffstat (limited to 'parts/documentation/protocols/chm')
| -rw-r--r-- | parts/documentation/protocols/chm/Makefile.am | 21 | ||||
| -rw-r--r-- | parts/documentation/protocols/chm/chm.cpp | 362 | ||||
| -rw-r--r-- | parts/documentation/protocols/chm/chm.h | 47 | ||||
| -rw-r--r-- | parts/documentation/protocols/chm/chm.protocol | 36 | ||||
| -rw-r--r-- | parts/documentation/protocols/chm/chmfile.cpp | 197 | ||||
| -rw-r--r-- | parts/documentation/protocols/chm/chmfile.h | 53 | ||||
| -rw-r--r-- | parts/documentation/protocols/chm/decompress.cpp | 796 | ||||
| -rw-r--r-- | parts/documentation/protocols/chm/decompress.h | 43 | ||||
| -rw-r--r-- | parts/documentation/protocols/chm/kchmpart.cpp | 123 | ||||
| -rw-r--r-- | parts/documentation/protocols/chm/kchmpart.desktop | 46 | ||||
| -rw-r--r-- | parts/documentation/protocols/chm/kchmpart.h | 82 |
11 files changed, 1806 insertions, 0 deletions
diff --git a/parts/documentation/protocols/chm/Makefile.am b/parts/documentation/protocols/chm/Makefile.am new file mode 100644 index 00000000..59d02cfd --- /dev/null +++ b/parts/documentation/protocols/chm/Makefile.am @@ -0,0 +1,21 @@ +## Makefile.am of kdebase/kioslave/chm + +INCLUDES = -I$(top_srcdir)/lib/widgets $(all_includes) + +kde_module_LTLIBRARIES = kio_chm.la libkchmpart.la + +kio_chm_la_SOURCES = decompress.cpp chmfile.cpp chm.cpp +kio_chm_la_LIBADD = $(LIB_KIO) +kio_chm_la_LDFLAGS = $(all_libraries) -module $(KDE_PLUGIN) + +libkchmpart_la_SOURCES = kchmpart.cpp +libkchmpart_la_LIBADD = -lkhtml $(LIB_KPARTS) $(top_builddir)/lib/widgets/libkdevwidgets.la +libkchmpart_la_LDFLAGS = $(all_libraries) $(KDE_PLUGIN) + +noinst_HEADERS = chm.h chmfile.h decompress.h kchmpart.h + +kdelnk_DATA = chm.protocol kchmpart.desktop +kdelnkdir = $(kde_servicesdir) + +METASOURCES = AUTO + diff --git a/parts/documentation/protocols/chm/chm.cpp b/parts/documentation/protocols/chm/chm.cpp new file mode 100644 index 00000000..1383d2b6 --- /dev/null +++ b/parts/documentation/protocols/chm/chm.cpp @@ -0,0 +1,362 @@ +/* This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#include <qcstring.h> +#include <qbitarray.h> +#include <qfile.h> +#include <qregexp.h> +#include <stack> + +#include <stdlib.h> +#include <unistd.h> +#include <sys/stat.h> + +#include <kapplication.h> +#include <kdebug.h> +#include <kinstance.h> +#include <kglobal.h> +#include <kurl.h> +#include <kmimemagic.h> +#include <ktempfile.h> + +#include "chm.h" + + +using namespace KIO; + +extern "C" +{ + int kdemain( int argc, char **argv ) + { + KInstance instance( "kio_chm" ); + + kdDebug() << "*** Starting kio_chm " << endl; + + if (argc != 4) { + kdDebug() << "Usage: kio_chm protocol domain-socket1 domain-socket2" << endl; + exit(-1); + } + + ChmProtocol slave(argv[2], argv[3]); + slave.dispatchLoop(); + + kdDebug() << "*** kio_chm Done" << endl; + return 0; + } +} + +ChmProtocol::ChmProtocol(const QCString &pool_socket, const QCString &app_socket) +: SlaveBase("kio_chm", pool_socket, app_socket) +{ + kdDebug() << "ChmProtocol::ChmProtocol()" << endl; +} +/* ---------------------------------------------------------------------------------- */ + + +ChmProtocol::~ChmProtocol() +{ + kdDebug() << "ChmProtocol::~ChmProtocol()" << endl; +} + + +/* ---------------------------------------------------------------------------------- */ +void ChmProtocol::get( const KURL& url ) +{ + /** When :catalog is appended to the end, a plain-text representation of the catalog + * is given out where each entry consists of four lines, an integer representing the parent + * of the node, an integer representing a node's ID, the Title of the Node, and it's hyperlink. + * When :contents is appended, all contained htm- and html-files will be printed, each in a line. + */ + kdDebug() << "kio_chm::get(const KURL& url) " << url.path() << endl; + + bool catalog = false; + bool contents = false; + QString bigpath = url.path(); + + if(bigpath.endsWith(":catalog")) { + catalog = true; + int len = QString(":catalog").length(); + bigpath.remove(bigpath.length() - len, len); ///strip :catalog from the end + } + + if(bigpath.endsWith(":contents")) { + contents = true; + int len = QString(":contents").length(); + bigpath.remove(bigpath.length() - len, len); ///strip :catalog from the end + } + + QString path; + if ( !checkNewFile( bigpath, path ) ) { + error( KIO::ERR_DOES_NOT_EXIST, url.prettyURL() ); + return; + } + + + if (m_dirMap.find(path) == m_dirMap.end()) { + error( KIO::ERR_DOES_NOT_EXIST, url.prettyURL() ); + return; + } + + QByteArray theData; + + //init.. + //added by lucida lucida@users.sf.net + QString fname = QString(); + QString chmpath = QString(); + KTempFile f("",".html"); + fname = f.name(); + QTextStream *t = f.textStream(); + QString firstPage = QString(""); + QString m_strIndex = QString(""); + QString tmpstr = QString(""); + bool m_bIndex = 0; + + + if(contents) { + QString output; + KURL u = url; + + ChmDirectoryMap::Iterator it; + for ( it = m_dirMap.begin(); it != m_dirMap.end(); ++it) { + u.setPath(bigpath); + u.addPath(it.key()); + output += u.prettyURL() + "\n"; + } + + data(output.local8Bit()); + processedSize(output.length()); + finished(); + return; + } + + + //try get some page to display, if the chm missing index + ChmDirectoryMap::Iterator it; + for ( it = m_dirMap.begin(); it != m_dirMap.end(); ++it) { + tmpstr.sprintf("%s", it.key().latin1()); + if ((m_strIndex == "") && + (tmpstr.endsWith(".htm") || tmpstr.endsWith(".html"))) + m_strIndex = tmpstr; + if ((tmpstr == "/index.htm") || (tmpstr == "/index.html")) { + m_strIndex = tmpstr; + break; + } + } + m_strIndex.remove(0,1); + + + if (path == "/" || catalog) { + bool htmlOutput = !catalog; + int offset = m_dirMap["/@contents"].offset; + int length = m_dirMap["/@contents"].length; + theData.setRawData(&m_contents[offset], length); + QString s(theData); + QString output; + + QRegExp object("<OBJECT type=\"text/sitemap\">(.*)</OBJECT>", false); + object.setMinimal(true); + + QRegExp nameParam("<param name=\"Name\" value=\"(.*)\">", false); + nameParam.setMinimal(true); + + QRegExp localParam("<param name=\"Local\" value=\"(.*)\">", false); + localParam.setMinimal(true); + + QRegExp mergeParam("<param name=\"Merge\" value=\"(.*)\">", false); + mergeParam.setMinimal(true); + + std::stack<int> parents; + int counter = 1; + int current = 0; + int old = 0, pos = 0; + parents.push(0); + while ((pos = s.find(object, pos)) != -1) { + if(htmlOutput) output += s.mid(old, pos - old); + if(catalog) { + QRegExp ex("<UL>|</UL>", false); ex.setMinimal(true); + QString ms = s.mid(old, pos - old); + int pos = 0; + while( (pos = ms.find(ex, pos)) != -1) { + if(ms.mid(pos, 4) == "<UL>") { + parents.push(current); + } else{ + if(parents.empty()){ + }else{ + current = parents.top(); + parents.pop(); + } + } + pos++; + } + } + pos += object.matchedLength(); + old = pos; + QString obj = object.cap(1); + QString name, local; + if (obj.find(nameParam) != -1) { + name = nameParam.cap(1); + if (obj.find(localParam) != -1) { + local = localParam.cap(1); + //output += "<a href=\"" + local + "\">" + name + "</a>"; + //added by lucida lucida@users.sf.net + if (local != "" && local != "/") { + if(!catalog) { + output += "<a target=\"browse\" href=\"" + url.url() + local + "\">" + name + "</a>"; + }else{ + current = counter; + ++counter; + KURL u = url; + u.setPath(bigpath + local); + QString str; + output += str.sprintf("%i\n%i\n", parents.top(), current); + output += name + "\n" + u.prettyURL() + "\n"; + } + m_bIndex = 1; + if (firstPage == "") firstPage = url.url()+QString::fromLocal8Bit(local.latin1()); + } + else + if(htmlOutput) output += name; + } else { + if(htmlOutput) output += name; + } + } + if (obj.find(mergeParam) != -1 && htmlOutput) { + QString link = mergeParam.cap(1); + QString href = link.left(link.find("::")); + QString path = m_chmFile.left(m_chmFile.findRev("/") + 1); + //output += " (<a href=\"" + path + href + "\">link</a>)"; + m_bIndex = 1; + output += " (<a target=\"browse\" href=\"" + url.url() + path + href + "\">link</a>)"; + if (firstPage == "") firstPage = url.url()+QString::fromLocal8Bit(local.latin1()); + } + } + if(htmlOutput) output += s.mid(old); + + //set left pane + //added by lucida, lucida@users.sf.net + QString lframe = QString("</HEAD><FRAMESET COLS=\"25%,*\">\n"); + lframe += "<FRAME NAME=\"index\" src=\"file:"+ fname+"\"" + " marginwidth=\"0\"></FRAME>\n"; + if (!m_bIndex) { + lframe = "</HEAD><FRAMESET>"; + firstPage = url.url() + QString::fromLocal8Bit(m_strIndex.latin1()); + } + theData.resetRawData(&m_contents[offset], length); + //KMimeMagicResult * result = KMimeMagic::self()->findBufferFileType( output, path ); + //kdDebug() << "Emitting mimetype " << result->mimeType() << endl; + //mimeType( result->mimeType() ); +/* QCString output1 = (QCString)(output.latin1()); + data(output1); + processedSize(output1.length());*/ + + //construct the frame + //added by lucida lucida@users.sf.net + QString framestr = QString("<HTML><HEAD>\n"); + framestr += lframe; + framestr += "<FRAME NAME=\"browse\" src=\"" + firstPage + "\">\n"; + framestr += "</FRAME>\n"; + framestr += "</FRAMESET></HTML>"; + //write index file + //added by lucida lucida@users.sf.net + *t << QString::fromLocal8Bit(output.latin1()) << endl; + + if(catalog) { + data(output.local8Bit()); + processedSize(output.length()); + }else{ + data(framestr.local8Bit()); + processedSize(framestr.length()); + } + } else { + int offset = m_dirMap[path].offset; + int length = m_dirMap[path].length; + totalSize(length); + theData.setRawData(&m_contents[offset], length); + + KMimeMagicResult * result = KMimeMagic::self()->findBufferFileType( theData, path ); + kdDebug() << "Emitting mimetype " << result->mimeType() << endl; + mimeType( result->mimeType() ); + data(theData); + theData.resetRawData(&m_contents[offset], length); + processedSize(length); + } + + finished(); +} + +/* --------------------------------------------------------------------------- */ +bool ChmProtocol::checkNewFile( QString fullPath, QString& path ) +{ + //kdDebug() << "ChmProtocol::checkNewFile " << fullPath << endl; + + fullPath = fullPath.replace(QRegExp("::"), ""); + + // Are we already looking at that file ? + if ( !m_chmFile.isEmpty() && fullPath.startsWith(m_chmFile) ) + { + path = fullPath.mid(m_chmFile.length()).lower(); + return true; + } + + kdDebug() << "Need to open a new file" << endl; + + m_chmFile = ""; + + // Find where the chm file is in the full path + int pos = 0; + QString chmFile; + path = ""; + + int len = fullPath.length(); + if ( len != 0 && fullPath[ len - 1 ] != '/' ) + fullPath += '/'; + + //kdDebug() << "the full path is " << fullPath << endl; + while ( (pos=fullPath.find( '/', pos+1 )) != -1 ) + { + QString tryPath = fullPath.left( pos ); + //kdDebug() << fullPath << " trying " << tryPath << endl; + struct stat statbuf; + if ( ::stat( QFile::encodeName(tryPath), &statbuf ) == 0 && !S_ISDIR(statbuf.st_mode) ) + { + chmFile = tryPath; + path = fullPath.mid( pos ).lower(); + kdDebug() << "fullPath=" << fullPath << " path=" << path << endl; + len = path.length(); + if ( len > 2 ) + { + if ( path[ len - 1 ] == '/' ) + path.truncate( len - 1 ); + } + else + { + path = QString::fromLatin1("/"); + } + kdDebug() << "Found. chmFile=" << chmFile << " path=" << path << endl; + break; + } + } + if ( chmFile.isEmpty() ) + { + kdDebug() << "ChmProtocol::checkNewFile: not found" << endl; + return false; + } + + m_chmFile = chmFile; + + // Open new file + //kdDebug() << "Opening Chm file on " << chmFile << endl; + return m_chm.read(chmFile, m_dirMap, m_contents); +} diff --git a/parts/documentation/protocols/chm/chm.h b/parts/documentation/protocols/chm/chm.h new file mode 100644 index 00000000..92044173 --- /dev/null +++ b/parts/documentation/protocols/chm/chm.h @@ -0,0 +1,47 @@ +/* This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#ifndef __chm_h__ +#define __chm_h__ + +#include <qstring.h> +#include <qcstring.h> +#include <kurl.h> +#include <kio/global.h> +#include <kio/slavebase.h> +#include "chmfile.h" + +class QCString; + +class ChmProtocol : public KIO::SlaveBase +{ +public: + ChmProtocol( const QCString&, const QCString& ); + ~ChmProtocol(); + + void get( const KURL& ); + +private: + bool checkNewFile( QString, QString& ); + ChmDirectoryMap m_dirMap; + QByteArray m_contents; + QString m_chmFile; + Chm m_chm; +}; + + +#endif // __chm_h__ + diff --git a/parts/documentation/protocols/chm/chm.protocol b/parts/documentation/protocols/chm/chm.protocol new file mode 100644 index 00000000..90daa4c5 --- /dev/null +++ b/parts/documentation/protocols/chm/chm.protocol @@ -0,0 +1,36 @@ +[Protocol] +exec=kio_chm +protocol=ms-its +input=none +output=filesystem +reading=true +defaultMimetype=text/html +Description=A kioslave for displaying WinHelp files +Description[ca]=Un kioslave per a mostrar fitxers WinHelp +Description[da]=En kioslave til visning af Windows hjælpefiler +Description[de]=Ein Ein-/Ausgabemodul zur Anzeige von WinHelp-Dateien +Description[el]=Ένας υπηρέτης kio για εμφάνιση αρχείων WinHelp +Description[es]=Un kioslave para mostrar archivos WinHelp +Description[et]=WinHelp-failide kuvamise IO-moodul +Description[eu]=WinHelp fitxategiak bistaratzeko kioslave bat +Description[fa]=یک kioslave برای نمایش پروندههای WinHelp +Description[fr]=Un esclave d'E/S (kioslave) pour l'affichage des fichiers WinHelp +Description[gl]=Un kioslave para mostrar ficheiros WinHelp +Description[hu]=KDE-protokoll WinHelp-fájlok megjelenítéséhez +Description[it]=Un kioslave per mostrare i file WinHelp +Description[ja]=WinHelp を表示するための kioslave +Description[nds]=En In-/Utgaavmoduul för't Wiesen vun "WinHelp"-Dateien +Description[ne]=WinHelp फाइलहरूका लागि किवस्लेभ +Description[nl]=Een kioslave voor het weergeven van WinHelp-bestanden +Description[pl]=kioslave do pokazywania plików WinHelp +Description[pt]=A 'kioslave' para mostrar ficheiros WinHelp +Description[pt_BR]=Um kioslave para exibir arquivos WinHelp +Description[ru]=Обработчик ввода-вывода для файлов WinHelp +Description[sk]=kioslave pre zobrazenie WinHelp súborov +Description[sr]=KIOSlave за приказ WinHelp фајлова +Description[sr@Latn]=KIOSlave za prikaz WinHelp fajlova +Description[sv]=En I/O-slav för att visa WinHelp-filer +Description[tr]=WinHelp dosyalarını görüntülemek için bir kioslave +Description[zh_CN]=显示 WinHelp 文件的 kioslave +Description[zh_TW]=顯示 WinHelp 檔案的 kioslave +Icon=help diff --git a/parts/documentation/protocols/chm/chmfile.cpp b/parts/documentation/protocols/chm/chmfile.cpp new file mode 100644 index 00000000..f69d354a --- /dev/null +++ b/parts/documentation/protocols/chm/chmfile.cpp @@ -0,0 +1,197 @@ +/* This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#include <qfile.h> +#include "chmfile.h" +#include "decompress.h" + +uint Chm::getEncInt(QFile& f, uint &value) const +{ + int c; + uint result = 0; + ulong count = 0; + + do + { + c = f.getch(); + result <<= 7; + result |= (c & 0x7F); + count++; + } while (c & 0x80); + + value = result; + return count; +} + +uint Chm::getName(QFile& f, QString& name) const +{ + int len = f.getch(); + char *buf = new char[len]; + f.readBlock(buf, len); + name = QString::fromUtf8(buf, len); + if (name.startsWith("/")) + name = name.lower(); + delete [] buf; + return len + 1; +} + +uint Chm::getIntel32(QFile& f) const +{ + uint value = f.getch() | f.getch() << 8 | f.getch() << 16 | f.getch() << 24; + return value; +} + +uint Chm::getIntel64(QFile& f) const +{ + uint value = getIntel32(f); + f.at(f.at() + 4); + return value; +} + +bool Chm::getChunk(QFile& f, uint chunkSize, ChmDirectoryMap& directoryMap) const +{ + char tag[4]; + if (f.readBlock(tag, 4) != 4) return false; + + if (!qstrncmp(tag, "PMGL", 4)) + { + uint quickref_length = getIntel32(f); + f.at(f.at() + 12); + + uint pos = 20; + while (pos < chunkSize - quickref_length) + { + uint section, offset, length; + QString name; + pos += getName(f, name); + pos += getEncInt(f, section); + pos += getEncInt(f, offset); + pos += getEncInt(f, length); + directoryMap[name] = ChmDirTableEntry(section, offset, length); + if (name.endsWith(".hhc")) + directoryMap["/@contents"] = ChmDirTableEntry(section, offset, length); + } + + return (f.at(f.at() + quickref_length)); + } + else if (!qstrncmp(tag, "PMGI", 4)) + { + // evaluation of the index chunk is not yet implemented => skip it + return f.at(f.at() + chunkSize - 4); + } + else + { + return false; + } +} + +bool Chm::read(const QString& fileSpec, ChmDirectoryMap& dirMap, QByteArray& contents) const +{ + QFile f(fileSpec); + if (!f.open(IO_ReadOnly)) return false; + + // read CHM file header + char tag[4]; + if (f.readBlock(tag, 4) != 4 || qstrncmp(tag, "ITSF", 4)) return false; + uint chm_version = getIntel32(f); + if (!f.at(f.at() + 0x30)) return false; + + // read header section table + uint section_0_offset = getIntel64(f); + uint section_0_length = getIntel64(f); + uint section_1_offset = getIntel64(f); + uint section_1_length = getIntel64(f); + + uint contentStart = 0; + if (chm_version >= 3) contentStart = getIntel32(f); + + // read directory header + if (!f.at(section_1_offset)) return false; + if (f.readBlock(tag, 4) != 4 || qstrncmp(tag, "ITSP", 4)) return false; + if (!f.at(f.at() + 12)) return false; + uint directory_chunk_size = getIntel32(f); + if (!f.at(f.at() + 24)) return false; + uint num_directory_chunks = getIntel32(f); + if (!f.at(f.at() + 36)) return false; + + // read directory table + for (uint i = 0; i < num_directory_chunks; i++) + if (!getChunk(f, directory_chunk_size, dirMap)) return false; + + // current position is start of content area + if (chm_version < 3) contentStart = f.at(); + + // read reset table + if (!f.at(contentStart)) return false; + uint resetTableOffset = + dirMap["::DataSpace/Storage/MSCompressed/Transform/{7FC28940-9D31-11D0-9B27-00A0C91E9C7C}/InstanceData/ResetTable"].offset; + if (!f.at(f.at() + resetTableOffset + 4)) return false; + uint numResetTableEntries = getIntel32(f); + if (!f.at(f.at() + 8)) return false; + uint uncompressedLength = getIntel64(f); + uint compressedLength = getIntel64(f); + uint blockSize = getIntel64(f); + uint *resetTable = new uint[numResetTableEntries + 1]; + + for (uint i = 0; i < numResetTableEntries; i++) + resetTable[i] = getIntel64(f); + + resetTable[numResetTableEntries] = compressedLength; + + // read compressed contents + if (!f.at(contentStart)) return false; + uint contentsOffset = dirMap["::DataSpace/Storage/MSCompressed/Content"].offset; + if (!f.at(f.at() + contentsOffset)) return false; + char *compressedContents = new char[compressedLength]; + if ((uint)f.readBlock(compressedContents, compressedLength) != compressedLength) return false; + + f.close(); + + // allocate buffer for uncompressed contents + char *uncompressedContents = new char[uncompressedLength]; + + // get window size + uint window = 1; + uint tmp = blockSize; + while (tmp >>= 1) window++; + + // decompress + uint outlen = uncompressedLength; + int res = 1; + + for (uint i = 0; i < numResetTableEntries; i++) + { + if (!(i & 1)) LZXinit(window); + + uint inlen = resetTable[i+1] - resetTable[i]; + res = LZXdecompress((uchar*)&compressedContents[resetTable[i]], + inlen, + (uchar*)uncompressedContents + i * blockSize, + (outlen < blockSize) ? outlen : blockSize); + if (res) break; + outlen -= blockSize; + } + + delete [] resetTable; + delete [] compressedContents; + + if (res == 0) + contents.duplicate(uncompressedContents, uncompressedLength); + + delete [] uncompressedContents; + + return (res == 0); +} diff --git a/parts/documentation/protocols/chm/chmfile.h b/parts/documentation/protocols/chm/chmfile.h new file mode 100644 index 00000000..0040c135 --- /dev/null +++ b/parts/documentation/protocols/chm/chmfile.h @@ -0,0 +1,53 @@ +/* This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#ifndef __chmfile_h__ +#define __chmfile_h__ + +#include <cstdio> +#include <qmap.h> +#include <qstring.h> + +class QFile; + +struct ChmDirTableEntry +{ + ChmDirTableEntry() : section(0), offset(0), length(0) {} + ChmDirTableEntry( uint s, uint o, uint l ) + : section(s), offset(o), length(l) {} + + uint section; + uint offset; + uint length; +}; + +typedef QMap<QString, ChmDirTableEntry> ChmDirectoryMap; + +class Chm +{ +public: + bool read( const QString&, ChmDirectoryMap&, QByteArray& ) const; + +private: + bool getChunk( QFile&, uint, ChmDirectoryMap& ) const; + uint getEncInt( QFile&, uint& ) const; + uint getName( QFile&, QString& ) const; + uint getIntel32( QFile& ) const; + uint getIntel64( QFile& ) const; +}; + +#endif // __chmfile_h__ + diff --git a/parts/documentation/protocols/chm/decompress.cpp b/parts/documentation/protocols/chm/decompress.cpp new file mode 100644 index 00000000..0356d86e --- /dev/null +++ b/parts/documentation/protocols/chm/decompress.cpp @@ -0,0 +1,796 @@ +/* Most of this file is taken from: + cabextract 0.5 - a program to extract Microsoft Cabinet files + (C) 2000-2001 Stuart Caie <kyzer@4u.net> + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include "decompress.h" + +int make_decode_table(ULONG nsyms, ULONG nbits, UBYTE *length, UWORD *table); +int lzx_read_lens(UBYTE *lens, ULONG first, ULONG last, lzx_bits *lb); + + +/*--------------------------------------------------------------------------*/ +/* our archiver information / state */ + +/* LZX stuff */ + +/* some constants defined by the LZX specification */ +#define LZX_MIN_MATCH (2) +#define LZX_MAX_MATCH (257) +#define LZX_NUM_CHARS (256) +#define LZX_BLOCKTYPE_INVALID (0) /* also blocktypes 4-7 invalid */ +#define LZX_BLOCKTYPE_VERBATIM (1) +#define LZX_BLOCKTYPE_ALIGNED (2) +#define LZX_BLOCKTYPE_UNCOMPRESSED (3) +#define LZX_PRETREE_NUM_ELEMENTS (20) +#define LZX_ALIGNED_NUM_ELEMENTS (8) /* aligned offset tree #elements */ +#define LZX_NUM_PRIMARY_LENGTHS (7) /* this one missing from spec! */ +#define LZX_NUM_SECONDARY_LENGTHS (249) /* length tree #elements */ + +/* LZX huffman defines: tweak tablebits as desired */ +#define LZX_PRETREE_MAXSYMBOLS (LZX_PRETREE_NUM_ELEMENTS) +#define LZX_PRETREE_TABLEBITS (6) +#define LZX_MAINTREE_MAXSYMBOLS (LZX_NUM_CHARS + 50*8) +#define LZX_MAINTREE_TABLEBITS (12) +#define LZX_LENGTH_MAXSYMBOLS (LZX_NUM_SECONDARY_LENGTHS+1) +#define LZX_LENGTH_TABLEBITS (12) +#define LZX_ALIGNED_MAXSYMBOLS (LZX_ALIGNED_NUM_ELEMENTS) +#define LZX_ALIGNED_TABLEBITS (7) + +#define LZX_LENTABLE_SAFETY (64) /* we allow length table decoding overruns */ + +#define LZX_DECLARE_TABLE(tbl) \ + UWORD tbl##_table[(1<<LZX_##tbl##_TABLEBITS) + (LZX_##tbl##_MAXSYMBOLS<<1)];\ + UBYTE tbl##_len [LZX_##tbl##_MAXSYMBOLS + LZX_LENTABLE_SAFETY] + +struct LZXstate +{ + UBYTE *window; /* the actual decoding window */ + ULONG window_size; /* window size (32Kb through 2Mb) */ + ULONG actual_size; /* window size when it was first allocated */ + ULONG window_posn; /* current offset within the window */ + ULONG R0, R1, R2; /* for the LRU offset system */ + UWORD main_elements; /* number of main tree elements */ + int header_read; /* have we started decoding at all yet? */ + UWORD block_type; /* type of this block */ + ULONG block_length; /* uncompressed length of this block */ + ULONG block_remaining; /* uncompressed bytes still left to decode */ + ULONG frames_read; /* the number of CFDATA blocks processed */ + LONG intel_filesize; /* magic header value used for transform */ + LONG intel_curpos; /* current offset in transform space */ + int intel_started; /* have we seen any translatable data yet? */ + + LZX_DECLARE_TABLE(PRETREE); + LZX_DECLARE_TABLE(MAINTREE); + LZX_DECLARE_TABLE(LENGTH); + LZX_DECLARE_TABLE(ALIGNED); +}; + + +/* generic stuff */ +#define CAB(x) (decomp_state.x) +#define LZX(x) (decomp_state.lzx.x) +#define DECR_OK (0) +#define DECR_DATAFORMAT (1) +#define DECR_ILLEGALDATA (2) +#define DECR_NOMEMORY (3) +#define DECR_CHECKSUM (4) +#define DECR_INPUT (5) +#define DECR_OUTPUT (6) + +struct +{ + struct LZXstate lzx; +} decomp_state; + + +/* LZX decruncher */ + +/* Microsoft's LZX document and their implementation of the + * com.ms.util.cab Java package do not concur. + * + * In the LZX document, there is a table showing the correlation between + * window size and the number of position slots. It states that the 1MB + * window = 40 slots and the 2MB window = 42 slots. In the implementation, + * 1MB = 42 slots, 2MB = 50 slots. The actual calculation is 'find the + * first slot whose position base is equal to or more than the required + * window size'. This would explain why other tables in the document refer + * to 50 slots rather than 42. + * + * The constant NUM_PRIMARY_LENGTHS used in the decompression pseudocode + * is not defined in the specification. + * + * The LZX document does not state the uncompressed block has an + * uncompressed length field. Where does this length field come from, so + * we can know how large the block is? The implementation has it as the 24 + * bits following after the 3 blocktype bits, before the alignment + * padding. + * + * The LZX document states that aligned offset blocks have their aligned + * offset huffman tree AFTER the main and length trees. The implementation + * suggests that the aligned offset tree is BEFORE the main and length + * trees. + * + * The LZX document decoding algorithm states that, in an aligned offset + * block, if an extra_bits value is 1, 2 or 3, then that number of bits + * should be read and the result added to the match offset. This is + * correct for 1 and 2, but not 3, where just a huffman symbol (using the + * aligned tree) should be read. + * + * Regarding the E8 preprocessing, the LZX document states 'No translation + * may be performed on the last 6 bytes of the input block'. This is + * correct. However, the pseudocode provided checks for the *E8 leader* + * up to the last 6 bytes. If the leader appears between -10 and -7 bytes + * from the end, this would cause the next four bytes to be modified, at + * least one of which would be in the last 6 bytes, which is not allowed + * according to the spec. + * + * The specification states that the huffman trees must always contain at + * least one element. However, many CAB files contain blocks where the + * length tree is completely empty (because there are no matches), and + * this is expected to succeed. + */ + + +/* LZX uses what it calls 'position slots' to represent match offsets. + * What this means is that a small 'position slot' number and a small + * offset from that slot are encoded instead of one large offset for + * every match. + * - position_base is an index to the position slot bases + * - extra_bits states how many bits of offset-from-base data is needed. + */ +static ULONG position_base[51]; +static UBYTE extra_bits[51]; + + +int LZXinit(int window) { + ULONG wndsize = 1 << window; + int i, j, posn_slots; + + /* LZX supports window sizes of 2^15 (32Kb) through 2^21 (2Mb) */ + /* if a previously allocated window is big enough, keep it */ + if (window < 15 || window > 21) return DECR_DATAFORMAT; + if (LZX(actual_size) < wndsize) + { + if (LZX(window)) free(LZX(window)); + LZX(window) = NULL; + } + if (!LZX(window)) + { + if (!(LZX(window) = (UBYTE*)malloc(wndsize))) return DECR_NOMEMORY; + LZX(actual_size) = wndsize; + } + LZX(window_size) = wndsize; + + /* initialise static tables */ + for (i=0, j=0; i <= 49; i += 2) + { + extra_bits[i] = extra_bits[i+1] = j; /* 0,0,0,0,1,1,2,2,3,3... */ + if ((i != 0) && (j < 17)) j++; /* 0,0,1,2,3,4...15,16,17,17,17,17... */ + } + for (i=0, j=0; i <= 50; i++) + { + position_base[i] = j; /* 0,1,2,3,4,6,8,12,16,24,32,... */ + j += 1 << extra_bits[i]; /* 1,1,1,1,2,2,4,4,8,8,16,16,32,32,... */ + } + + /* calculate required position slots */ + if (window == 20) posn_slots = 42; + else if (window == 21) posn_slots = 50; + else posn_slots = window << 1; + + /*posn_slots=i=0; while (i < wndsize) i += 1 << extra_bits[posn_slots++]; */ + + + LZX(R0) = LZX(R1) = LZX(R2) = 1; + LZX(main_elements) = LZX_NUM_CHARS + (posn_slots << 3); + LZX(header_read) = 0; + LZX(frames_read) = 0; + LZX(block_remaining) = 0; + LZX(block_type) = LZX_BLOCKTYPE_INVALID; + LZX(intel_curpos) = 0; + LZX(intel_started) = 0; + LZX(window_posn) = 0; + + /* initialise tables to 0 (because deltas will be applied to them) */ + for (i = 0; i < LZX_MAINTREE_MAXSYMBOLS; i++) LZX(MAINTREE_len)[i] = 0; + for (i = 0; i < LZX_LENGTH_MAXSYMBOLS; i++) LZX(LENGTH_len)[i] = 0; + + return DECR_OK; +} + + +/* Bitstream reading macros: + * + * INIT_BITSTREAM should be used first to set up the system + * READ_BITS(var,n) takes N bits from the buffer and puts them in var + * + * ENSURE_BITS(n) ensures there are at least N bits in the bit buffer + * PEEK_BITS(n) extracts (without removing) N bits from the bit buffer + * REMOVE_BITS(n) removes N bits from the bit buffer + * + * These bit access routines work by using the area beyond the MSB and the + * LSB as a free source of zeroes. This avoids having to mask any bits. + * So we have to know the bit width of the bitbuffer variable. This is + * sizeof(ULONG) * 8, also defined as ULONG_BITS + */ + +/* number of bits in ULONG. Note: This must be at multiple of 16, and at + * least 32 for the bitbuffer code to work (ie, it must be able to ensure + * up to 17 bits - that's adding 16 bits when there's one bit left, or + * adding 32 bits when there are no bits left. The code should work fine + * for machines where ULONG >= 32 bits. + */ +#define ULONG_BITS (sizeof(ULONG)<<3) + +#define INIT_BITSTREAM do { bitsleft = 0; bitbuf = 0; } while (0) + +#define ENSURE_BITS(n) \ + while (bitsleft < (n)) { \ + bitbuf |= ((inpos[1]<<8)|inpos[0]) << (ULONG_BITS-16 - bitsleft); \ + bitsleft += 16; inpos+=2; \ + } + +#define PEEK_BITS(n) (bitbuf >> (ULONG_BITS - (n))) +#define REMOVE_BITS(n) ((bitbuf <<= (n)), (bitsleft -= (n))) + +#define READ_BITS(v,n) do { \ + ENSURE_BITS(n); \ + (v) = PEEK_BITS(n); \ + REMOVE_BITS(n); \ +} while (0) + + +/* Huffman macros */ + +#define TABLEBITS(tbl) (LZX_##tbl##_TABLEBITS) +#define MAXSYMBOLS(tbl) (LZX_##tbl##_MAXSYMBOLS) +#define SYMTABLE(tbl) (LZX(tbl##_table)) +#define LENTABLE(tbl) (LZX(tbl##_len)) + +/* BUILD_TABLE(tablename) builds a huffman lookup table from code lengths. + * In reality, it just calls make_decode_table() with the appropriate + * values - they're all fixed by some #defines anyway, so there's no point + * writing each call out in full by hand. + */ +#define BUILD_TABLE(tbl) \ + if (make_decode_table( \ + MAXSYMBOLS(tbl), TABLEBITS(tbl), LENTABLE(tbl), SYMTABLE(tbl) \ + )) { return DECR_ILLEGALDATA; } + + +/* READ_HUFFSYM(tablename, var) decodes one huffman symbol from the + * bitstream using the stated table and puts it in var. + */ +#define READ_HUFFSYM(tbl,var) do { \ + ENSURE_BITS(16); \ + hufftbl = SYMTABLE(tbl); \ + if ((i = hufftbl[PEEK_BITS(TABLEBITS(tbl))]) >= MAXSYMBOLS(tbl)) { \ + j = 1 << (ULONG_BITS - TABLEBITS(tbl)); \ + do { \ + j >>= 1; i <<= 1; i |= (bitbuf & j) ? 1 : 0; \ + if (!j) { return DECR_ILLEGALDATA; } \ + } while ((i = hufftbl[i]) >= MAXSYMBOLS(tbl)); \ + } \ + j = LENTABLE(tbl)[(var) = i]; \ + REMOVE_BITS(j); \ +} while (0) + + +/* READ_LENGTHS(tablename, first, last) reads in code lengths for symbols + * first to last in the given table. The code lengths are stored in their + * own special LZX way. + */ +#define READ_LENGTHS(tbl,first,last) do { \ + lb.bb = bitbuf; lb.bl = bitsleft; lb.ip = inpos; \ + if (lzx_read_lens(LENTABLE(tbl),(first),(last),&lb)) { \ + return DECR_ILLEGALDATA; \ + } \ + bitbuf = lb.bb; bitsleft = lb.bl; inpos = lb.ip; \ +} while (0) + + +/* make_decode_table(nsyms, nbits, length[], table[]) + * + * This function was coded by David Tritscher. It builds a fast huffman + * decoding table out of just a canonical huffman code lengths table. + * + * nsyms = total number of symbols in this huffman tree. + * nbits = any symbols with a code length of nbits or less can be decoded + * in one lookup of the table. + * length = A table to get code lengths from [0 to syms-1] + * table = The table to fill up with decoded symbols and pointers. + * + * Returns 0 for OK or 1 for error + */ + +int make_decode_table(ULONG nsyms, ULONG nbits, UBYTE *length, UWORD *table) { + register UWORD sym; + register ULONG leaf; + register UBYTE bit_num = 1; + ULONG fill; + ULONG pos = 0; /* the current position in the decode table */ + ULONG table_mask = 1 << nbits; + ULONG bit_mask = table_mask >> 1; /* don't do 0 length codes */ + ULONG next_symbol = bit_mask; /* base of allocation for long codes */ + + /* fill entries for codes short enough for a direct mapping */ + while (bit_num <= nbits) + { + for (sym = 0; sym < nsyms; sym++) + { + if (length[sym] == bit_num) + { + leaf = pos; + + if ((pos += bit_mask) > table_mask) return 1; /* table overrun */ + + /* fill all possible lookups of this symbol with the symbol itself */ + fill = bit_mask; + while (fill-- > 0) table[leaf++] = sym; + } + } + bit_mask >>= 1; + bit_num++; + } + + /* if there are any codes longer than nbits */ + if (pos != table_mask) + { + /* clear the remainder of the table */ + for (sym = pos; sym < table_mask; sym++) table[sym] = 0; + + /* give ourselves room for codes to grow by up to 16 more bits */ + pos <<= 16; + table_mask <<= 16; + bit_mask = 1 << 15; + + while (bit_num <= 16) + { + for (sym = 0; sym < nsyms; sym++) + { + if (length[sym] == bit_num) + { + leaf = pos >> 16; + for (fill = 0; fill < bit_num - nbits; fill++) + { + /* if this path hasn't been taken yet, 'allocate' two entries */ + if (table[leaf] == 0) + { + table[(next_symbol << 1)] = 0; + table[(next_symbol << 1) + 1] = 0; + table[leaf] = next_symbol++; + } + /* follow the path and select either left or right for next bit */ + leaf = table[leaf] << 1; + if ((pos >> (15-fill)) & 1) leaf++; + } + table[leaf] = sym; + + if ((pos += bit_mask) > table_mask) return 1; /* table overflow */ + } + } + bit_mask >>= 1; + bit_num++; + } + } + + /* full table? */ + if (pos == table_mask) return 0; + + /* either erroneous table, or all elements are 0 - let's find out. */ + for (sym = 0; sym < nsyms; sym++) if (length[sym]) return 1; + return 0; +} + +int lzx_read_lens(UBYTE *lens, ULONG first, ULONG last, lzx_bits *lb) { + ULONG i,j, x,y; + int z; + + register ULONG bitbuf = lb->bb; + register int bitsleft = lb->bl; + UBYTE *inpos = lb->ip; + UWORD *hufftbl; + + for (x = 0; x < 20; x++) + { + READ_BITS(y, 4); + LENTABLE(PRETREE)[x] = y; + } + BUILD_TABLE(PRETREE); + + for (x = first; x < last;) + { + READ_HUFFSYM(PRETREE, z); + if (z == 17) + { + READ_BITS(y, 4); y += 4; + while (y--) lens[x++] = 0; + } + else if (z == 18) + { + READ_BITS(y, 5); y += 20; + while (y--) lens[x++] = 0; + } + else if (z == 19) + { + READ_BITS(y, 1); y += 4; + READ_HUFFSYM(PRETREE, z); + z = lens[x] - z; if (z < 0) z += 17; + while (y--) lens[x++] = z; + } + else + { + z = lens[x] - z; if (z < 0) z += 17; + lens[x++] = z; + } + } + + lb->bb = bitbuf; + lb->bl = bitsleft; + lb->ip = inpos; + return 0; +} + +int LZXdecompress(UBYTE* inpos, int inlen, UBYTE* outpos, int outlen) { + UBYTE *endinp = inpos + inlen; + UBYTE *window = LZX(window); + UBYTE *runsrc, *rundest; + UWORD *hufftbl; /* used in READ_HUFFSYM macro as chosen decoding table */ + + ULONG window_posn = LZX(window_posn); + ULONG window_size = LZX(window_size); + ULONG R0 = LZX(R0); + ULONG R1 = LZX(R1); + ULONG R2 = LZX(R2); + + register ULONG bitbuf; + register int bitsleft; + ULONG match_offset, i,j,k; /* ijk used in READ_HUFFSYM macro */ + lzx_bits lb; /* used in READ_LENGTHS macro */ + + int togo = outlen, this_run, main_element, aligned_bits; + int match_length, length_footer, extra, verbatim_bits; + + INIT_BITSTREAM; + + /* read header if necessary */ + if (!LZX(header_read)) + { + i = j = 0; + READ_BITS(k, 1); if (k) + { + READ_BITS(i,16); READ_BITS(j,16); + } + LZX(intel_filesize) = (i << 16) | j; /* or 0 if not encoded */ + LZX(header_read) = 1; + } + + /* main decoding loop */ + while (togo > 0) + { + /* last block finished, new block expected */ + if (LZX(block_remaining) == 0) + { + if (LZX(block_type) == LZX_BLOCKTYPE_UNCOMPRESSED) + { + if (LZX(block_length) & 1) inpos++; /* realign bitstream to word */ + INIT_BITSTREAM; + } + + READ_BITS(LZX(block_type), 3); + READ_BITS(i, 16); + READ_BITS(j, 8); + LZX(block_remaining) = LZX(block_length) = (i << 8) | j; + + switch (LZX(block_type)) + { + case LZX_BLOCKTYPE_ALIGNED: + for (i = 0; i < 8; i++) + { + READ_BITS(j, 3); LENTABLE(ALIGNED)[i] = j; + } + BUILD_TABLE(ALIGNED); + /* rest of aligned header is same as verbatim */ + + case LZX_BLOCKTYPE_VERBATIM: + READ_LENGTHS(MAINTREE, 0, 256); + READ_LENGTHS(MAINTREE, 256, LZX(main_elements)); + BUILD_TABLE(MAINTREE); + if (LENTABLE(MAINTREE)[0xE8] != 0) LZX(intel_started) = 1; + + READ_LENGTHS(LENGTH, 0, LZX_NUM_SECONDARY_LENGTHS); + BUILD_TABLE(LENGTH); + break; + + case LZX_BLOCKTYPE_UNCOMPRESSED: + LZX(intel_started) = 1; /* because we can't assume otherwise */ + ENSURE_BITS(16); /* get up to 16 pad bits into the buffer */ + if (bitsleft > 16) inpos -= 2; /* and align the bitstream! */ + R0 = inpos[0]|(inpos[1]<<8)|(inpos[2]<<16)|(inpos[3]<<24);inpos+=4; + R1 = inpos[0]|(inpos[1]<<8)|(inpos[2]<<16)|(inpos[3]<<24);inpos+=4; + R2 = inpos[0]|(inpos[1]<<8)|(inpos[2]<<16)|(inpos[3]<<24);inpos+=4; + break; + + default: + return DECR_ILLEGALDATA; + } + } + + /* buffer exhaustion check */ + if (inpos > endinp) + { + /* it's possible to have a file where the next run is less than + * 16 bits in size. In this case, the READ_HUFFSYM() macro used + * in building the tables will exhaust the buffer, so we should + * allow for this, but not allow those accidentally read bits to + * be used (so we check that there are at least 16 bits + * remaining - in this boundary case they aren't really part of + * the compressed data) + */ + if (inpos > (endinp+2) || bitsleft < 16) return DECR_ILLEGALDATA; + } + + while ((this_run = LZX(block_remaining)) > 0 && togo > 0) + { + if (this_run > togo) this_run = togo; + togo -= this_run; + LZX(block_remaining) -= this_run; + + /* apply 2^x-1 mask */ + window_posn &= window_size - 1; + /* runs can't straddle the window wraparound */ + if ((window_posn + this_run) > window_size) + return DECR_DATAFORMAT; + + switch (LZX(block_type)) + { + + case LZX_BLOCKTYPE_VERBATIM: + while (this_run > 0) + { + READ_HUFFSYM(MAINTREE, main_element); + + if (main_element < LZX_NUM_CHARS) + { + /* literal: 0 to LZX_NUM_CHARS-1 */ + window[window_posn++] = main_element; + this_run--; + } + else + { + /* match: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */ + main_element -= LZX_NUM_CHARS; + + match_length = main_element & LZX_NUM_PRIMARY_LENGTHS; + if (match_length == LZX_NUM_PRIMARY_LENGTHS) + { + READ_HUFFSYM(LENGTH, length_footer); + match_length += length_footer; + } + match_length += LZX_MIN_MATCH; + + match_offset = main_element >> 3; + + if (match_offset > 2) + { + /* not repeated offset */ + if (match_offset != 3) + { + extra = extra_bits[match_offset]; + READ_BITS(verbatim_bits, extra); + match_offset = position_base[match_offset] - 2 + verbatim_bits; + } + else + { + match_offset = 1; + } + + /* update repeated offset LRU queue */ + R2 = R1; R1 = R0; R0 = match_offset; + } + else if (match_offset == 0) + { + match_offset = R0; + } + else if (match_offset == 1) + { + match_offset = R1; + R1 = R0; R0 = match_offset; + } + else /* match_offset == 2 */ + { + match_offset = R2; + R2 = R0; R0 = match_offset; + } + + rundest = window + window_posn; + runsrc = rundest - match_offset; + window_posn += match_length; + this_run -= match_length; + + /* copy any wrapped around source data */ + while ((runsrc < window) && (match_length-- > 0)) + { + *rundest++ = *(runsrc + window_size); runsrc++; + } + /* copy match data - no worries about destination wraps */ + while (match_length-- > 0) *rundest++ = *runsrc++; + + } + } + break; + + case LZX_BLOCKTYPE_ALIGNED: + while (this_run > 0) + { + READ_HUFFSYM(MAINTREE, main_element); + + if (main_element < LZX_NUM_CHARS) + { + /* literal: 0 to LZX_NUM_CHARS-1 */ + window[window_posn++] = main_element; + this_run--; + } + else + { + /* match: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */ + main_element -= LZX_NUM_CHARS; + + match_length = main_element & LZX_NUM_PRIMARY_LENGTHS; + if (match_length == LZX_NUM_PRIMARY_LENGTHS) + { + READ_HUFFSYM(LENGTH, length_footer); + match_length += length_footer; + } + match_length += LZX_MIN_MATCH; + + match_offset = main_element >> 3; + + if (match_offset > 2) + { + /* not repeated offset */ + extra = extra_bits[match_offset]; + match_offset = position_base[match_offset] - 2; + if (extra > 3) + { + /* verbatim and aligned bits */ + extra -= 3; + READ_BITS(verbatim_bits, extra); + match_offset += (verbatim_bits << 3); + READ_HUFFSYM(ALIGNED, aligned_bits); + match_offset += aligned_bits; + } + else if (extra == 3) + { + /* aligned bits only */ + READ_HUFFSYM(ALIGNED, aligned_bits); + match_offset += aligned_bits; + } + else if (extra > 0) + { /* extra==1, extra==2 */ + /* verbatim bits only */ + READ_BITS(verbatim_bits, extra); + match_offset += verbatim_bits; + } + else /* extra == 0 */ + { + /* ??? */ + match_offset = 1; + } + + /* update repeated offset LRU queue */ + R2 = R1; R1 = R0; R0 = match_offset; + } + else if (match_offset == 0) + { + match_offset = R0; + } + else if (match_offset == 1) + { + match_offset = R1; + R1 = R0; R0 = match_offset; + } + else /* match_offset == 2 */ + { + match_offset = R2; + R2 = R0; R0 = match_offset; + } + + rundest = window + window_posn; + runsrc = rundest - match_offset; + window_posn += match_length; + this_run -= match_length; + + /* copy any wrapped around source data */ + while ((runsrc < window) && (match_length-- > 0)) + { + *rundest++ = *(runsrc + window_size); runsrc++; + } + /* copy match data - no worries about destination wraps */ + while (match_length-- > 0) *rundest++ = *runsrc++; + + } + } + break; + + case LZX_BLOCKTYPE_UNCOMPRESSED: + if ((inpos + this_run) > endinp) return DECR_ILLEGALDATA; + memcpy(window + window_posn, inpos, (size_t) this_run); + inpos += this_run; window_posn += this_run; + break; + + default: + return DECR_ILLEGALDATA; /* might as well */ + } + + } + } + + if (togo != 0) return DECR_ILLEGALDATA; + memcpy(outpos, window + ((!window_posn) ? window_size : window_posn) - + outlen, (size_t) outlen); + + LZX(window_posn) = window_posn; + LZX(R0) = R0; + LZX(R1) = R1; + LZX(R2) = R2; + + /* intel E8 decoding */ + if ((LZX(frames_read)++ < 32768) && LZX(intel_filesize) != 0) + { + if (outlen <= 6 || !LZX(intel_started)) + { + LZX(intel_curpos) += outlen; + } + else + { + UBYTE *data = outpos; + UBYTE *dataend = data + outlen - 10; + LONG curpos = LZX(intel_curpos); + LONG filesize = LZX(intel_filesize); + LONG abs_off, rel_off; + + LZX(intel_curpos) = curpos + outlen; + + while (data < dataend) + { + if (*data++ != 0xE8) + { + curpos++; continue; + } + abs_off = data[0] | (data[1]<<8) | (data[2]<<16) | (data[3]<<24); + if ((abs_off >= -curpos) && (abs_off < filesize)) + { + rel_off = (abs_off >= 0) ? abs_off - curpos : abs_off + filesize; + data[0] = (UBYTE) rel_off; + data[1] = (UBYTE) (rel_off >> 8); + data[2] = (UBYTE) (rel_off >> 16); + data[3] = (UBYTE) (rel_off >> 24); + } + data += 4; + curpos += 5; + } + } + } + return DECR_OK; +} + diff --git a/parts/documentation/protocols/chm/decompress.h b/parts/documentation/protocols/chm/decompress.h new file mode 100644 index 00000000..4fa42615 --- /dev/null +++ b/parts/documentation/protocols/chm/decompress.h @@ -0,0 +1,43 @@ +/* This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#ifndef __decompress_h__ +#define __decompress_h__ + +#ifdef __cplusplus__ +extern "C" { +#endif + +typedef unsigned char UBYTE; /* 8 bits exactly */ +typedef unsigned short UWORD; /* 16 bits (or more) */ +typedef unsigned int ULONG; /* 32 bits (or more) */ +typedef signed int LONG; /* 32 bits (or more) */ + +typedef struct lzx_bits +{ + ULONG bb; + int bl; + UBYTE *ip; +} lzx_bits; + +int LZXinit( int window ); +int LZXdecompress( UBYTE *inpos, int inlen, UBYTE *outpos, int outlen ); + +#ifdef __cplusplus__ +} +#endif + +#endif // __decompress_h__ diff --git a/parts/documentation/protocols/chm/kchmpart.cpp b/parts/documentation/protocols/chm/kchmpart.cpp new file mode 100644 index 00000000..b72602c3 --- /dev/null +++ b/parts/documentation/protocols/chm/kchmpart.cpp @@ -0,0 +1,123 @@ +/* This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#include "kchmpart.h" +#include <qstring.h> + +#include <kinstance.h> +#include <kglobal.h> +#include <kdebug.h> +#include <klocale.h> +#include <kstandarddirs.h> +#include <kaboutdata.h> + +extern "C" +{ + void* init_libkchmpart() + { + return new KChmPartFactory; + } +} + +KInstance* KChmPartFactory::s_instance = 0L; +KAboutData* KChmPartFactory::s_about = 0L; + +KChmPartFactory::KChmPartFactory( QObject* parent, const char* name ) + : KParts::Factory( parent, name ) +{ +} + +KChmPartFactory::~KChmPartFactory() +{ + delete s_instance; + s_instance = 0L; + delete s_about; +} + +KParts::Part* KChmPartFactory::createPartObject( QWidget *parentWidget, const char *, QObject *, + const char *name, const char *, const QStringList & ) +{ + KChmPart* part = new KChmPart( parentWidget, name ); + return part; +} + +KInstance* KChmPartFactory::instance() +{ + if( !s_instance ) + { + s_about = new KAboutData( "kchmpart", + I18N_NOOP( "KChm" ), "1.0pre" ); + s_instance = new KInstance( s_about ); + } + return s_instance; +} + + +KChmPart::KChmPart( QWidget * parent, const char * name ) + : KDevHTMLPart( ), m_job(0) +{ + KInstance * instance = new KInstance( "kchmpart" ); + setInstance( instance ); + m_extension=new KParts::BrowserExtension(this); + setOptions(-1); +} + +bool KChmPart::openURL( const KURL &url ) +{ + KURL chmURL = url; + chmURL.setProtocol("ms-its"); + chmURL.addPath("/"); + return KDevHTMLPart::openURL(chmURL); +} + +void KChmPart::slotDuplicate() +{ +} + +void KChmPart::slotOpenInNewWindow(const KURL &url) +{ +} + + +/* +bool KChmPart::openFile() +{ + if (m_job!=0) + m_job->kill(); + + m_htmlData.truncate(0); + + m_job = KIO::get( QString("chm:")+m_file+"/", true, false ); + connect( m_job, SIGNAL( data( KIO::Job *, const QByteArray &) ), SLOT( readData( KIO::Job *, const QByteArray &) ) ); + connect( m_job, SIGNAL( result( KIO::Job * ) ), SLOT( jobDone( KIO::Job * ) ) ); + return true; +} + +void KChmPart::readData(KIO::Job * , const QByteArray & data) +{ + m_htmlData += data; +} + +void KChmPart::jobDone( KIO::Job *) +{ + m_job=0; + begin(); + write(QString::fromLocal8Bit(m_htmlData)); + end(); +} +*/ +#include "kchmpart.moc" + diff --git a/parts/documentation/protocols/chm/kchmpart.desktop b/parts/documentation/protocols/chm/kchmpart.desktop new file mode 100644 index 00000000..1ddefe13 --- /dev/null +++ b/parts/documentation/protocols/chm/kchmpart.desktop @@ -0,0 +1,46 @@ +[Desktop Entry] +Type=Service +Exec=foobar +Comment=Embeddable HTMLHelp Viewer +Comment[ca]=Visor encastat de l'ajuda HTML +Comment[da]=Indlejrbar HTMLHjælp-fremviser +Comment[de]=Eingebetteter Betrachter für HTMLHelp +Comment[el]=Ενσωματωμένος προβολέας HTMLHelp +Comment[es]=Visor de ayuda HTML empotrable +Comment[et]=Põimitav HTML-abifailide näitaja +Comment[eu]=HTMLHelp ikustaile kapsulagarria +Comment[fa]=مشاهدهگر کمک قابل نهفتۀ زنگام +Comment[fr]=Afficheur HTMLHelp intégrable +Comment[ga]=Comhpháirt inleabaithe amharctha HTML +Comment[gl]=Visor de HTMLHelp incrustable +Comment[hi]=अंतर्निर्मित योग्य एचटीएमएल मदद प्रदर्शक +Comment[hu]=Beágyazható HTML-es dokumentációnézegető +Comment[it]=Visualizzatore integrabile per la guida HTML +Comment[ja]=埋め込み可能な HTMLHelp ビューア +Comment[ms]=Pelihat HTMLHelp Terbinadalam +Comment[nds]=Inbettbor Kieker för HTMLHelp +Comment[ne]=सम्मिलित गर्न मिल्ने HTMLHelp दृश्यकर्ता +Comment[nl]=Ingebedde HTML Helpweergave +Comment[pl]=Wbudowywalna przeglądarka pomocy w formacie HTML +Comment[pt]=Visualizador de HTMLHelp Incorporado +Comment[pt_BR]=Visualizador de Ajuda HTML Embutido +Comment[ru]=Встроенный просмотр HTMLHelp +Comment[sk]=Vložiteľný HTMLHelp prezerač +Comment[sr]=Уградиви приказивач HTMLHelp-а +Comment[sr@Latn]=Ugradivi prikazivač HTMLHelp-a +Comment[sv]=Inbäddningsbar HTML-hjälpvisning +Comment[ta]=HTML உதவி பார்வையாளரை உட்பொதி +Comment[tg]=Намоиши ҳамвори HTMLHelp +Comment[tr]=Gömülebilir HTMLHelp Görüntüleyicisi +Comment[zh_CN]=嵌入的 HTML 帮助查看器 +Comment[zh_TW]=可嵌入 HTMLHelp 檢視器 +MimeType=application/chm +Name=KChmPart +Name[de]=CHM-Betrachter (KDevelop) +Name[hi]=के-सीएचएम-पार्ट +Name[nds]=Chm-Kieker (KDevelop) +Name[pl]=Program KChm +Name[sv]=Kchm-del +ServiceTypes=KParts/ReadOnlyPart,Browser/View +X-KDE-Library=libkchmpart +X-KDevelop-Version=5 diff --git a/parts/documentation/protocols/chm/kchmpart.h b/parts/documentation/protocols/chm/kchmpart.h new file mode 100644 index 00000000..03a12738 --- /dev/null +++ b/parts/documentation/protocols/chm/kchmpart.h @@ -0,0 +1,82 @@ +/* This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#ifndef __kchmpart_h__ +#define __kchmpart_h__ + +#include <kparts/factory.h> +#include <kparts/part.h> +#include <kparts/browserextension.h> +#include <khtml_part.h> +#include <kio/job.h> +#include <kio/jobclasses.h> +#include <kdevhtmlpart.h> + +#include <qcstring.h> + +class KInstance; +class KAboutData; + +class KChmPartFactory: public KParts::Factory +{ + Q_OBJECT + public: + KChmPartFactory( QObject *parent = 0, const char *name = 0 ); + virtual ~KChmPartFactory(); + + virtual KParts::Part* createPartObject( + QWidget *parentWidget, const char *widgetName, + QObject *parent, const char *name, + const char *classname, const QStringList &args ); + + static KInstance *instance(); + + private: + static KInstance *s_instance; + static KAboutData *s_about; + +}; + + +class KChmPart : public KDevHTMLPart +{ + Q_OBJECT + public: + KChmPart( QWidget *, const char * = 0 ); + KParts::BrowserExtension * extension() { return m_extension; } + + public slots: + virtual bool openURL( const KURL & ); +/* + protected slots: + void readData(KIO::Job * , const QByteArray & data); + void jobDone( KIO::Job *); +*/ + protected: + //virtual bool openFile(); + KInstance *m_instance; + KParts::BrowserExtension *m_extension; + KIO::TransferJob *m_job; + QCString m_htmlData; + + protected slots: + virtual void slotDuplicate(); + virtual void slotOpenInNewWindow(const KURL &url); + +}; + +#endif // __kchmpart_h__ + |