DataMuseum.dk

Presents historical artifacts from the history of:

DANOSI

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about DANOSI

Excavated with: AutoArchaeologist - Free & Open Source Software. 

top - download

⟦c0b41aed6⟧ TextFile

    Length: 14068 (0x36f4)
    Types: TextFile
    Names: »RTPLIB.NEW«

Derivation

└─⟦037c0ce35⟧ Bits:30010524 DVBS1.SW2114.src.2.6-2 RTP compiler source SW2104+SW2114 Disk#2 30/1-92 HHA
    └─⟦this⟧ »RTP\RTPLIB.NEW« 
└─⟦828f0d3dd⟧ Bits:30010527 DVBS1.SW2114.src.2.6-5 RTP Compiler Source SW2104+SW2114 Disk 2 92.02.03 HEJ HHA
    └─⟦this⟧ »RTP\RTPLIB.NEW« 
└─⟦891417be1⟧ Bits:30010519 DVBS1.SW2114.src.2-1 SW2114 1/4 Real Time Pascal 2.7 92.06.16
    └─⟦this⟧ »RTP\RTPLIB.NEW« 
└─⟦a2bcc95d7⟧ Bits:30010511 DVBS1.SW2114.src.2.14-2 SW2114 REAL #2/4 TIME PASCAL SOURCE REL 2.14 92.09.01
    └─⟦this⟧ »RTP\RTPLIB.NEW«

TextFile

SetModule;\r
\r
$NoIndex\r
\r
  TYPE\r
    (* The type sets describes the way a set is represented on runtime *)\r
\r
    setbit = Array(4..4) of byte;\r
\r
    Settemp = RECORD\r
             Length : integer;   \r
             BitVector : setbit;\r
           END;\r
\r
    SetAddr = ^Settemp;\r
\r
\r
    SetConst = Array(1..2) Of Integer;\r
\r
\r
  FUNCTION GetMemory(Size : Integer) : SetAddr; EXTERNAL;\r
\r
  PROCEDURE PutMemory(Addr : SetAddr; Size : integer); EXTERNAL;\r
.\r
\r
\r
  (******************** ADDSET ******************************)\r
\r
  FUNCTION AddSet(Addr1 : SetAddr; Size1 : integer;\r
                  Addr2 : SetAddr; Size2 : integer) : SetAddr;\r
\r
    (* Add the sets given by addr1 and addr2. Temp memery are allocated\r
       for the result. The memery for the operands are released if temp.\r
       memery *)\r
   \r
    VAR\r
      Length : integer;\r
      ResAddr : SetAddr;\r
      Res : Byte;\r
      Index1, Index2 : Integer;\r
      Rel1,Rel2 : Boolean;\r
\r
    BEGIN\r
      index1 := 0;\r
      index2 := 0;\r
      Rel1 := ( size1 = 0);\r
      Rel2 := ( Size2 = 0);\r
      IF Rel1 THEN\r
        BEGIN\r
         Size1 := Addr1^.Length;\r
         Index1 := 4;\r
        END;\r
      IF Rel2 THEN\r
        BEGIN\r
          Size2 := Addr2^.Length;\r
          Index2 := 4;\r
        END;\r
\r
      IF Size1 < size2 THEN Length := Size2 ELSE Length := Size1;\r
\r
       (* Allocated memery for the result *)\r
      resaddr := GetMemory(Length + #H004);\r
      ResAddr^.Length := Length;\r
 \r
\r
      (* The add is made by  BitVector1 or Bitvector2 *)\r
      FOR Index := 1 TO Length DO\r
        BEGIN\r
          IF (index > size1) THEN\r
            Res := Addr2^.BitVector(Index2 + Index - 1)\r
          ELSE\r
          IF (index > size2) THEN\r
              Res := Addr1^.BitVector(Index1 + index - 1) \r
          ELSE\r
              Res := Addr1^.BitVector(Index1 + index - 1) OR\r
                     Addr2^.BitVector(Index2 + index - 1);\r
 \r
          ResAddr^.BitVector(Index + 3) := Res;\r
        END;\r
\r
\r
       (*  Release memery if nes *)\r
      IF Rel2 THEN\r
        BEGIN\r
          PutMemory(Addr2,Size2 + #H004);\r
        END;\r
\r
      IF Rel1 THEN\r
        BEGIN\r
          PutMemory(Addr1,Size1 + #H004);\r
        END;\r
\r
      AddSet := ResAddr;\r
    END;\r
\r
\r
\r
  (*********************** SUBSET *****************************)\r
\r
  FUNCTION SubSet(Addr1 : SetAddr; Size1 : integer;\r
                  Addr2 : SetAddr; Size2 : integer) : SetAddr;\r
    (* If addr1 is represented in temp. memery this memery is used for the \r
       result. Else temp. memery is allocated for the result. The memery\r
       for the 2. operand is released if temp. memery *)\r
\r
    VAR\r
      Length : integer;\r
      ResAddr : SetAddr;\r
      Res : Byte;\r
      Index1, Index2 : Integer;\r
      Rel1,Rel2 : Boolean;\r
\r
    BEGIN\r
      index1 := 0;\r
      index2 := 0;\r
      Rel1 := ( size1 = 0);\r
      Rel2 := ( Size2 = 0);\r
      IF Rel1 THEN\r
        BEGIN\r
         Size1 := Addr1^.Length;\r
         Index1 := 4;\r
        END;\r
      IF Rel2 THEN\r
        BEGIN\r
          Size2 := Addr2^.Length;\r
          Index2 := 4;\r
        END;\r
\r
     Length := Size1;\r
\r
       (* Allocated memery for the result *)\r
      IF Rel1 THEN\r
        ResAddr := Addr1\r
      ELSE\r
        BEGIN\r
          resaddr := GetMemory(Length + #H004);\r
          ResAddr^.Length := Length;\r
        END; \r
\r
      (* Sub sets are made by Bitvector1 And (not Bitvector2)  *)\r
      FOR Index := 1 TO Length DO\r
        BEGIN\r
          IF (index > size2) THEN\r
            Res := Addr1^.BitVector(Index1 + Index - 1)\r
          ELSE\r
              Res := Addr1^.BitVector(Index1 + index - 1) AND\r
                     ( NOT Addr2^.BitVector(Index2 + index - 1));\r
 \r
          ResAddr^.BitVector(Index + 3) := Res;\r
        END;\r
\r
\r
       (*  Release memery if nes *)\r
      IF Rel2 THEN\r
        BEGIN\r
          PutMemory(Addr2,Size2 + #H004);\r
        END;\r
\r
      SubSet := ResAddr;\r
    END;\r
\r
\r
\r
  (************************* MULTSET **********************)\r
\r
\r
  FUNCTION MultSet(Addr1 : SetAddr; Size1 : Integer;\r
                   Addr2 : SetAddr; Size2 : Integer) : SetAddr;\r
   \r
    (* If addr1 or addr2 is represented in temp. memery this memery is used \r
       for the result. Else temp. memery is allocated for the result. The memery\r
       for the 2. operand is released if temp. memery and not used for result *)\r
\r
    VAR\r
      Length : integer;\r
      ResAddr : SetAddr;\r
      Res : Byte;\r
      Index1, Index2 : Integer;\r
      Rel1,Rel2 : Boolean;\r
\r
    BEGIN\r
      index1 := 0;\r
      index2 := 0;\r
      Rel1 := ( size1 = 0);\r
      Rel2 := ( Size2 = 0);\r
      IF Rel1 THEN\r
        BEGIN\r
         Size1 := Addr1^.Length;\r
         Index1 := 4;\r
         Length := Size1;\r
         ResAddr := Addr1;\r
        END;\r
      IF Rel2 THEN\r
        BEGIN\r
          Size2 := Addr2^.Length;\r
          Index2 := 4;\r
          IF not Rel1 THEN\r
            BEGIN\r
              Length := Size2;\r
              ResAddr := Addr2;\r
            END;\r
        END;\r
\r
       (* Allocated memery for the result *)\r
      IF NOT (Rel1 OR Rel2)  THEN\r
        BEGIN\r
          if Size1 > size2 THEN Length := Size2 ELSE Length := Size1;\r
          resaddr := GetMemory(Length + #H004);\r
          ResAddr^.Length := Length;\r
        END; \r
\r
      (* Mult sets are made by Bitvector1 And Bitvector2)  *)\r
      FOR Index := 1 TO Length DO\r
        BEGIN\r
          IF (index > size2) or (index > Size1) THEN\r
            Res := 0\r
          ELSE\r
              Res := Addr1^.BitVector(Index1 + index - 1) AND\r
                     Addr2^.BitVector(Index2 + index - 1);\r
 \r
          ResAddr^.BitVector(Index + 3) := Res;\r
        END;\r
\r
\r
       (*  Release memery if nes *)\r
      IF Rel1 AND Rel2 THEN\r
        BEGIN\r
          PutMemory(Addr2,Size2 + #H004);\r
        END;\r
\r
      MultSet := ResAddr;\r
    END;\r
\r
\r
  (***************************** INSET **************************)\r
\r
  FUNCTION InSet(elem : integer;Addr : SetAddr; Size : Integer) : Boolean;\r
    (* The function returns true if elem is in the set Addr .\r
       The memery addr is released if temp. memery *)\r
\r
    VAR\r
      Rel,Res : Boolean;\r
      index : integer;\r
      ByteOffset, BitOffset : integer;\r
\r
\r
    BEGIN\r
      index := 0;\r
      Rel := ( size = 0);\r
      IF Rel THEN\r
        BEGIN\r
         Size := Addr^.Length;\r
         Index := 4;\r
        END;\r
    \r
\r
      IF (elem < 0) OR ( (size * 8) <= elem) THEN \r
            Res := false\r
          ELSE\r
            BEGIN\r
              ByteOffset := elem Div 8;\r
              BitOffset := elem Mod 8;\r
              WITH Res As x : Byte DO \r
                x := (Addr^.BitVector(index + ByteOffset) \r
                                       Shift (-BitOffset)) AND #H1;\r
            END;\r
\r
      IF  Rel THEN\r
        BEGIN\r
          PutMemory(Addr,size + #H004);\r
        END;\r
\r
\r
      InSet := Res;\r
    END;\r
\r
\r
  (*********************** ASSIGNSET ************************)\r
\r
  PROCEDURE AssignSet(Addr1 : SetAddr;Low : integer;\r
                      Addr2 : SetAddr; Size,High : integer);\r
    (* The set given by Addr2 is assign to Addr1. Addr2 may not have values \r
       outside the range low..high.\r
       IF addr2 is Temp. memery then the memery is released  *)\r
\r
    VAR\r
       index : integer;\r
       rel : boolean;\r
\r
\r
    BEGIN\r
      index := 0;\r
      Rel := ( size = 0);\r
      IF Rel THEN\r
        BEGIN\r
         Size := Addr2^.Length;\r
         Index := 4;\r
        END;\r
      IF Low DIV 8 < size THEN\r
      BEGIN\r
        FOR i := 1 to (low DIV 8) DO\r
        IF Addr2^.Bitvector(index + i - 1) <> 0 THEN\r
           Exception(63);\r
        IF ( Addr2^.Bitvector(index + (Low Div 8)) AND\r
           ( (1 SHIFT (Low MOD 8))-1 ) ) <> 0 THEN \r
           Exception(63);\r
      END;\r
      \r
      IF high DIV 8 < size THEN\r
      BEGIN\r
        FOR i := (high DIV 8)+2 to size DO\r
        IF Addr2^.Bitvector(index + i - 1) <> 0 THEN\r
           Exception(63);\r
        IF ( Addr2^.Bitvector(index + (High Div 8)) SHIFT\r
            ( - (High MOD 8) - 1   ) ) <> 0 THEN \r
           Exception(63);\r
      END;\r
\r
\r
\r
      FOR i := 0 TO (High DIV 8) DO\r
        BEGIN\r
          IF i >= Size THEN\r
             Addr1^.Bitvector(i) := 0\r
          ELSE\r
             Addr1^.BitVector(i) := Addr2^.BitVector(Index + i);\r
        END;\r
           \r
      (*  Release memery *)\r
      IF  Rel THEN\r
        BEGIN\r
          PutMemory(Addr2,Size + #H004);\r
        END;\r
    END;\r
\r
\r
\r
   (***************************** MAKESET *************************)\r
\r
\r
\r
  FUNCTION MakeSet(Lengthset1 : Integer; SetKon : SetConst) : SetAddr;\r
    \r
    (* SetKon Gives a number of range values. The procedure makes a set\r
       containing these values \r
       SetKon is in the following format :\r
           Lengthset1        : Number of ranges.\r
           SetKon(i * 2 - 1  : lower for the i'te range.\r
           SetKon(i * 2 )    : higher for the i'te range.*)\r
    VAR\r
      Min, Max : Integer;\r
      LowKon, HighKon : Integer;\r
      ByteOffset, BitOffset : integer;\r
      Length : integer;\r
      ResAddr : SetAddr;\r
  \r
    BEGIN\r
      (* Compute min and max for the new set *)\r
          Min := SetKon(1);\r
          Max := SetKon(2);\r
          FOR i := 2 TO LengthSet1 DO\r
            BEGIN\r
              IF Min > SetKon(i * 2 - 1) THEN Min := SetKon(i * 2 - 1);\r
              IF Max <= SetKon(i * 2) THEN Max := SetKon(i * 2);\r
            END;\r
\r
          IF Min < 0 THEN Exception(63);\r
          \r
          Length := ( (Max DIV 8) + 1);\r
\r
      (* Allocate memery *)\r
          ResAddr := GetMemory(Length + #H004);\r
          ResAddr^.Length := Length;\r
\r
          FOR i := 1 TO (Length) DO\r
            ResAddr^.BitVector(i+3) := #H00;\r
\r
          FOR i := 1 TO LengthSet1 DO\r
          BEGIN\r
            HighKon := SetKon(i*2);\r
            LowKon := SetKon(i * 2 - 1);\r
            FOR i := LowKon TO HighKon DO\r
             BEGIN\r
               ByteOffset := (i Div 8)+4;\r
               BitOffset  := i MOD 8;\r
               ResAddr^.BitVector(ByteOffset) := (#H1 Shift BitOffset) OR\r
                                               ResAddr^.BitVector(ByteOffset);\r
             END;\r
         END;\r
     MakeSet := ResAddr;\r
    END;\r
\r
\r
\r
  (************************* LESET ***********************)\r
\r
  FUNCTION LESet(Addr1 : SetAddr; Size1 : Integer;\r
                 Addr2 : SetAddr; Size2 : Integer) : Boolean;\r
   \r
   \r
    VAR\r
      Length : integer;\r
      Res    : Boolean;\r
      Res1,Res2 : Byte;\r
      Index1, Index2 : Integer;\r
      Rel1,Rel2 : Boolean;\r
\r
    BEGIN\r
      index1 := 0;\r
      index2 := 0;\r
      Rel1 := ( size1 = 0);\r
      Rel2 := ( Size2 = 0);\r
      IF Rel1 THEN\r
        BEGIN\r
         Size1 := Addr1^.Length;\r
         Index1 := 4;\r
        END;\r
      IF Rel2 THEN\r
        BEGIN\r
          Size2 := Addr2^.Length;\r
          Index2 := 4;\r
        END;\r
\r
      IF Size1 < size2 THEN Length := Size2 ELSE Length := Size1;\r
\r
      (* <= is made by Bitvector1 = (Bitvector1 and Bitvector2)  *)\r
      Res := True;\r
      FOR Index := 1 TO Length DO\r
        BEGIN\r
          IF (index > size1) THEN\r
            Res1 := 0\r
          ELSE\r
            Res1 := Addr1^.BitVector(Index1 + Index - 1);\r
          IF (index > size2) THEN\r
            Res2 := 0\r
          ELSE\r
            Res2 := Addr2^.BitVector(Index2 + Index - 1);\r
\r
          Res := Res AND (Res1 = (Res1 AND Res2)); \r
        END;\r
\r
\r
       (*  Release memery if nes *)\r
      IF Rel2 THEN\r
        BEGIN\r
          PutMemory(Addr2,Size2 + #H004);\r
        END;\r
\r
      IF Rel1 THEN\r
        BEGIN\r
          PutMemory(Addr1,Size1 + #H004);\r
        END;\r
\r
      LESet := Res;\r
    END;\r
\r
\r
  (**************************** GESET ************************)\r
\r
\r
\r
  FUNCTION GESet(Addr1 : SetAddr; Size1 : Integer;\r
                 Addr2 : SetAddr; Size2 : Integer) : Boolean;\r
\r
\r
    FUNCTION LESet(Addr1 : SetAddr; Size1 : Integer;\r
                 Addr2 : SetAddr; Size2 : Integer) : Boolean; EXTERNAL;\r
   \r
\r
    BEGIN\r
      GESet := LESet(Addr2,Size2,Addr1,Size1);\r
    END;\r
\r
\r
\r
\r
  (***************************** EQSET **************************)\r
\r
  FUNCTION EqSet(Addr1 : SetAddr; Size1 : Integer;\r
                 Addr2 : SetAddr; Size2 : Integer) : Boolean;\r
   \r
   \r
    VAR\r
      Length : integer;\r
      Res : boolean;\r
      Res1,Res2 : Byte;\r
      Index1, Index2 : Integer;\r
      Rel1,Rel2 : Boolean;\r
\r
    BEGIN\r
      index1 := 0;\r
      index2 := 0;\r
      Rel1 := ( size1 = 0);\r
      Rel2 := ( Size2 = 0);\r
      IF Rel1 THEN\r
        BEGIN\r
         Size1 := Addr1^.Length;\r
         Index1 := 4;\r
        END;\r
      IF Rel2 THEN\r
        BEGIN\r
          Size2 := Addr2^.Length;\r
          Index2 := 4;\r
        END;\r
\r
      IF Size1 < size2 THEN Length := Size2 ELSE Length := Size1;\r
\r
      (* = is made by Bitvector1 = Bitvector2  *)\r
      Res := True;\r
      FOR Index := 1 TO Length DO\r
        BEGIN\r
          IF (index > size1) THEN\r
            Res1 := 0\r
          ELSE\r
            Res1 := Addr1^.BitVector(Index1 + Index - 1);\r
          IF (index > size2) THEN\r
            Res2 := 0\r
          ELSE\r
            Res2 := Addr2^.BitVector(Index2 + Index - 1);\r
\r
          Res := Res AND (Res1 = Res2); \r
        END;\r
\r
\r
       (*  Release memery if nes *)\r
      IF Rel2 THEN\r
        BEGIN\r
          PutMemory(Addr2,Size2 + #H004);\r
        END;\r
\r
      IF Rel1 THEN\r
        BEGIN\r
          PutMemory(Addr1,Size1 + #H004);\r
        END;\r
\r
      EQSet := Res;\r
    END;\r
\r
\r
  (**************************** NESET ***************************)\r
\r
\r
  FUNCTION NESet(Addr1 : SetAddr; Size1 : Integer;\r
                 Addr2 : SetAddr; Size2 : Integer) : Boolean;\r
\r
    FUNCTION EqSet(Addr1 : SetAddr; Size1 : Integer;\r
                 Addr2 : SetAddr; Size2 : Integer) : Boolean; EXTERNAL;\r
   \r
\r
\r
    BEGIN\r
      NeSet := Not EQSet(Addr1,Size1,Addr2,Size2);\r
    END\r
\r
       \r
 .\r