textmodel.cc

   1 #include <textmodel.h>
   2 #include <reader.h>
   3
   4 #include <vector>
   5 #include <assert.h>
   6
   7 namespace odc {
   8
   9 const std::string TextModel::TYPENAME("TextModels.Model^");
  10 const TypeProxy<TextModel> TextModel::PROXY;
  11
  12 TextModel::TextModel(INTEGER id) : ContainerModel(id) {}
  13
  14 const std::string &TextModel::getType() {
  15         return TYPENAME;
  16 }
  17
  18 const std::string *TextModel::getSuper() {
  19         return &ContainerModel::getType();
  20 }
  21
  22 const std::string &TextModel::getTypeName() const {
  23         return getType();
  24 }
  25
  26 void TextModel::internalize(Reader &reader) {
  27         ContainerModel::internalize(reader);
  28         if (reader.isCancelled()) return;
  29         reader.readVersion(0, 0);
  30 }
  31
  32 const std::string StdTextModel::TYPENAME("TextModels.StdModel^");
  33 const TypeProxy<StdTextModel> StdTextModel::PROXY;
  34
  35 StdTextModel::StdTextModel(INTEGER id) : TextModel(id) {}
  36
  37 const std::string &StdTextModel::getType() {
  38         return TYPENAME;
  39 }
  40
  41 const std::string *StdTextModel::getSuper() {
  42         return &TextModel::getType();
  43 }
  44
  45 const std::string &StdTextModel::getTypeName() const {
  46         return getType();
  47 }
  48
  49 /*
  50  * This is my current theory of how the StdTextModel storage format works:
  51  * byte 0: version
  52  * byte 1-5: len (length of piece descriptions)
  53  * byte 6-5+len: piece descriptions
  54  * byte 6+len-end: pieces (length of each defined in piece descriptions)
  55  */
  56 void StdTextModel::internalize(Reader &reader) {
  57         TextModel::internalize(reader);
  58         if (reader.isCancelled()) return;
  59         reader.readVersion(0, 1);
  60         if (reader.isCancelled()) return;
  61
  62         std::vector<Store *> dict;
  63         std::vector<TextPiece *> pieces;
  64         INTEGER len = reader.readInt();
  65         BYTE ano = reader.readByte();
  66         std::cout << "len " << len << " ano " << (int)ano << std::endl;
  67         int skip = 0;
  68         while (ano != -1) {
  69                 if (ano == dict.size()) {
  70                         Store *attr = reader.readStore(); // readAttributes(); Stores.Join(t, attr)
  71                         dict.push_back(attr);
  72                 }
  73                 INTEGER pieceLen = reader.readInt();
  74                 if (pieceLen > 0) { // shortchar piece
  75                         std::cout << "Found SChar piece" << std::endl;
  76                         pieces.push_back(new ShortPiece(pieceLen));
  77 //                              NEW(sp); sp.len := len; sp.attr := attr;
  78 //                              sp.file := rd.rider.Base(); sp.org := org; un := sp;
  79 //                              INC(org, len) -- increment org by len ?
  80                 } else if (pieceLen < 0) { // longchar piece
  81                         std::cout << "Found LChar piece" << std::endl;
  82                         assert(pieceLen % 2 == 0);
  83                         pieces.push_back(new LongPiece(pieceLen / 2));
  84 //                              len := -len; ASSERT(~ODD(len), 100);
  85 //                              NEW(lp); lp.len := len DIV 2; lp.attr := attr;
  86 //                              lp.file := rd.rider.Base(); lp.org := org; un := lp;
  87 //                              INC(org, len) -- increment org by len ?
  88                 } else { // embedded view
  89                         std::cout << "Found View piece" << std::endl;
  90                         reader.readInt(); reader.readInt();
  91                         Store *view = reader.readStore(); // fixme: save somewhere
  92 //                              NEW(v); v.len := 1; v.attr := attr;
  93 //                              rd.ReadInt(v.w); rd.ReadInt(v.h); Views.ReadView(rd, v.view);
  94 //                              v.view.InitContext(NewContext(v, t));
  95 //                              un := v; INC(org) -- increment org by one?? WTH?
  96                         pieces.push_back(new ViewPiece());
  97                         ++skip;
  98                 }
  99                 ano = reader.readByte();
 100         }
 101         for (int i = 0; i < pieces.size(); ++i) {
 102                 pieces[i]->read(reader);
 103         }
 104 //              rd.SetPos(org);
 105 }
 106 //      PROCEDURE (t: StdModel) Internalize (VAR rd: Stores.Reader);
 107 //              VAR u, un: Run; sp: Piece; lp: LPiece; v: ViewRef;
 108 //                      org, len: INTEGER; ano: BYTE; thisVersion: INTEGER;
 109 //                      attr: Attributes; dict: AttrDict;
 110 //      BEGIN
 111 //              ASSERT(t.Domain() = NIL, 20); ASSERT(t.len = 0, 21);
 112 //              t.Internalize^(rd); IF rd.cancelled THEN RETURN END;
 113 //              rd.ReadVersion(minVersion, maxStdModelVersion, thisVersion);
 114 //              IF rd.cancelled THEN RETURN END;
 115 //              StdInit(t);
 116 //              dict.len := 0; u := t.trailer;
 117 //              rd.ReadInt(len); org := rd.Pos() + len;
 118 //              rd.ReadByte(ano);
 119 //              WHILE ano # -1 DO
 120 //                      IF ano = dict.len THEN
 121 //                              ReadAttr(rd, attr); Stores.Join(t, attr);
 122 //                              IF dict.len < dictSize THEN dict.attr[dict.len] := attr; INC(dict.len) END
 123 //                      ELSE
 124 //                              attr := dict.attr[ano]
 125 //                      END;
 126 //                      rd.ReadInt(len);
 127 //                      IF len > 0 THEN (* piece *)
 128 //                              NEW(sp); sp.len := len; sp.attr := attr;
 129 //                              sp.file := rd.rider.Base(); sp.org := org; un := sp;
 130 //                              INC(org, len)
 131 //                      ELSIF len < 0 THEN      (* longchar piece *)
 132 //                              len := -len; ASSERT(~ODD(len), 100);
 133 //                              NEW(lp); lp.len := len DIV 2; lp.attr := attr;
 134 //                              lp.file := rd.rider.Base(); lp.org := org; un := lp;
 135 //                              INC(org, len)
 136 //                      ELSE    (* len = 0  =>  embedded view *)
 137 //                              NEW(v); v.len := 1; v.attr := attr;
 138 //                              rd.ReadInt(v.w); rd.ReadInt(v.h); Views.ReadView(rd, v.view);
 139 //                              v.view.InitContext(NewContext(v, t));
 140 //                              un := v; INC(org)
 141 //                      END;
 142 //                      INC(t.len, un.len); u.next := un; un.prev := u; u := un;
 143 //                      rd.ReadByte(ano)
 144 //              END;
 145 //              rd.SetPos(org);
 146 //              u.next := t.trailer; t.trailer.prev := u
 147 //      END Internalize;
 148 //
 149
 150 TextPiece::TextPiece(size_t len): d_len(len) {}
 151
 152 LongPiece::LongPiece(size_t len): TextPiece(len) {}
 153
 154 void LongPiece::read(Reader &reader) {
 155         CHAR *buf = new CHAR[d_len];
 156         reader.readLChar(buf, d_len);
 157         delete buf;
 158 }
 159
 160 ShortPiece::ShortPiece(size_t len): TextPiece(len) {}
 161
 162 void ShortPiece::read(Reader &reader) {
 163         SHORTCHAR *buf = new SHORTCHAR[d_len + 1];
 164         reader.readSChar(buf, d_len);
 165         buf[d_len] = 0;
 166         delete buf;
 167 }
 168
 169 ViewPiece::ViewPiece(): TextPiece(0) {}
 170
 171 void ViewPiece::read(Reader &reader) {
 172         reader.readByte();
 173 }
 174
 175 } // namespace odc