DEADSOFTWARE

Testing odcread against a bunch of existing .odc files
[odcread.git] / odcread.cc
index 6d506685882012eef28356b70f36ef21e8fd51cb..858028e6babf5e252ede8ade0c0f71d2946ceb4e 100644 (file)
@@ -1,12 +1,96 @@
 #include <iostream>
 #include <fstream>
 #include <string>
+#include <stack>
 
 #include <oberon.h>
 #include <reader.h>
 #include <store.h>
+#include <textmodel.h>
+#include <visitor.h>
 
 namespace odc {
+       class Context {
+               public:
+               virtual void addPiece(std::string &piece) = 0;
+               virtual std::string getPlainText() const = 0;
+       };
+       class PartContext : public Context {
+               private:
+               std::string d_text;
+               public:
+               virtual void addPiece(std::string &piece) {
+                       d_text += piece;
+               }
+               virtual std::string getPlainText() const {
+                       return d_text;
+               }
+       };
+       class FoldContext : public Context {
+               private:
+               bool d_collapsed;
+               bool d_haveFirst; // flag that first part has been set
+               std::string d_firstPart;
+               std::string d_remainder;
+               public:
+               FoldContext(bool collapsed) : d_collapsed(collapsed), d_haveFirst(false) {}
+               virtual void addPiece(std::string &piece) {
+                       if (!d_haveFirst) {
+                               d_haveFirst = true;
+                               d_firstPart = piece;
+                       } else {
+                               d_remainder += piece;
+                       }
+               }
+               virtual std::string getPlainText() const {
+                       if (d_collapsed) {
+                               return std::string("##=>") + d_remainder + "\n" + d_firstPart +"##<=";
+                       } else {
+                               return std::string("##=>") + d_firstPart + "\n" + d_remainder +"##<=";
+                       }
+               }
+       };
+
+       class MyVisitor : public Visitor {
+               private:
+               std::stack<Context*> d_context;
+
+               void terminateContext() {
+                       Context *c = d_context.top();
+                       d_context.pop();
+                       if (d_context.empty()) {
+                               std::cout << c->getPlainText() << std::endl;
+                       } else {
+                               std::string text = c->getPlainText();
+                               d_context.top()->addPiece(text);
+                       }
+                       delete c;
+               }
+               
+               public:
+               virtual void partStart() {
+                       d_context.push(new PartContext());
+               }
+               virtual void partEnd() {
+                       terminateContext();
+               }
+               virtual void foldLeft(bool collapsed) {
+                       d_context.push(new FoldContext(collapsed));
+               }
+               virtual void foldRight() {
+                       terminateContext();
+               }
+               virtual void textShortPiece(const ShortPiece *piece) {
+                       std::string text = piece->getText();
+                       d_context.top()->addPiece(text);
+               }
+               virtual void textLongPiece(const LongPiece *piece) {
+                       throw "Long Piece not handled";
+                       //std::string text = piece->getText();
+                       //d_context.top()->addPiece(text);
+               }
+       };
+
        Store* importDocument(std::istream &is) {
                const INTEGER docTag = 0x6F4F4443;
                const INTEGER docVersion = 0;
@@ -29,14 +113,32 @@ int main(int argc, char *argv[]) {
                return 1;
        }
        std::ifstream in(argv[1], std::ios::in | std::ios::binary);
-       odc::Store* s = odc::importDocument(in);
-       std::cout << std::endl << std::endl;
 
-       std::cout << s->toString() << std::endl;
-       std::cout << in.tellg() << " " << in.eof() << std::endl;
+       odc::Store* s;
+       try {
+               s = odc::importDocument(in);
+       } catch (int trap) {
+               std::cerr << "Exception in parsing file: BlackBox trap no. " << trap << std::endl;
+               return 2;
+       } catch (const char * exception) {
+               std::cerr << "Exception in parsing file: " << exception << std::endl;
+               return 2;
+       }
+//     std::cout << s->toPlainText() << std::endl;
+//     std::cout << std::endl << std::endl;
+
+       try {
+               odc::MyVisitor visitor;
+               s->accept(visitor);
+       } catch (const char * exception) {
+               std::cerr << "Exception in processing document: " << exception << std::endl;
+               return 3;
+       }
+//     std::cout << s->toString() << std::endl;
+//     std::cout << in.tellg() << " " << in.eof() << std::endl;
 
-       odc::TypePath path;
-       odc::ContainerModel(0).getTypePath(&path);
-       std::cout << path.toString() << std::endl;
+//     odc::TypePath path;
+//     odc::ContainerModel(0).getTypePath(&path);
+//     std::cout << path.toString() << std::endl;
        return 0;
 }