/
GreggyBitsDefProc.a
298 lines (264 loc) · 11.4 KB
/
GreggyBitsDefProc.a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
;
; File: GreggyBitsDefProc.a
;
; Contains: Decompress defProc for GreggyBits decompression "'dcmp'(2)"
;
; Written by: Greg Marriott
;
; Copyright: © 1990-1991 by Apple Computer, Inc., all rights reserved.
;
; Change History (most recent first):
;
; <6> 12/18/91 pvh Remove '040 cache flushing from here and move to
; DeCompressorPatch.a where it will do more good for mankind.
; <5> 12/10/91 pvh Added cache flushing for '040s at end of decompression. This
; appears to clear up boot problems on the Quadras.
; <4> 1/30/91 gbm sab, #38: Change the name of one of the decompressor header
; files (because Sheila said it was okay)
; <3> 12/14/90 dba & sab: make a small optimization to the decompressor
; <2> 9/4/90 gbm add new calling interface for new defProcs (like this one)
; <1> 9/3/90 gbm first checked in
; 9/3/90 gbm Newly checked in today
;
; To Do:
;
LOAD 'StandardEqu.d'
include 'DecompressorPatchEqu.a'
IF &TYPE('forCompressor')='UNDEFINED' THEN
forCompressor: SET 0
ENDIF
;
; First, we have the offset table for the three entry points used by the decompress patch
;
EntryPointTable proc
import PrepareForDecompression, WordForByte, CleanUpAfterDecompression
dc.w PrepareForDecompression-EntryPointTable
dc.w WordForByte-EntryPointTable
dc.w CleanUpAfterDecompression-EntryPointTable
endproc
;---------------------------------------------------------------------------------
;
; RECORD PrepareForDecompressionFrame
;
; Stack frame template for PrepareForDecompression routine
;
;---------------------------------------------------------------------------------
PrepareForDecompressionFrame RECORD {A6Link},DECR
StartParams EQU *
header DS.L 1 ; extended header for this resource
ParamSize EQU StartParams-*
Return DS.L 1
A6Link DS.L 1
; locals go here
ENDRSize
;---------------------------------------------------------------------------------
;
; PROCEDURE PrepareForDecompression( header : Ptr ); {ptr to an extended resource header}
;
; This is the routine called by the decompress patch to tell us to get ready
; for decompression. This is where we allocate extra storage, etc...
; But, this defproc doesn't NEED any extra storage, so we don't do anything.
;
;---------------------------------------------------------------------------------
PrepareForDecompression Proc Export
With PrepareForDecompressionFrame
; I guess we can just leave...
movem.l D4/A6, BootTmp8 ; this is very important
move.l (sp)+, a0 ; get return address
add.l #ParamSize, sp ; pop parameters
jmp (a0) ; return to caller
EndWith
EndProc
;---------------------------------------------------------------------------------
;
; RECORD CleanUpAfterDecompressionFrame
;
; Stack frame template for CleanUpAfterDecompression routine
;
;---------------------------------------------------------------------------------
CleanUpAfterDecompressionFrame RECORD {A6Link},DECR
StartParams EQU *
header DS.L 1 ; extended header for this resource
ParamSize EQU StartParams-*
Return DS.L 1
A6Link DS.L 1
; locals go here
ENDRSize
;---------------------------------------------------------------------------------
;
; PROCEDURE CleanUpAfterDecompression( header : Ptr ); {ptr to an extended resource header}
;
; This is the routine called by the decompress patch to tell us to clean up
; after decompression. This is where we deallocate extra storage, etc...
; But, this defproc doesn't NEED any extra storage, so we don't do anything.
;
;---------------------------------------------------------------------------------
CleanUpAfterDecompression Proc Export
With CleanUpAfterDecompressionFrame
; I guess we can just leave...
move.l BootTmp8, A0 ; this is just as important
add.l BootTmp8+4, A0
move.l (sp)+, a0 ; get return address
add.l #ParamSize, sp ; pop parameters
jmp (a0) ; return to caller
EndWith
EndProc
;---------------------------------------------------------------------------------
;
; RECORD WordForByteFrame
;
; Stack frame template for WordForByte routine
;
;---------------------------------------------------------------------------------
WordForByteFrame RECORD {A6Link},DECR
StartParams EQU *
source DS.L 1 ; get compressed data here,
destination DS.L 1 ; and put it here
header DS.L 1 ; extended header for this resource
ParamSize EQU StartParams-*
Return DS.L 1
A6Link DS.L 1
; locals go here
ENDRSize
;
; Register equates I COULD have used in decompression
;
;
;scratch EQU d0
;numberOfWords EQU d1
;numberOfRuns EQU d1
;wordsInLastRun EQU d2
;runBitMap EQU d3
;runCount EQU d4
;extraByteFlag EQU d5
;source EQU a0
;byteTable EQU a1
;destination EQU a2
;extendedHeader EQU a3
;endOfSource EQU a4
;---------------------------------------------------------------------------------
;
; PROCEDURE WordForByte( source, destination, extHeader : Ptr ); (not MemoryMgr blocks, just addresses)
;
; This function takes data and decompresses it. The data is moved from source to
; destination, decompressing bytes into words. If a dynamic byte table is included
; in the data, it is copied into the table buffer (contained herein) before decompression.
; A pointer to the extended header is also provided, so that various flags and whatnot will
; be available to the decompress routine.
;
;---------------------------------------------------------------------------------
WordForByte Proc Export
With WordForByteFrame, ExtendedResource
link a6, #WordForByteFrame.SIZE
movem.l a0-a4/d0-d5, -(SP)
move.l header(a6), a3 ; flags and shit be here...
move.l source(a6), a0
move.l destination(a6), a2
@testForTable
btst #byteTableSaved, compressFlags(a3)
beq.s @noByteTableSaved
moveq #0, d0
move.b byteTableSize(a3), d0 ; get the size, in words, of the byte table
addq.w #1, d0 ; adjust it to "real" numbers (not zero based)
add.w d0, d0 ; make it bytes
lea DynamicTable, a1 ; point to the start of our storage
move.w d0, d1 ; save size a sec...
_BlockMove ; copy the table
adda.w d1, a0 ; move source pointer past table data
bra.s @testForOddLength
@noByteTableSaved
lea StaticTable, a1 ; point to the start of the static table
@testForOddLength
move.l actualSize(a3), d1 ; get the real size, and figure out the special cases
lsr.l #1, d1 ; but first, turn data length into number of words of uncompressed data
scs d5 ; indicate no extra byte is there
@testForBitMap
btst #bitmappedData, compressFlags(a3)
bne.s DoBitMappedData
DoNonBitMappedData
move.l a0, a4
add.l d1, a4 ; point a4 past last byte of source data
@again
moveq #0, d0
move.b (a0)+, d0 ; get byte
add.w d0, d0 ; turn it into an index
move.w (a1, d0.w), (a2)+ ; move word to destination
cmp.l a0, a4
bhi.s @again ; not at end, do it again
DoDanglingByte
tst.b d5 ; is there one more byte to move?
beq.s AllDone ; no, leave
move.b (a0), (a2) ; yes, move it and leave
bra.s AllDone
DoBitMappedData
move.l d1, d2 ; get number of uncompressed words we should do
andi.l #$7, d2 ; MOD 8 - d2 now has the number of words in the last run
lsr.l #3, d1 ; DIV 8 - d1 now has the number of 8 word runs to decompress
bra.s @endOfRun
@do8 ; if we're making this routine for the compressor
IF forCompressor THEN ; to do its reality check, then make sure
cmp.l a0, a2 ; the source and dest pointers never cross...
bls.s @pointersOK ; if they do, just leave, because the comparison
bra AllDone ; routine will show that this decompressed
@pointersOK ; resource doesn't match the original...
ENDIF
moveq #8-1, d4 ; otherwise, load up for another run
move.b (a0)+, d3 ; get bitmap
beq.s @fast8 ; if the bitmap's empty, all 16 words are uncompressed
@doNextDatum
add.b d3, d3 ; shift map over one
bcs.s @doCompressed ; bit was set, so do it the hard way
move.b (a0)+, (a2)+ ; bit wasn't set, so do it the easy way
move.b (a0)+, (a2)+ ; bit wasn't set, so do it the easy way, part II
dbra d4, @doNextDatum ; loop around
@endOfRun
subq.l #1, d1 ; subtract one from run count (we may go past -1 because of last run)
bpl.s @do8 ; and go do another batch of 16
bra.s @doLastRun ; when we fall below zero, bail out
@fast8
move.b (a0)+, (a2)+
move.b (a0)+, (a2)+
dbra d4, @fast8
bra.s @endOfRun
@doCompressed
moveq #0, d0
move.b (a0)+, d0 ; get compressed datum
add.w d0, d0 ; make it an index into byte table
move.w (a1, d0.w), (a2)+ ; move word from table to destination
@lastEntry
dbra d4, @doNextDatum ; loop around
bra.s @endOfRun ; branch to end, prepare another run
@doLastRun
move.w d2, d4 ; load up number of words to move
beq.s DoDanglingByte ; there aren’t any more words, just think about a last byte
moveq #0, d2 ; and make sure we don’t do this again...
move.b (a0)+, d3 ; get mask for this run
bra.s @lastEntry ; enter through bottom of dbra, 'cause the count is 1 based
AllDone
; I guess we can just leave...
movem.l (sp)+, a0-a4/d0-d5
unlk a6
move.l (sp)+, a0 ; get return address
add.l #ParamSize, sp ; pop parameters
jmp (a0) ; return to caller
StaticTable
DC.W $0000, $0008, $4EBA, $206E, $4E75, $000C, $0004, $7000, $0010, $0002, $486E, $FFFC, $6000, $0001, $48E7, $2F2E
DC.W $4E56, $0006, $4E5E, $2F00, $6100, $FFF8, $2F0B, $FFFF, $0014, $000A, $0018, $205F, $000E, $2050, $3F3C, $FFF4
DC.W $4CEE, $302E, $6700, $4CDF, $266E, $0012, $001C, $4267, $FFF0, $303C, $2F0C, $0003, $4ED0, $0020, $7001, $0016
DC.W $2D40, $48C0, $2078, $7200, $588F, $6600, $4FEF, $42A7, $6706, $FFFA, $558F, $286E, $3F00, $FFFE, $2F3C, $6704
DC.W $598F, $206B, $0024, $201F, $41FA, $81E1, $6604, $6708, $001A, $4EB9, $508F, $202E, $0007, $4EB0, $FFF2, $3D40
DC.W $001E, $2068, $6606, $FFF6, $4EF9, $0800, $0C40, $3D7C, $FFEC, $0005, $203C, $FFE8, $DEFC, $4A2E, $0030, $0028
DC.W $2F08, $200B, $6002, $426E, $2D48, $2053, $2040, $1800, $6004, $41EE, $2F28, $2F01, $670A, $4840, $2007, $6608
DC.W $0118, $2F07, $3028, $3F2E, $302B, $226E, $2F2B, $002C, $670C, $225F, $6006, $00FF, $3007, $FFEE, $5340, $0040
DC.W $FFE4, $4A40, $660A, $000F, $4EAD, $70FF, $22D8, $486B, $0022, $204B, $670E, $4AAE, $4E90, $FFE0, $FFC0, $002A
DC.W $2740, $6702, $51C8, $02B6, $487A, $2278, $B06E, $FFE6, $0009, $322E, $3E00, $4841, $FFEA, $43EE, $4E71, $7400
DC.W $2F2C, $206C, $003C, $0026, $0050, $1880, $301F, $2200, $660C, $FFDA, $0038, $6602, $302C, $200C, $2D6E, $4240
DC.W $FFE2, $A9F0, $FF00, $377C, $E580, $FFDC, $4868, $594F, $0034, $3E1F, $6008, $2F06, $FFDE, $600A, $7002, $0032
DC.W $FFCC, $0080, $2251, $101F, $317C, $A029, $FFD8, $5240, $0100, $6710, $A023, $FFCE, $FFD4, $2006, $4878, $002E
DC.W $504F, $43FA, $6712, $7600, $41E8, $4A6E, $20D9, $005A, $7FFF, $51CA, $005C, $2E00, $0240, $48C7, $6714, $0C80
DC.W $2E9F, $FFD6, $8000, $1000, $4842, $4A6B, $FFD2, $0048, $4A47, $4ED1, $206F, $0041, $600C, $2A78, $422E, $3200
DC.W $6574, $6716, $0044, $486D, $2008, $486C, $0B7C, $2640, $0400, $0068, $206D, $000D, $2A40, $000B, $003E, $0220
DynamicTable
DCB.W 256, 0
EndProc
End