reader.cc

   1 #include <reader.h>
   2
   3 namespace odc {
   4
   5 Reader::Reader(std::istream &rider): d_rider(rider), d_cancelled(false), d_readAlien(false) {}
   6
   7 SHORTCHAR Reader::readSChar() {
   8         SHORTCHAR out;
   9         d_rider.read(&out, 1);
  10         return out;
  11 }
  12
  13 INTEGER Reader::readInt() {
  14         char *buf = new char[4];
  15         d_rider.read(buf, 4);
  16         if (isLittleEndian()) {
  17                 return *(INTEGER *)buf;
  18         } else {
  19                 char *out = new char[4];
  20                 out[0] = buf[3]; out[1] = buf[2]; out[2] = buf[1]; out[3] = buf[0];
  21                 return *(INTEGER *)out;
  22         }
  23 }
  24
  25 Store* Reader::readStore() {
  26         SHORTCHAR kind = readSChar();
  27         if (kind == Store::NIL) {
  28                 return readNilStore();
  29         } else if (kind == Store::LINK) {
  30                 return readLinkStore();
  31         } else if (kind == Store::NEWLINK) {
  32                 return readNewLinkStore();
  33         } else if (kind == Store::STORE) {
  34                 return readStoreOrElemStore(false);
  35         } else if (kind == Store::ELEM) {
  36                 return readStoreOrElemStore(true);
  37         } else {
  38                 throw 20;
  39         }
  40 }
  41 //      PROCEDURE (VAR rd: Reader) ReadStore* (OUT x: Store), NEW;
  42 //              VAR a: Alien; t: Kernel.Type;
  43 //                      len, pos, pos1, id, comment, next, down, downPos, nextTypeId, nextElemId, nextStoreId: INTEGER;
  44 //                      kind: SHORTCHAR; path: TypePath; type: TypeName;
  45 //                      save: ReaderState;
  46 Store *Reader::readNilStore() {
  47         return 0;
  48 }
  49 //              IF kind = nil THEN
  50 //                      rd.ReadInt(comment); rd.ReadInt(next);
  51 //                      rd.st.end := rd.Pos();
  52 //                      IF (next > 0) OR ((next = 0) & ODD(comment)) THEN rd.st.next := rd.st.end + next ELSE rd.st.next := 0 END;
  53 //                      x := NIL
  54 Store *Reader::readLinkStore() {
  55         return 0;
  56 }
  57 //              ELSIF kind = link THEN
  58 //                      rd.ReadInt(id); rd.ReadInt(comment); rd.ReadInt(next);
  59 //                      rd.st.end := rd.Pos();
  60 //                      IF (next > 0) OR ((next = 0) & ODD(comment)) THEN rd.st.next := rd.st.end + next ELSE rd.st.next := 0 END;
  61 //                      x := ThisStore(rd.eDict, id)
  62 Store *Reader::readNewLinkStore() {
  63         return 0;
  64 }
  65 //              ELSIF kind = newlink THEN
  66 //                      rd.ReadInt(id); rd.ReadInt(comment); rd.ReadInt(next);
  67 //                      rd.st.end := rd.Pos();
  68 //                      IF (next > 0) OR ((next = 0) & ODD(comment)) THEN rd.st.next := rd.st.end + next ELSE rd.st.next := 0 END;
  69 //                      x := ThisStore(rd.sDict, id)
  70
  71 Store *Reader::readStoreOrElemStore(bool isElem) {
  72         INTEGER id = isElem ? d_nextElemId++ : d_nextStoreId++;
  73         CHAR** path = newTypePath();
  74         readPath(path);
  75         CHAR* type = path[0];
  76         std::cout << type << std::endl;
  77         INTEGER comment = readInt();
  78         return 0;
  79 }
  80 //                      ReadPath(rd, path); type := path[0];
  81 //                      nextTypeId := rd.nextTypeId; nextElemId := rd.nextElemId; nextStoreId := rd.nextStoreId;
  82 //                      rd.ReadInt(comment);
  83 //                      pos1 := rd.Pos();
  84 //                      rd.ReadInt(next); rd.ReadInt(down); rd.ReadInt(len);
  85 //                      pos := rd.Pos();
  86 //                      IF next > 0 THEN rd.st.next := pos1 + next + 4 ELSE rd.st.next := 0 END;
  87 //                      IF down > 0 THEN downPos := pos1 + down + 8 ELSE downPos := 0 END;
  88 //                      rd.st.end := pos + len;
  89 //                      rd.cause := 0;
  90 //                      ASSERT(len >= 0, 101);
  91 //                      IF next # 0 THEN
  92 //                              ASSERT(rd.st.next > pos1, 102);
  93 //                              IF down # 0 THEN
  94 //                                      ASSERT(downPos < rd.st.next, 103)
  95 //                              END
  96 //                      END;
  97 //                      IF down # 0 THEN
  98 //                              ASSERT(downPos > pos1, 104);
  99 //                              ASSERT(downPos < rd.st.end, 105)
 100 //                      END;
 101 //                      t := ThisType(type);
 102 //                      IF t # NIL THEN
 103 //                              x := NewStore(t); x.isElem := kind = elem
 104 //                      ELSE
 105 //                              rd.cause := thisTypeRes; AlienTypeReport(rd.cause, type);
 106 //                              x := NIL
 107 //                      END;
 108 //                      IF x # NIL THEN
 109 //                              IF SamePath(t, path) THEN
 110 //                                      IF kind = elem THEN
 111 //                                              x.id := id; AddStore(rd.eDict, rd.eHead, x)
 112 //                                      ELSE
 113 //                                              x.id := id; AddStore(rd.sDict, rd.sHead, x)
 114 //                                      END;
 115 //                                      save := rd.st; rd.cause := 0; rd.cancelled :=  FALSE;
 116 //                                      x.Internalize(rd);
 117 //                                      rd.st := save;
 118 //                                      IF rd.cause # 0 THEN x := NIL
 119 //                                      ELSIF (rd.Pos() # rd.st.end) OR rd.rider.eof THEN
 120 //                                              rd.cause := inconsistentVersion; AlienReport(rd.cause);
 121 //                                              x := NIL
 122 //                                      END
 123 //                              ELSE
 124 //                                      rd.cause := inconsistentType; AlienTypeReport(rd.cause, type);
 125 //                                      x := NIL
 126 //                              END
 127 //                      END;
 128 //
 129 //                      IF x # NIL THEN
 130 //                              IF rd.noDomain THEN
 131 //                                      rd.store := x;
 132 //                                      rd.noDomain := FALSE
 133 //                              ELSE
 134 //                                      Join(rd.store, x)
 135 //                              END
 136 //                      ELSE    (* x is an alien *)
 137 //                              rd.SetPos(pos);
 138 //                              ASSERT(rd.cause # 0, 107);
 139 //                              NEW(a); a.path := path; a.cause := rd.cause; a.file := rd.rider.Base();
 140 //                              IF rd.noDomain THEN
 141 //                                      rd.store := a;
 142 //                                      rd.noDomain := FALSE
 143 //                              ELSE
 144 //                                      Join(rd.store, a)
 145 //                              END;
 146 //                              IF kind = elem THEN
 147 //                                      a.id := id; AddStore(rd.eDict, rd.eHead, a)
 148 //                              ELSE
 149 //                                      a.id := id; AddStore(rd.sDict, rd.sHead, a)
 150 //                              END;
 151 //                              save := rd.st;
 152 //                              rd.nextTypeId := nextTypeId; rd.nextElemId := nextElemId; rd.nextStoreId := nextStoreId;
 153 //                              InternalizeAlien(rd, a.comps, downPos, pos, len);
 154 //                              rd.st := save;
 155 //                              x := a;
 156 //                              ASSERT(rd.Pos() = rd.st.end, 108);
 157 //                              rd.cause := 0; rd.cancelled :=  FALSE; rd.readAlien := TRUE
 158 //                      END
 159
 160 void Reader::readPath(CHAR **path) {
 161         SHORTCHAR kind = readSChar();
 162         for (int i = 0; kind == Store::NEWEXT; ++i) {
 163                 std::cout << "NEWEXT" << std::endl;
 164                 //readXString(path[i]);
 165 //                      AddPathComp(rd); INC(rd.nextTypeId);
 166 //                      IF path[i] # elemTName THEN INC(i) END;
 167 //                      rd.ReadSChar(kind)
 168         }
 169
 170         if (kind == Store::NEWBASE) {
 171                 std::cout << "NEWBASE" << std::endl;
 172         } else if (kind == Store::OLDTYPE) {
 173                 std::cout << "OLDTYPE" << std::endl;
 174         } else {
 175                 throw 100;
 176         }
 177
 178         // FIXME
 179         path[0][0] = 'H';
 180         path[0][1] = 'i';
 181         path[0][2] = 0;
 182 }
 183 //      PROCEDURE ReadPath (VAR rd: Reader; VAR path: TypePath);
 184 //              VAR h: TypeDict; id, extId: INTEGER; i: INTEGER; kind: SHORTCHAR;
 185 //
 186 //              PROCEDURE AddPathComp (VAR rd: Reader);
 187 //              BEGIN
 188 //                      IF h # NIL THEN AddBaseId(h, extId, rd.nextTypeId) END;
 189 //                      AddType(rd.tDict, rd.tHead, rd.nextTypeId, path[i]);
 190 //                      h := rd.tHead; extId := rd.nextTypeId
 191 //              END AddPathComp;
 192 //
 193 //      BEGIN
 194 //              h := NIL; i := 0; rd.ReadSChar(kind);
 195 //              WHILE kind = newExt DO
 196 //                      rd.ReadXString(path[i]);
 197 //                      AddPathComp(rd); INC(rd.nextTypeId);
 198 //                      IF path[i] # elemTName THEN INC(i) END;
 199 //                      rd.ReadSChar(kind)
 200 //              END;
 201 //              IF kind = newBase THEN
 202 //                      rd.ReadXString(path[i]);
 203 //                      AddPathComp(rd); INC(rd.nextTypeId); INC(i)
 204 //              ELSE
 205 //                      ASSERT(kind = oldType, 100);
 206 //                      rd.ReadInt(id);
 207 //                      IF h # NIL THEN AddBaseId(h, extId, id) END;
 208 //                      REPEAT
 209 //                              GetThisType(rd.tDict, id, path[i]); id := ThisBaseId(rd.tDict, id);
 210 //                              IF path[i] # elemTName THEN INC(i) END
 211 //                      UNTIL id = -1
 212 //              END;
 213 //              path[i] := ""
 214 //      END ReadPath;
 215
 216 } // namespace odc