home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 2 / goldfish_vol2_cd1.bin / files / comm / misc / elcheapofax / rcs / apack.asm,v < prev    next >
Text File  |  1993-12-21  |  7KB  |  291 lines
  1. head    1.2;
  2. access;
  3. symbols
  4.     OCT93:1.2;
  5. locks;
  6. comment    @;; @;
  7.  
  8.  
  9. 1.2
  10. date    93.06.11.16.33.37;    author Rhialto;    state Exp;
  11. branches;
  12. next    1.1;
  13.  
  14. 1.1
  15. date    93.06.11.14.53.53;    author Rhialto;    state Exp;
  16. branches;
  17. next    ;
  18.  
  19.  
  20. desc
  21. @Assembler version of packer.c
  22. @
  23.  
  24.  
  25. 1.2
  26. log
  27. @First real RCS checkin
  28. @
  29. text
  30. @;; $Id$
  31. ;; $Log$
  32.  
  33. ****************************************************************
  34. *
  35. *  Copyright 1988 by CREATIVE FOCUS.  This code is freely
  36. *  distributable as long as this notice is retained and no
  37. *  other conditions are imposed upon its redistribution.
  38. *
  39. *
  40. *  APACK.ASM --
  41. *
  42. *  A fully compatible replacement for Electronic Arts' PACKER.C
  43. *  routine.  Converts data according to the IFF ILBM cmpByteRun1
  44. *  compression protocol:
  45. *
  46. *     control bytes:
  47. *
  48. *     n =  0.. 127:     followed by n+1 bytes of data;
  49. *     n = -1..-127:     followed by byte to be repeated -n+1 times;
  50. *     n =     -128:     don't do no nada.
  51. *
  52. *     calling format:
  53. *
  54. *     long packrow(from, too, amt)
  55. *        char **from, /* pointer to source data pointer */
  56. *         **too;  /* pointer to destination data pointer */
  57. *        long amt;     /* number of bytes to compress */
  58. *
  59. *     return(number of bytes written to destination);
  60. *
  61. *     effects:
  62. *
  63. *      *from = *from + amt, and *too = *too + return;
  64. *      return is "smart," that is, not greater than
  65. *      MaxPackedSize = amt + ((amt+127) >> 7).
  66. *
  67. *     By commenting out CHECK (below) you disable checking for runs
  68. *     exceeding 128 bytes.  That CHECK is not needed if you are sure
  69. *     the amt to be compressed is always 128 or less.
  70. *
  71. *  !!! DISCLAIMER !!!  You use this code entirely at your own
  72. *  risk.  I don't warrantee its fitness for any purpose.  I
  73. *  can't even guarantee the accuracy of anything I've said
  74. *  about it, though I've tried my damndest to get it right.
  75. *  I may, in fact, be completely out of my tiny little mind :-).
  76. *
  77. *  That being said, I can be reached for questions, comments,
  78. *  or concerns at:
  79. *
  80. *     Dr. Gerald Hull
  81. *     CREATIVE FOCUS
  82. *     12 White Street
  83. *     Binghamton, N.Y.  13901
  84. *     (607) 648-4082
  85. *
  86. *     bix:     ghull
  87. *     PLink:  DRJERRY
  88. *
  89. ***************************************************************
  90.  
  91.       xdef  _PackRow
  92.  
  93. PT    equr  a0              -> beginning of replicate run (if any)
  94. IX    equr  a1              -> end+1 of input line
  95. IP    equr  a2              -> beginning of literal run (if any)
  96. IQ    equr  a3              -> end+1 of lit and/or rep run (if any)
  97. OP    equr  a4              -> end+1 of output line current pos
  98. FP    equr  a6              frame pointer
  99. SP    equr  a7              stack pointer
  100.  
  101. RT    equr  d0              return value
  102. MX    equr  d1              check for maximum run = MAX
  103. AM    equr  d2              amount
  104. CH    equr  d3              character
  105.  
  106. REGS  reg   AM/CH/IP/IQ/OP
  107.  
  108. FRM   equ   8              input line address
  109. TOO   equ   12              output line address
  110. AMT   equ   16              length of input line
  111.  
  112. MAX   equ   128           maximum encodable output run
  113. CHECK equ   1              turns on maximum row checking
  114.  
  115.  
  116. _PackRow
  117.  
  118.  
  119. ***************     CASE 0:   GRAB PARAMS & INITIALIZE
  120. CAS0
  121.       link     FP,#0
  122.       movem.l  REGS,-(SP)
  123.       movea.l  FRM(FP),IP
  124.       movea.l  (IP),IP        IP = *from
  125.       movea.l  IP,IQ          IQ = IP
  126.       movea.l  IQ,IX
  127.       adda.l   AMT(FP),IX     IX = IP + amt
  128.       movea.l  TOO(FP),OP
  129.       movea.l  (OP),OP        OP = *too
  130.  
  131.  
  132. ***************     CASE 1:   LITERAL RUN
  133. CAS1
  134.       movea.l  IQ,PT          adjust PT (no replicates yet!)
  135.       move.b   (IQ)+,CH       grab character
  136.       cmpa.l   IQ,IX          if input is finished
  137.       beq.s    CAS5         branch to case 5
  138.  
  139.       ifd      CHECK
  140.       move.l   IQ,MX
  141.       sub.l    IP,MX
  142.       cmpi     #MAX,MX          if run has reached MAX
  143.       beq.s    CAS6         branch to case 6
  144.       endc
  145.  
  146.       cmp.b    (IQ),CH        if next character != CH
  147.       bne.s    CAS1         stay in case 1
  148.  
  149. *                  else fall into case 2
  150.  
  151.  
  152. ***************     CASE 2:   AT LEAST 2 BYTE REPEAT
  153. CAS2
  154.       move.b   (IQ)+,CH       grab character
  155.       cmpa.l   IQ,IX          if input is finished
  156.       beq.s    CAS7         branch to case 7
  157.  
  158.       ifd      CHECK
  159.       move.l   IQ,MX
  160.       sub.l    IP,MX
  161.       cmpi     #MAX,MX          if run has reached MAX
  162.       beq.s    CAS6         branch to case 6
  163.       endc
  164.  
  165.       cmp.b    (IQ),CH        if next character != CH
  166.       bne.s    CAS1         branch to case 1
  167.  
  168. *                  else fall into case 3
  169.  
  170.  
  171. ***************     CASE 3:   REPLICATE RUN
  172. CAS3
  173.       move.b   (IQ)+,CH       grab character
  174.       cmpa.l   IQ,IX          if input is finished
  175.       beq.s    CAS7         branch to case 7
  176.  
  177.       ifd      CHECK
  178.       move.l   IQ,MX
  179.       sub.l    PT,MX
  180.       cmpi     #MAX,MX          if run has reached MAX
  181.       beq.s    CAS4         branch to case 4
  182.       endc
  183.  
  184.       cmp.b    (IQ),CH        if next character = CH
  185.       beq.s    CAS3         stay in case 3
  186.  
  187. *                  else fall into case 4
  188.  
  189.  
  190. ***************     CASE 4:   LIT AND/OR REP DUMP & CONTINUE
  191. CAS4
  192.       move.l   PT,AM
  193.       sub.l    IP,AM          AM = PT - IP
  194. *                  if no literal run
  195.       beq.s    C41         branch to replicate run
  196.  
  197.       subq     #1,AM          AM = AM - 1
  198.       move.b   AM,(OP)+       output literal control byte
  199.  
  200. C40   move.b   (IP)+,(OP)+    output literal run
  201.       dbra     AM,C40
  202.  
  203. C41   move.l   PT,AM
  204.       sub.l    IQ,AM          AM = PT - IQ (negative result!)
  205.       addq     #1,AM          AM = AM + 1
  206.       move.b   AM,(OP)+       output replicate control byte
  207.       move.b   CH,(OP)+       output repeated character
  208.       movea.l  IQ,IP          reset IP
  209.       bra.s    CAS1          branch to case 1 (not done)
  210.  
  211.  
  212. ***************     CASE 5:   LITERAL DUMP & QUIT
  213. CAS5
  214.       move.l   IQ,AM
  215.       sub.l    IP,AM          AM = IQ - IP (positive result > 0)
  216.       subq     #1,AM          AM = AM - 1
  217.       move.b   AM,(OP)+       output literal control byte
  218.  
  219. C50   move.b   (IP)+,(OP)+    output literal run
  220.       dbra     AM,C50
  221.  
  222.       bra.s    CAS8          branch to case 8 (done)
  223.  
  224.  
  225.       ifd      CHECK
  226.  
  227. ***************     CASE 6:   LITERAL DUMP & CONTINUE
  228. CAS6
  229.       move.l   IQ,AM
  230.       sub.l    IP,AM          AM = IQ - IP (positive result > 0)
  231.       subq     #1,AM          AM = AM - 1
  232.       move.b   AM,(OP)+       output literal control byte
  233.  
  234. C60   move.b   (IP)+,(OP)+    output literal run
  235.       dbra     AM,C60
  236.  
  237.       bra      CAS1          branch to case 1 (not done)
  238.  
  239.       endc
  240.  
  241.  
  242. ***************     CASE 7:   LIT AND/OR REP DUMP & FINISH
  243. CAS7
  244.       move.l   PT,AM
  245.       sub.l    IP,AM          AM = PT - IP (positive result > 0)
  246. *                  if no literal run
  247.       beq.s    C71         branch to replicate run
  248.  
  249.       subq     #1,AM          AM = AM - 1
  250.       move.b   AM,(OP)+       output literal control byte
  251.  
  252. C70   move.b   (IP)+,(OP)+    output literal run
  253.       dbra     AM,C70
  254.  
  255. C71   move.l   PT,AM
  256.       sub.l    IQ,AM          AM = PT - IQ (negative result)
  257.       addq     #1,AM          AM = AM + 1
  258.       move.b   AM,(OP)+       output replicate control byte
  259.       move.b   CH,(OP)+       output repeated character
  260.  
  261. *                  fall into case 8
  262.  
  263.  
  264. ***************     CASE 8:   ADJUST PARAMS & RETURN VALUE
  265. CAS8
  266.       movea.l  FRM(FP),PT     PT = **from
  267.       move.l   IQ,(PT)        *from = *from + amt
  268.       movea.l  TOO(FP),PT     PT = **too
  269.  
  270.       move.l   OP,RT
  271.       sub.l    (PT),RT       return = OP - *too
  272.  
  273.       move.l   OP,(PT)       *too = *too + return
  274.       movem.l  (SP)+,REGS
  275.       UNLK     FP
  276.       rts
  277.  
  278.       end
  279.  
  280.  
  281. @
  282.  
  283.  
  284. 1.1
  285. log
  286. @Initial revision
  287. @
  288. text
  289. @d1 2
  290. @
  291.