odcread.cc

   1 #include <iostream>
   2 #include <fstream>
   3 #include <string>
   4
   5 #include <oberon.h>
   6 #include <reader.h>
   7 #include <store.h>
   8 #include <textmodel.h>
   9 #include <visitor.h>
  10
  11 namespace odc {
  12         class Context {
  13                 public:
  14                 virtual void addPiece(std::string &piece) = 0;
  15                 virtual std::string getPlainText() const = 0;
  16         };
  17         class PartContext : public Context {
  18                 private:
  19                 std::string d_text;
  20                 public:
  21                 virtual void addPiece(std::string &piece) {
  22                         d_text += piece;
  23                 }
  24                 virtual std::string getPlainText() const {
  25                         return d_text;
  26                 }
  27         };
  28         class FoldContext : public Context {
  29                 private:
  30                 bool d_collapsed;
  31                 bool d_haveFirst; // flag that first part has been set
  32                 std::string d_firstPart;
  33                 std::string d_remainder;
  34                 public:
  35                 FoldContext(bool collapsed) : d_collapsed(collapsed), d_haveFirst(false) {}
  36                 virtual void addPiece(std::string &piece) {
  37                         if (!d_haveFirst) {
  38                                 d_haveFirst = true;
  39                                 d_firstPart = piece;
  40                         } else {
  41                                 d_remainder += piece;
  42                         }
  43                 }
  44                 virtual std::string getPlainText() const {
  45                         if (d_collapsed) {
  46                                 return std::string("##=>") + d_remainder + "\n" + d_firstPart +"##<=";
  47                         } else {
  48                                 return std::string("##=>") + d_firstPart + "\n" + d_remainder +"##<=";
  49                         }
  50                 }
  51         };
  52
  53         class MyVisitor : public Visitor {
  54                 private:
  55                 std::vector<Context*> d_context;
  56
  57                 void terminateContext() {
  58                         Context *c = *(d_context.end() - 1);
  59                         d_context.erase(d_context.end() - 1);
  60                         if (d_context.size() == 0) {
  61                                 std::cout << c->getPlainText() << std::endl;
  62                         } else {
  63                                 std::string text = c->getPlainText();
  64                                 (*(d_context.end() - 1))->addPiece(text);
  65                         }
  66                         delete c;
  67                 }
  68
  69                 public:
  70                 virtual void partStart() {
  71                         d_context.push_back(new PartContext());
  72                 }
  73                 virtual void partEnd() {
  74                         terminateContext();
  75                 }
  76                 virtual void foldLeft(bool collapsed) {
  77                         d_context.push_back(new FoldContext(collapsed));
  78                 }
  79                 virtual void foldRight() {
  80                         terminateContext();
  81                 }
  82                 virtual void textShortPiece(const ShortPiece *piece) {
  83                         std::string text = piece->getText();
  84                         (*(d_context.end() - 1))->addPiece(text);
  85                 }
  86                 virtual void textLongPiece(const LongPiece *piece) {
  87                         std::string text = piece->getText();
  88                         (*(d_context.end() - 1))->addPiece(text);
  89                 }
  90         };
  91
  92         Store* importDocument(std::istream &is) {
  93                 const INTEGER docTag = 0x6F4F4443;
  94                 const INTEGER docVersion = 0;
  95                 Reader r(is);
  96                 INTEGER tag = r.readInt();
  97                 if (tag == docTag) {
  98                         INTEGER version = r.readInt();
  99                         if (version != docVersion) {
 100                                 throw 100;
 101                         }
 102                         Store *s = r.readStore();
 103                         return s;
 104                 }
 105                 return 0;
 106         }
 107 }
 108
 109 int main(int argc, char *argv[]) {
 110         if (argc < 2) {
 111                 return 1;
 112         }
 113         std::ifstream in(argv[1], std::ios::in | std::ios::binary);
 114         odc::Store* s = odc::importDocument(in);
 115 //      std::cout << s->toPlainText() << std::endl;
 116 //      std::cout << std::endl << std::endl;
 117
 118         odc::MyVisitor visitor;
 119         s->accept(visitor);
 120 //      std::cout << s->toString() << std::endl;
 121 //      std::cout << in.tellg() << " " << in.eof() << std::endl;
 122
 123 //      odc::TypePath path;
 124 //      odc::ContainerModel(0).getTypePath(&path);
 125 //      std::cout << path.toString() << std::endl;
 126         return 0;
 127 }