File indexing completed on 2024-04-28 04:40:02

 #include "leinputstream.h"
 #include "leoutputstream.h"
 #include "introspection.h"
 #include "pole.h"
 #include <QBuffer>
 #include <QCoreApplication>
 #include <QDebug>
 #include <QFile>
 #include <QVariant>
 #include <cstdio>
 
 const Introspectable* parse(const QString& key, LEInputStream& in);
 void serialize(const Introspectable* i, const QString& key, LEOutputStream& out);
 
 using namespace std;
 
 void
 write(const QString& name, const QByteArray& data) {
     QFile out(name);
     out.open(QIODevice::WriteOnly);
     out.write(data);
     out.close();
 }
 
 bool
 parse(const QString& file) {
     try {
         POLE::Storage storage(file.toLocal8Bit());
         if (!storage.open()) {
             qDebug() << "Cannot open file " << file << ".";
             return false;
         }
 
         string prefix;
         if (storage.isDirectory("PP97_DUALSTORAGE")) {
             prefix = "PP97_DUALSTORAGE/";
         } else {
             prefix = "/";
         }
 
         list<string> entries = storage.entries(prefix);
         for (list<string>::const_iterator i=entries.begin(); i!=entries.end(); ++i) {
             // if encrypted, do not report failure.
             if (*i == "EncryptedSummary") return true;
         }
         for (list<string>::const_iterator i=entries.begin(); i!=entries.end(); ++i) {
             if (!storage.isDirectory(prefix+*i)) {
                 POLE::Stream stream(&storage, prefix+*i);
                 QString streamname(QString::fromStdString(*i));
                 QByteArray array;
                 array.resize(stream.size());
                 unsigned long read = stream.read((unsigned char*)array.data(), stream.size());
                 if (read != stream.size()) {
                     qDebug() << "Error reading stream " << streamname;
                     return false;
                 }
 //                write("/tmp/"+streamname+".in", array);
                 QBuffer buffer;
                 buffer.setData(array);
                 buffer.open(QIODevice::ReadOnly);
                 LEInputStream listream(&buffer);
                 qDebug() << "Parsing stream '" << streamname << "' of size "
                         << array.size();
                 const Introspectable* i = parse(streamname, listream);
                 if (listream.getPosition() != (qint64)stream.size()) {
                     qDebug() << stream.size() - listream.getPosition()
                         << "trailing bytes in stream " << streamname
                         << ", so probably an error at position "
                         << listream.getMaxPosition();
                     return false;
                 }
                 buffer.close();
 
                 buffer.buffer().clear();
                 buffer.open(QIODevice::WriteOnly);
                 LEOutputStream lostream(&buffer);
                 serialize(i, streamname, lostream);
 //                write("/tmp/"+streamname+".out", buffer.data());
                 if (array != buffer.data()) {
                     qDebug() << "Serialized data different from original in "
                         << streamname;
                     return false;
                 }
 
 
                 delete i;
             }
         }
     } catch (IOException& e) {
         qDebug() << "Error: " << e.msg;
         return false;
     }
     return true;
 }
 
 int
 main(int argc, char** argv) {
     QCoreApplication app(argc, argv);
     if (argc < 2) return -1;
 
     for (int i=1; i<argc; ++i) {
         QString file(argv[i]);
         qDebug() << "Parsing of " << file;
         if (parse(file)) {
             qDebug() << "Parsing of " << file << " succeedded.";
         } else {
             qDebug() << "Parsing of " << file << " failed.";
         }
     }
 
     return 0;
 }