home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 1 / crawlyvol1.bin / program / compiler / m2posx14 / src / memblk.ipp < prev    next >
Encoding:
Modula Implementation  |  1994-05-15  |  23.5 KB  |  883 lines
  1. IMPLEMENTATION MODULE MEMBLK;
  2. __IMP_SWITCHES__
  3. __RANGECHECK_OFF__
  4. __STACKCHECK_OFF__
  5. __DEBUG_OFF__
  6. #ifdef HM2
  7. #ifdef __LONG_WHOLE__
  8. (*$!i+: Modul muss mit $i- uebersetzt werden! *)
  9. (*$!w+: Modul muss mit $w- uebersetzt werden! *)
  10. #else
  11. (*$!i-: Modul muss mit $i+ uebersetzt werden! *)
  12. (*$!w-: Modul muss mit $w+ uebersetzt werden! *)
  13. #endif
  14. #endif
  15. (*****************************************************************************)
  16. (* 15-Mai-94, Holger Kleinschmidt                                            *)
  17. (*****************************************************************************)
  18.  
  19. INLINE_CODE_IMPORT
  20.  
  21. FROM SYSTEM IMPORT
  22. (* TYPE *) ADDRESS;
  23.  
  24. FROM types IMPORT
  25. (* TYPE *) int, sizeT;
  26.  
  27. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  28.  
  29. __PROCFRAME_OFF__
  30. PROCEDURE memswap ((* EIN/ -- *) blk1 : ADDRESS;
  31.                    (* EIN/ -- *) blk2 : ADDRESS;
  32.                    (* EIN/ -- *) len  : sizeT   );
  33.  
  34. BEGIN
  35. #if (defined HM2)
  36. (*
  37.   move.w  D2,-(SP)
  38.   movea.l 6(SP),A0
  39.   movea.l 10(SP),A1
  40.   move.l  14(SP),D0
  41. *)
  42.  CODE(3F02H,206FH,0006H,226FH,000AH,202FH,000EH);
  43. #elif (defined MM2)
  44. (*
  45.   move.l  -(A3),D0
  46.   movea.l -(A3),A1
  47.   movea.l -(A3),A0
  48.   tst.l   D0
  49. *)
  50.  CODE(2023H,2263H,2063H,4A80H);
  51. #elif (defined TDIM2)
  52. (*
  53.   movea.l 12(SP),A0
  54.   movea.l 8(SP),A1
  55.   move.l  4(SP),D0
  56. *)
  57.  CODE(206FH,000CH,226FH,0008H,202FH,0004H);
  58. #elif (defined LPRM2) || (defined SPCM2)
  59. (*
  60.   movea.l 20(A6),A0
  61.   movea.l 16(A6),A1
  62.   move.l  12(A6),D0
  63. *)
  64.  CODE(206EH,0014H,226EH,0010H,202EH,000CH);
  65. #endif
  66.  
  67. (*
  68.   beq.s   ende           ; B: len = 0, nix zu tun
  69.   move.w  A0,D1
  70.   move.w  A1,D2
  71.   eor.b   D2,D1          ; genau eine der Adressen ungerade ?
  72.   btst    #0,D1          ;
  73.   beq.s   fastswap       ; B: nein
  74. slowswap:                ; Bloecke byteweise vertauschen
  75.   move.b  (A0),D1
  76.   move.b  (A1),(A0)+
  77.   move.b  D1,(A1)+
  78.   subq.l  #1,D0
  79.   bne.s   slowswap
  80.   bra.s   ende           ; fertig
  81.  
  82. fastswap:
  83.   btst    #0,D2          ; beide Adr. ungerade oder beide gerade ?
  84.   beq.s   longcnt        ; B: beide gerade
  85.   move.b  (A0),D1        ; sonst ein Byte vorneweg tauschen
  86.   move.b  (A1),(A0)+     ; -> gerade Adresse
  87.   move.b  D1,(A1)+
  88.   subq.l  #1,D0          ; eins weniger zu tauschen
  89. longcnt:
  90.   move.b  D0,D2          ; fuer spaeteren Ueberhangtest
  91.   lsr.l   #2,D0          ; Anzahl auszutauschender Langworte
  92.   beq.s   tstwswap       ; B: weniger als 4 Byte
  93. swaplp:                  ; Bloecke langwortweise vertauschen
  94.   move.l  (A0),D1
  95.   move.l  (A1),(A0)+
  96.   move.l  D1,(A1)+
  97.   subq.l  #1,D0
  98.   bne.s   swaplp
  99. tstwswap:
  100.   btst    #1,D2          ; noch ein zusaetzl. Wort auszutauschen ?
  101.   beq.s   tstbswap       ; B: nein
  102.   move.w  (A0),D1
  103.   move.w  (A1),(A0)+
  104.   move.w  D1,(A1)+
  105. tstbswap:
  106.   btst    #0,D2          ; noch ein Byte ?
  107.   beq.s   ende           ; B: nein, fertig
  108.   move.b  (A0),D1
  109.   move.b  (A1),(A0)
  110.   move.b  D1,(A1)
  111. ende:
  112.  
  113. *)
  114.  CODE(674EH,3208H,3409H,0B501H,0801H,0000H);
  115.  CODE(670CH,1210H,10D1H,12C1H,5380H,66F6H,6036H,0802H);
  116.  CODE(0000H,6708H,1210H,10D1H,12C1H,5380H,1400H,0E488H);
  117.  CODE(670AH,2210H,20D1H,22C1H,5380H,66F6H,0802H,0001H);
  118.  CODE(6706H,3210H,30D1H,32C1H,0802H,0000H,6706H,1210H);
  119.  CODE(1091H,1281H);
  120.  
  121. #if (defined HM2)
  122. (*
  123.   move.w  (SP)+,D2
  124.   movea.l (SP)+,A0
  125.   lea     12(SP),SP
  126.   jmp     (A0)
  127. *)
  128.  CODE(341FH,205FH,4FEFH,000CH,4ED0H);
  129. #elif (defined TDIM2)
  130. (*
  131.   rts
  132. *)
  133.  CODE(4E75H);
  134. #endif
  135. END memswap;
  136. __PROCFRAME_ON__
  137.  
  138. (*---------------------------------------------------------------------------*)
  139.  
  140. __PROCFRAME_OFF__
  141. PROCEDURE memmove ((* EIN/ -- *) dst : ADDRESS;
  142.                    (* EIN/ -- *) src : ADDRESS;
  143.                    (* EIN/ -- *) len : sizeT   );
  144.  
  145. BEGIN
  146. #if (defined HM2)
  147. (*
  148.   move.w  D2,-(SP)
  149.   movea.l 10(SP),A0
  150.   movea.l 6(SP),A1
  151.   move.l  14(SP),D0
  152. *)
  153.  CODE(3F02H,206FH,000AH,226FH,0006H,202FH,000EH);
  154. #elif (defined MM2)
  155. (*
  156.   move.l  -(A3),D0
  157.   movea.l -(A3),A0
  158.   movea.l -(A3),A1
  159.   tst.l   D0
  160. *)
  161.  CODE(2023H,2063H,2263H,4A80H);
  162. #elif (defined TDIM2)
  163. (*
  164.   movea.l 8(SP),A0
  165.   movea.l 12(SP),A1
  166.   move.l  4(SP),D0
  167. *)
  168.  CODE(206FH,0008H,226FH,000CH,202FH,0004H);
  169. #elif (defined LPRM2) || (defined SPCM2)
  170. (*
  171.   movea.l 16(A6),A0
  172.   movea.l 20(A6),A1
  173.   move.l  12(A6),D0
  174. *)
  175.  CODE(206EH,0010H,226EH,0014H,202EH,000CH);
  176. #endif
  177.  
  178. (*
  179.   beq     ende           ; B: len = 0, nix zu tun
  180.   cmpa.l  A0,A1          ; Zieladresse groesser als Quelladresse ?
  181.   bhi     special        ; B: ja, muss von hinten nach vorne kopiert werden
  182.                          ; falls sich die Bereiche ueberschneiden
  183.   move.w  A0,D1          ; genau eine Adresse ungerade ?
  184.   move.w  A1,D2          ;
  185.   eor.b   D2,D1          ;
  186.   btst    #0,D1          ;
  187.   beq.s   nfastcpy       ; B: nein, beide gerade/ungerade -> schnell kopieren
  188.  
  189. * Es muss langsam byteweise kopiert werden.
  190. * Der Trick mit dem Sprung in die Kopieranweisungen stammt aus
  191. * dem "bcopy()" der GnuLib/MiNTLib
  192.  
  193.   move.w  D0,D1          ; die Anzahl Bytes im letzten unvollstaendigen 8-er-
  194.   neg.w   D1             ; Block und entsprechenden Index in die
  195.   andi.w  #7,D1          ; Kopieranweisungen berechnen
  196.   add.w   D1,D1          ;
  197.   addq.l  #7,D0          ; plus 1 Block, falls unvollst. Block
  198.   lsr.l   #3,D0          ; Anzahl kompletter 8-er Bloecke [+ unvollst. Block]
  199.   jmp     nloop8(PC,D1.w) ; ersten vollst. oder unvollst. Block kopieren
  200. nloop8:                  ; jeweils 8 Byte kopieren
  201.   move.b  (A0)+,(A1)+
  202.   move.b  (A0)+,(A1)+
  203.   move.b  (A0)+,(A1)+
  204.   move.b  (A0)+,(A1)+
  205.   move.b  (A0)+,(A1)+
  206.   move.b  (A0)+,(A1)+
  207.   move.b  (A0)+,(A1)+
  208.   move.b  (A0)+,(A1)+
  209.   subq.l  #1,D0
  210.   bne.s   nloop8
  211.   bra     ende
  212.  
  213. nfastcpy:
  214.   btst    #0,D2          ; beide Adressen ungerade ?
  215.   beq.s   neven          ; B: nein
  216.   move.b  (A0)+,(A1)+    ; ein Byte vorneweg -> gerade Adressen
  217.   subq.l  #1,D0          ; ein Byte weniger zu kopieren
  218. neven:
  219.   move.b  D0,D2          ; fuer spaeteren Ueberhangtest
  220.   lsr.l   #2,D0          ; Anzahl zu kopierender Langworte
  221.   beq.s   ntstw          ; B: weniger als 4 Byte
  222.   move.w  D0,D1          ; die Anzahl Bytes im letzten unvollstaendigen 32-er-
  223.   neg.w   D1             ; Block und entsprechenden Index in die
  224.   andi.w  #7,D1          ; Kopieranweisungen berechnen
  225.   add.w   D1,D1          ;
  226.   addq.l  #7,D0          ; plus 1 Block, falls unvollst. Block
  227.   lsr.l   #3,D0          ; Anzahl von 32-er-Bloecken [+ unvollst Block]
  228.   jmp     nloop32(PC,D1.w) ; ersten vollst. oder unvollst. Block kopieren
  229. nloop32:                 ; jeweils 32 Byte kopieren
  230.   move.l  (A0)+,(A1)+
  231.   move.l  (A0)+,(A1)+
  232.   move.l  (A0)+,(A1)+
  233.   move.l  (A0)+,(A1)+
  234.   move.l  (A0)+,(A1)+
  235.   move.l  (A0)+,(A1)+
  236.   move.l  (A0)+,(A1)+
  237.   move.l  (A0)+,(A1)+
  238.   subq.l  #1,D0
  239.   bne.s   nloop32
  240. ntstw:
  241.   btst    #1,D2          ; ein zusaetzliches Wort ?
  242.   beq.s   ntstb          ; B: nein
  243.   move.w  (A0)+,(A1)+
  244. ntstb:
  245.   btst    #0,D2          ; ein zusaetzliches Byte ?
  246.   beq     ende           ; B: nein, fertig
  247.   move.b  (A0)+,(A1)+
  248.   bra.s   ende
  249.  
  250. * wie oben, nur alles von hinten nach vorne kopieren
  251.  
  252. special:
  253.   adda.l  D0,A0
  254.   adda.l  D0,A1
  255.  
  256.   move.w  A0,D1
  257.   move.w  A1,D2
  258.   eor.b   D2,D1
  259.   btst    #0,D1
  260.   beq.s   sfastcpy
  261.  
  262.   move.w  D0,D1
  263.   neg.w   D1
  264.   andi.w  #7,D1
  265.   add.w   D1,D1
  266.   addq.l  #7,D0
  267.   lsr.l   #3,D0
  268.   jmp     sloop8(PC,D1.w)
  269. sloop8:
  270.   move.b  -(A0),-(A1)
  271.   move.b  -(A0),-(A1)
  272.   move.b  -(A0),-(A1)
  273.   move.b  -(A0),-(A1)
  274.   move.b  -(A0),-(A1)
  275.   move.b  -(A0),-(A1)
  276.   move.b  -(A0),-(A1)
  277.   move.b  -(A0),-(A1)
  278.   subq.l  #1,D0
  279.   bne.s   sloop8
  280.   bra.s   ende
  281.  
  282. sfastcpy:
  283.   btst    #0,D2
  284.   beq.s   seven
  285.   move.b  -(A0),-(A1)
  286.   subq.l  #1,D0
  287. seven:
  288.   move.b  D0,D2
  289.   lsr.l   #2,D0
  290.   beq.s   ststw
  291.   move.w  D0,D1
  292.   neg.w   D1
  293.   andi7.w  #7,D1
  294.   add.w   D1,D1
  295.   addq.l  #7,D0
  296.   lsr.l   #3,D0
  297.   jmp     sloop32(PC,D1.w)
  298. sloop32:
  299.   move.l  -(A0),-(A1)
  300.   move.l  -(A0),-(A1)
  301.   move.l  -(A0),-(A1)
  302.   move.l  -(A0),-(A1)
  303.   move.l  -(A0),-(A1)
  304.   move.l  -(A0),-(A1)
  305.   move.l  -(A0),-(A1)
  306.   move.l  -(A0),-(A1)
  307.   subq.l  #1,D0
  308.   bne.s   sloop32
  309. ststw:
  310.   btst    #1,D2
  311.   beq.s   ststb
  312.   move.w  -(A0),-(A1)
  313. ststb:
  314.   btst    #0,D2
  315.   beq.s   ende
  316.   move.b  -(A0),-(A1)
  317.  
  318. ende:
  319. *)
  320.  CODE(6700H,0106H,0B3C8H,6200H,0082H,3208H);
  321.  CODE(3409H,0B501H,0801H,0000H,672AH,3200H,4441H,0241H);
  322.  CODE(0007H,0D241H,5E80H,0E688H,4EFBH,1002H,12D8H,12D8H);
  323.  CODE(12D8H,12D8H,12D8H,12D8H,12D8H,12D8H,5380H,66ECH);
  324.  CODE(6000H,00CAH,0802H,0000H,6704H,12D8H,5380H,1400H);
  325.  CODE(0E488H,6726H,3200H,4441H,0241H,0007H,0D241H,5E80H);
  326.  CODE(0E688H,4EFBH,1002H,22D8H,22D8H,22D8H,22D8H,22D8H);
  327.  CODE(22D8H,22D8H,22D8H,5380H,66ECH,0802H,0001H,6702H);
  328.  CODE(32D8H,0802H,0000H,6700H,0084H,12D8H,607EH,0D1C0H);
  329.  CODE(0D3C0H,3208H,3409H,0B501H,0801H,0000H,6728H,3200H);
  330.  CODE(4441H,0241H,0007H,0D241H,5E80H,0E688H,4EFBH,1002H);
  331.  CODE(1320H,1320H,1320H,1320H,1320H,1320H,1320H,1320H);
  332.  CODE(5380H,66ECH,6046H,0802H,0000H,6704H,1320H,5380H);
  333.  CODE(1400H,0E488H,6726H,3200H,4441H,0241H,0007H,0D241H);
  334.  CODE(5E80H,0E688H,4EFBH,1002H,2320H,2320H,2320H,2320H);
  335.  CODE(2320H,2320H,2320H,2320H,5380H,66ECH,0802H,0001H);
  336.  CODE(6702H,3320H,0802H,0000H,6702H,1320H);
  337.  
  338. #if (defined HM2)
  339. (*
  340.   move.w  (SP)+,D2
  341.   movea.l (SP)+,A0
  342.   lea     12(SP),SP
  343.   jmp     (A0)
  344. *)
  345.  CODE(341FH,205FH,4FEFH,000CH,4ED0H);
  346. #elif (defined TDIM2)
  347. (*
  348.   rts
  349. *)
  350.  CODE(4E75H);
  351. #endif
  352. END memmove;
  353. __PROCFRAME_ON__
  354.  
  355. (*---------------------------------------------------------------------------*)
  356.  
  357. __PROCFRAME_OFF__
  358. PROCEDURE memset ((* EIN/ -- *) dst : ADDRESS;
  359.                   (* EIN/ -- *) val : int;
  360.                   (* EIN/ -- *) len : sizeT    );
  361.  
  362. BEGIN
  363. #if (defined HM2)
  364. (*
  365.   move.w  D2,-(SP)
  366.   movea.l 6(SP),A0
  367. #if (defined __LONG_WHOLE__)
  368.   move.w  10+2(SP),D1
  369.   move.l  14(SP),D0
  370. #else
  371.   move.w  10(SP),D1
  372.   move.l  12(SP),D0
  373. #endif
  374. *)
  375.  CODE(3F02H,206FH,0006H);
  376. #if (defined __LONG_WHOLE__)
  377.  CODE(322FH,000CH,202FH,000EH);
  378. #else
  379.  CODE(322FH,000AH,202FH,000CH);
  380. #endif
  381. #elif (defined MM2)
  382. (*
  383.   move.l  -(A3),D0
  384. #if (defined __LONG_WHOLE__)
  385.   move.l  -(A3),D1
  386. #else
  387.   move.w  -(A3),D1
  388. #endif
  389.   movea.l -(A3),A0
  390.   tst.l   D0
  391. *)
  392.  CODE(2023H);
  393. #if (defined __LONG_WHOLE__)
  394.  CODE(2223H);
  395. #else
  396.  CODE(3223H);
  397. #endif
  398.  CODE(2063H,4A80H);
  399. #elif (defined TDIM2)
  400. (*
  401.   movea.l 10(SP),A0
  402.   move.w  8(SP),D1
  403.   move.l  4(SP),D0
  404. *)
  405.  CODE(206FH,000AH,322FH,0008H,202FH,0004H);
  406. #elif (defined LPRM2) || (defined SPCM2)
  407. (*
  408.   movea.l 18(A6),A0
  409.   move.w  16(A6),D1
  410.   move.l  12(A6),D0
  411. *)
  412.  CODE(206EH,0012H,322EH,0010H,202EH,000CH);
  413. #endif
  414.  
  415. (*
  416.   beq.s   ende           ; B: len = 0, nix zu tun
  417.  
  418.   move.b  D1,D2
  419.   lsl.w   #8,D2
  420.   move.b  D1,D2
  421.   move.w  D2,D1
  422.   swap    D1
  423.   move.w  D2,D1
  424.  
  425.   move.w  A0,D2          ; Anfangsadresse ungerade ?
  426.   btst    #0,D2          ;
  427.   beq.s   even           ; B: nein
  428.   move.b  D1,(A0)+       ; sonst ein Byte vorneweg kopieren
  429.   subq.l  #1,D0
  430. even:
  431.   movea.w D0,A1          ; Anzahl der Bytes fuer spaeteren Ueberhangtest merken
  432.   lsr.l   #2,D0          ; Anzahl von Langworten
  433.   beq.s   tstw           ; B: weniger als 4 Byte zu kopieren
  434.   move.w  D0,D2          ; die Anzahl Bytes im letzten unvollstaendigen 32-er-
  435.   neg.w   D2             ; Block und entsprechenden Index in die
  436.   andi.w  #7,D2          ; Kopieranweisungen berechnen
  437.   add.w   D2,D2
  438.   addq.l  #7,D0          ; plus 1 Block, falls unvollst. Block (< 32 Byte)
  439.   lsr.l   #3,D0          ; Anzahl kompletter 32-Byte-Bloecke [+ unvollst. Block]
  440.   jmp     loop32(PC,D2.w) ; ersten kompletten oder unvollst. Block loeschen
  441. loop32:                  ; jeweils 32 Byte loeschen
  442.   move.l  D1,(A0)+
  443.   move.l  D1,(A0)+
  444.   move.l  D1,(A0)+
  445.   move.l  D1,(A0)+
  446.   move.l  D1,(A0)+
  447.   move.l  D1,(A0)+
  448.   move.l  D1,(A0)+
  449.   move.l  D1,(A0)+
  450.   subq.l  #1,D0
  451.   bne.s   loop32         ; naechsten kompletten Block loeschen
  452. tstw:
  453.   move.w  A1,D2
  454.   btst    #1,D2          ; ein zusaetzliches Wort ?
  455.   beq.s   tstb           ; B: nein
  456.   move.w  D1,(A0)+
  457. tstb:
  458.   btst    #0,D2          ; ein zusaetzliches Byte ?
  459.   beq.s   ende           ; B: nein
  460.   move.b  D1,(A0)+
  461. ende:
  462. *)
  463.  CODE(6756H,1401H,0E14AH,1401H,3202H,4841H,3202H,3408H,0802H);
  464.  CODE(0000H,6704H,10C1H,5380H,3240H,0E488H,6726H,3400H);
  465.  CODE(4442H,0242H,0007H,0D442H,5E80H,0E688H,4EFBH,2002H);
  466.  CODE(20C1H,20C1H,20C1H,20C1H,20C1H,20C1H,20C1H,20C1H);
  467.  CODE(5380H,66ECH,3409H,0802H,0001H,6702H,30C1H,0802H);
  468.  CODE(0000H,6702H,10C1H);
  469.  
  470. #if (defined HM2)
  471. (*
  472.   move.w  (SP)+,D2
  473.   movea.l (SP)+,A0
  474. #if (defined __LONG_WHOLE__)
  475.   lea     12(SP),SP
  476. #else
  477.   lea     10(SP),SP
  478. #endif
  479.   jmp     (A0)
  480. *)
  481.  CODE(341FH,205FH);
  482. #if (defined __LONG_WHOLE__)
  483.  CODE(4FEFH,000CH);
  484. #else
  485.  CODE(4FEFH,000AH);
  486. #endif
  487.  CODE(4ED0H);
  488. #elif (defined TDIM2)
  489. (*
  490.   rts
  491. *)
  492.  CODE(4E75H);
  493. #endif
  494. END memset;
  495. __PROCFRAME_ON__
  496.  
  497. (*---------------------------------------------------------------------------*)
  498.  
  499. __PROCFRAME_OFF__
  500. PROCEDURE memchr ((* EIN/ -- *) src : ADDRESS;
  501.                   (* EIN/ -- *) val : int;
  502.                   (* EIN/ -- *) len : sizeT    ): ADDRESS;
  503.  
  504. BEGIN
  505. #if (defined HM2)
  506. (*
  507.   move.l  D2,-(SP)
  508.   movea.l 8(SP),A0
  509. #if (defined __LONG_WHOLE__)
  510.   move.w  12+2(SP),D1
  511.   move.l  16(SP),D0
  512. #else
  513.   move.w  12(SP),D1
  514.   move.l  14(SP),D0
  515. #endif
  516. *)
  517.  CODE(2F02H,206FH,0008H);
  518. #if (defined __LONG_WHOLE__)
  519.  CODE(322FH,000EH,202FH,0010H);
  520. #else
  521.  CODE(322FH,000CH,202FH,000EH);
  522. #endif
  523. #elif (defined MM2)
  524. (*
  525.   move.l  -(A3),D0
  526. #if (defined __LONG_WHOLE__)
  527.   move.l  -(A3),D1
  528. #else
  529.   move.w  -(A3),D1
  530. #endif
  531.   movea.l -(A3),A0
  532.   tst.l   D0
  533. *)
  534.  CODE(2023H);
  535. #if (defined __LONG_WHOLE__)
  536.  CODE(2223H);
  537. #else
  538.  CODE(3223H);
  539. #endif
  540.  CODE(2063H,4A80H);
  541. #elif (defined TDIM2)
  542. (*
  543.   movea.l 10(SP),A0
  544.   move.w  8(SP),D1
  545.   move.l  4(SP),D0
  546. *)
  547.  CODE(206FH,000AH,322FH,0008H,202FH,0004H);
  548. #elif (defined LPRM2) || (defined SPCM2)
  549. (*
  550.   movea.l 18(A6),A0
  551.   move.w  16(A6),D1
  552.   move.l  12(A6),D0
  553. *)
  554.  CODE(206EH,0012H,322EH,0010H,202EH,000CH);
  555. #endif
  556.  
  557. (*
  558.   beq.s   ende
  559.  
  560.   subq.l  #1,D0
  561.   move.l  D0,D2
  562.   swap    D2
  563. lp:
  564.   cmp.b   (A0)+,D1
  565. start:
  566.   dbeq    D0,lp
  567.   dbeq    D2,lp
  568.   beq.s   found
  569.   moveq   #0,D0
  570.   bra.s   ende
  571. found:
  572.   move.l  A0,D0
  573.   subq.l  #1,D0
  574. ende:
  575. *)
  576.  CODE(671AH,5380H,2400H,4842H,0B218H,57C8H,0FFFCH,57CAH);
  577.  CODE(0FFF8H,6704H,7000H,6004H,2008H,5380H);
  578.  
  579. #if (defined HM2)
  580.  CODE(241FH);       (* move.l  (SP)+,D2 *)
  581.  CODE(205FH);       (* move.l  (SP)+,A0 *)
  582. #if (defined __LONG_WHOLE__)
  583.  CODE(4FEFH,000CH); (* lea     12(SP),SP *)
  584. #else
  585.  CODE(4FEFH,000AH); (* lea     10(SP),SP *)
  586. #endif
  587.  CODE(4ED0H);       (* jmp     (A0) *)
  588. #elif (defined MM2) && (defined __RES_ON_STACK__)
  589.  CODE(26C0H);       (* move.l  D0,(A3)+ *)
  590. #elif (defined LPRM2) || (defined SPCM2)
  591.  CODE(2D40H,0016H); (* move.l  D0,22(A6) *)
  592.  CODE(4E5EH);       (* unlk    A6 *)
  593.  CODE(285FH);       (* movea.l (SP)+,A4 *)
  594.  CODE(205FH);       (* movea.l (SP)+,A0 *)
  595.  CODE(4FEFH,000AH); (* lea     10(SP),SP *)
  596.  CODE(4ED0H);       (* jmp     (A0) *)
  597. #elif (defined TDIM2)
  598.  CODE(2F40H,000EH); (* move.l  D0,14(SP) *)
  599.  CODE(4E75H);       (* rts *)
  600. #endif
  601. END memchr;
  602. __PROCFRAME_ON__
  603.  
  604. (*---------------------------------------------------------------------------*)
  605.  
  606. __PROCFRAME_OFF__
  607. PROCEDURE memcmp ((* EIN/ -- *) blk1 : ADDRESS;
  608.                   (* EIN/ -- *) blk2 : ADDRESS;
  609.                   (* EIN/ -- *) len  : sizeT   ): int;
  610.  
  611. BEGIN
  612. #if (defined HM2)
  613. (*
  614.   move.w  D2,-(SP)
  615.   movea.l 6(SP),A0
  616.   movea.l 10(SP),A1
  617.   move.l  14(SP),D0
  618. *)
  619.  CODE(3F02H,206FH,0006H,226FH,000AH,202FH,000EH);
  620. #elif (defined MM2)
  621. (*
  622.   move.l  -(A3),D0
  623.   movea.l -(A3),A1
  624.   movea.l -(A3),A0
  625.   tst.l   D0
  626. *)
  627.  CODE(2023H,2263H,2063H,4A80H);
  628. #elif (defined TDIM2)
  629. (*
  630.   movea.l 12(SP),A0
  631.   movea.l 8(SP),A1
  632.   move.l  4(SP),D0
  633. *)
  634.  CODE(206FH,000CH,226FH,0008H,202FH,0004H);
  635. #elif (defined LPRM2) || (defined SPCM2)
  636. (*
  637.   movea.l 20(A6),A0
  638.   movea.l 16(A6),A1
  639.   move.l  12(A6),D0
  640. *)
  641.  CODE(206EH,0014H,226EH,0010H,202EH,000CH);
  642. #endif
  643.  
  644. (*
  645.   beq.s   equal
  646.   move.w  A0,D1
  647.   move.w  A1,D2
  648.   eor.b   D2,D1          ; genau eine der Adressen ungerade ?
  649.   btst    #0,D1          ;
  650.   beq.s   fastcmp        ; B: nein
  651. slowcmp:
  652.   cmpm.b  (A0)+,(A1)+
  653.   bne.s   notequal
  654.   subq.l  #1,D0
  655.   bne.s   slowcmp
  656.   bra.s   equal
  657.  
  658. fastcmp:
  659.   btst    #0,D2           ; beide Adressen ungerade ?
  660.   beq.s   longcnt         ; B: nein, beide gerade
  661.   cmpm.b  (A0)+,(A1)+     ; sonst ein Byte vergl. -> gerade Adr.
  662.   bne.s   notequal        ; B: schon das erste Byte unterschiedlich
  663.   subq.l  #1, D0          ; sonst ein Byte weniger zu vergleichen
  664. longcnt:
  665.   move.b  D0,D2           ; fuer Ueberhangtest
  666.   lsr.l   #2,D0           ; Anzahl zu vergleichender Langworte
  667.   beq.s   tstwcmp         ; B: weniger als 4 Bytes zu vergleichen
  668. cmplp:
  669.   cmpm.l  (A0)+,(A1)+
  670.   bne.s   notequal
  671.   subq.l  #1,D0
  672.   bne.s   cmplp
  673. tstwcmp:
  674.   btst    #1,D2           ; noch mindestens ein abschliessendes Wort vergl. ?
  675.   beq.s   tstbcmp         ; B: nein
  676.   cmpm.w  (A0)+,(A1)+     ; letztes Wort auch gleich ?
  677.   bne.s   notequal        ; B: nein
  678. tstbcmp:
  679.   btst    #0,D2           ; noch ein abschliessendes Byte vergl. ?
  680.   beq.s   equal           ; B: nein, Bloecke sind gleich
  681.   cmpm.b  (A0)+,(A1)+     ; letztes Byte auch gleich ?
  682.   bne.s   notequal        ; B: nein
  683. equal:
  684.   moveq   #0,D0
  685.   bra.s   ende
  686. notequal:
  687.   bhi.s   less            ; B: blk1 < blk2
  688.   moveq   #1,D0           ; sonst blk1 > blk2
  689.   bra.s   ende
  690. less:
  691.   moveq   #-1,D0
  692. ende:
  693. *)
  694.  CODE(6744H,3208H,3409H,0B501H,0801H,0000H,670AH,0B308H);
  695.  CODE(6638H,5380H,66F8H,602EH,0802H,0000H,6706H,0B308H);
  696.  CODE(6628H,5380H,1400H,0E488H,6708H,0B388H,661CH,5380H);
  697.  CODE(66F8H,0802H,0001H,6704H,0B348H,660EH,0802H,0000H);
  698.  CODE(6704H,0B308H,6604H,7000H,6008H,6204H,7001H,6002H);
  699.  CODE(70FFH);
  700.  
  701. #if (defined HM2)
  702.  CODE(341FH);       (* move.w  (SP)+,D2 *)
  703.  CODE(205FH);       (* move.l  (SP)+,A0 *)
  704.  CODE(4FEFH,000CH); (* lea     12(SP),SP *)
  705.  CODE(4ED0H);       (* jmp     (A0) *)
  706. #elif (defined MM2)
  707. #ifdef __RES_ON_STACK__
  708. #ifdef __LONG_WHOLE__
  709.  CODE(26C0H);       (* move.l  D0,(A3)+ *)
  710. #else
  711.  CODE(36C0H);       (* move.w  D0,(A3)+ *)
  712. #endif
  713. #endif
  714. #elif (defined LPRM2) || (defined SPCM2)
  715.  CODE(3D40H,0018H); (* move.w  D0,24(A6) *)
  716.  CODE(4E5EH);       (* unlk    A6 *)
  717.  CODE(285FH);       (* movea.l (SP)+,A4 *)
  718.  CODE(205FH);       (* movea.l (SP)+,A0 *)
  719.  CODE(4FEFH,000CH); (* lea     12(SP),SP *)
  720.  CODE(4ED0H);       (* jmp     (A0) *)
  721. #elif (defined TDIM2)
  722.  CODE(3F40H,0010H); (* move.w  D0,16(SP) *)
  723.  CODE(4E75H);       (* rts *)
  724. #endif
  725. END memcmp;
  726. __PROCFRAME_ON__
  727.  
  728. (*---------------------------------------------------------------------------*)
  729.  
  730. #if (defined LPRM2) || (defined SPCM2)
  731. PROCEDURE memalloc ((* EIN/ -- *)     size : sizeT;
  732.                     (* -- /AUS *) VAR old  : ADDRESS;
  733.                     (* -- /AUS *) VAR adr  : ADDRESS );
  734.  
  735. BEGIN
  736. (*
  737.   movea.l (SP)+,A6      ; A6 -> lokale Variablen des Aufrufers
  738.   movea.l (SP)+,A4      ; A4 -> globale Variablen des Aufrufers
  739.   movea.l (SP)+,A1      ; A1 := RTN-Adresse
  740.   movea.l (SP)+,A2      ; A2 -> <adr>
  741.   movea.l (SP)+,A0      ; A0 -> <old>
  742.   move.l  (SP)+,D0      ; D0 := <size>
  743.   move.l  SP,(A0)       ; <old> := Stackpointer vor Aufruf der Funktion
  744.   addq.l  #1,D0         ; <size> auf gerade Anzahl aufrunden
  745.   bclr    #0,D0         ;
  746.   suba.l  D0,SP         ; Neuer Stackpointer
  747.   move.l  SP,(A2)       ; <adr> := Neuer Stackpointer
  748.   jmp     (A1)          ; RETURN
  749. *)
  750.  CODE(2C5FH,285FH,225FH,245FH,205FH,201FH,208FH,5280H);
  751.  CODE(0880H,0000H,9FC0H,248FH,4ED1H);
  752. END memalloc;
  753.  
  754. (*---------------------------------------------------------------------------*)
  755.  
  756. PROCEDURE memdealloc ((* EIN/ -- *) old : ADDRESS );
  757. BEGIN
  758. (*
  759.   movea.l (SP)+,A6      ; A6 -> lokale Variablen des Aufrufers
  760.   movea.l (SP)+,A4      ; A4 -> globale Variablen des Aufrufers
  761.   movea.l (SP)+,A1      ; A1 := RTN-Adresse
  762.   movea.l (SP),SP       ; Stack setzen
  763.   jmp     (A1)          ; RETURN
  764. *)
  765.  CODE(2C5FH,285FH,225FH,2E57H,4ED1H);
  766. END memdealloc;
  767.  
  768. #elif (defined TDIM2)
  769.  
  770. __PROCFRAME_OFF__
  771. PROCEDURE memalloc ((* EIN/ -- *)     size : sizeT;
  772.                     (* -- /AUS *) VAR old  : ADDRESS;
  773.                     (* -- /AUS *) VAR adr  : ADDRESS );
  774.  
  775. BEGIN
  776. (*
  777.   movea.l (SP)+,A1         ; A1 := RTN-Adresse
  778.   movea.l (SP)+,A2         ; A2 -> <adr>
  779.   movea.l (SP)+,A0         ; A0 -> <old>
  780.   move.l  (SP)+,D0         ; D0 := <size>
  781.   move.l  SP,(A0)          ; <old> := Stackpointer vor Aufruf der Funktion
  782.   addq.l  #1,D0            ; <size> auf gerade Anzahl aufrunden
  783.   bclr    #0,D0            ;
  784.   suba.l  D0,SP            ; Neuer Stackpointer
  785.   move.l  SP,(A2)          ; <adr> := Neuer Stackpointer
  786.   lea     -12(SP),SP       ; fuer Parameterkorrektur vom Aufrufer
  787.   jmp     (A1)             ; RETURN
  788. *)
  789.  CODE(225FH,245FH,205FH,201FH,208FH,5280H,0880H,0000H);
  790.  CODE(9FC0H,248FH,4FEFH,0FFF4H,4ED1H);
  791. END memalloc;
  792. __PROCFRAME_ON__
  793. (*---------------------------------------------------------------------------*)
  794. __PROCFRAME_OFF__
  795. PROCEDURE memdealloc ((* EIN/ -- *) old : ADDRESS );
  796. BEGIN
  797. (*
  798.   movea.l (SP)+,A1         ; A1 := RTN-Adresse
  799.   movea.l (SP),SP          ; Stackpointer setzen
  800.   subq.l  #4,SP            ; fuer Parameterkorrektur vom Aufrufer
  801.   jmp     (A1)             ; RETURN
  802. *)
  803.  CODE(225FH,2E57H,598FH,4ED1H);
  804. END memdealloc;
  805. __PROCFRAME_ON__
  806.  
  807. #elif (defined HM2)
  808.  
  809. __PROCFRAME_OFF__
  810. PROCEDURE memalloc ((* EIN/ -- *)     size : sizeT;
  811.                     (* -- /AUS *) VAR old  : ADDRESS;
  812.                     (* -- /AUS *) VAR adr  : ADDRESS );
  813.  
  814. BEGIN
  815. (*
  816.   movea.l (SP)+,A1         ; A1 := RTN-Adresse
  817.   move.l  (SP)+,D0         ; D0 := <size>
  818.   movea.l (SP)+,A0         ; A0 -> <old>
  819.   move.l  (SP)+,D1         ; D1 -> <adr>
  820.   move.l  SP,(A0)          ; <old> := Stackpointer vor Aufruf der Funktion
  821.   addq.l  #1,D0            ; <size> auf gerade Anzahl aufrunden
  822.   bclr    #0,D0            ;
  823.   suba.l  D0,SP            ; Neuer Stackpointer
  824.   movea.l D1,A0            ; <adr> := Neuer Stackpointer
  825.   move.l  SP,(A0)          ;
  826.   jmp     (A1)             ; RETURN
  827. *)
  828.  CODE(225FH,201FH,205FH,221FH,208FH,5280H,0880H,0000H);
  829.  CODE(9FC0H,2041H,208FH,4ED1H);
  830. END memalloc;
  831. __PROCFRAME_ON__
  832. (*---------------------------------------------------------------------------*)
  833. __PROCFRAME_OFF__
  834. PROCEDURE memdealloc ((* EIN/ -- *) old : ADDRESS );
  835. BEGIN
  836. (*
  837.   movea.l (SP)+,A1         ; A1 := RTN-Adresse
  838.   movea.l (SP),SP          ; Stackpointer setzen
  839.   jmp     (A1)             ; RETURN
  840. *)
  841.  CODE(225FH,2E57H,4ED1H);
  842. END memdealloc;
  843. __PROCFRAME_ON__
  844.  
  845. #elif (defined MM2)
  846.  
  847. __PROCFRAME_OFF__
  848. PROCEDURE memalloc ((* EIN/ -- *)     size : sizeT;
  849.                     (* -- /AUS *) VAR old  : ADDRESS;
  850.                     (* -- /AUS *) VAR adr  : ADDRESS );
  851.  
  852. BEGIN
  853.  ASSEMBLER
  854.    MOVEA.L -(A3),A2        ; A2 -> <adr>
  855.    MOVEA.L -(A3),A0        ; A0 -> <old>
  856.    MOVE.L  -(A3),D0        ; D0 := <size>
  857.    MOVEA.L (A7)+,A1        ; A1 := RTN-Adresse
  858.    MOVE.L  A7,(A0)         ; <old> := Stackpointer vor Aufruf der Funktion
  859.    ADDQ.L  #1,D0           ; <size> auf gerade Anzahl aufrunden
  860.    BCLR    #0,D0           ;
  861.    SUBA.L  D0,A7           ; Neuer Stackpointer
  862.    MOVE.L  A7,(A2)         ; <adr> := Neuer Stackpointer
  863.    JMP     (A1)            ; RETURN
  864.  END;
  865. END memalloc;
  866. __PROCFRAME_ON__
  867.  
  868. (*---------------------------------------------------------------------------*)
  869.  
  870. __PROCFRAME_OFF__
  871. PROCEDURE memdealloc ((* EIN/ -- *) old : ADDRESS );
  872. BEGIN
  873.  ASSEMBLER
  874.    MOVEA.L (A7)+,A1        ; A1 := RTN-Adresse
  875.    MOVEA.L -(A3),A7        ; Stackpointer setzen
  876.    JMP     (A1)            ; RETURN
  877.  END;
  878. END memdealloc;
  879. __PROCFRAME_ON__
  880. #endif
  881.  
  882. END MEMBLK.
  883.