home *** CD-ROM | disk | FTP | other *** search
/ 64'er / 64ER_CD.iso / sh2x / sh24b.d64 / packer.src-giga (.txt) < prev    next >
Commodore BASIC  |  1995-03-30  |  15KB  |  468 lines
  1. 10 ; PROGRAMM ZUR DEMONSTRATION DER
  2. 20 ; FUNKTIONSWEISE VON PACKERN
  3. 30 ;
  4. 40 ;     BY DIRK NEUMEISTER
  5. 50 ;        IM  TRIESCH  28
  6. 60 ;        3503  LOHFELDEN
  7. 70 ;        TEL.: KS/518475
  8. 80 ;
  9. 120 ;
  10. 130 ;
  11. 140 ;
  12. 150 ;
  13. 160 ; PROGRAMMSTART AUF $C000 = 49152
  14. 170 ;
  15. 180  +$C000
  16. 190 ;
  17. 200 ; DEFINITION VON ROM-ROUTINEN
  18. 210 ;
  19. 220  TOSTRAUSG=$AB1E
  20. 230  TOGETBYTE=$B79E
  21. 240  TOPRINTFAC=$BDD7
  22. 250  TOKOMMA=$AEFD
  23. 260  TOINTHOLEN=$AD8A
  24. 270  TOWANDELN=$B7F7
  25. 280  TOFACMAL10=$BAE2
  26. 290  TOINFAC=$B395
  27. 300  TOCOPYFACII=$BC0C
  28. 310  TOFACDIV=$BB14
  29. 1000 ;
  30. 1010 ; ALLGEMEINER COMPACTOR START
  31. 1020 ;
  32. 1030 ; SYS 49152, ADR2, ADR3, ADR4, MODE
  33. 1040 ; MIT AUSGAGE DER LAENGE IN % UND DER ENDADRESSE
  34. 1050 ;
  35. 1060  MID$#<(REST); ZEIGER FUER DEN TEXT LADEN, UM DEN
  36. 1070  LEN#>(REST); HINWEIS AUF DIE RESTLAENGE AUSZUGEBEN
  37. 1080  (null)STRAUSG; TEXT AUSGEBEN
  38. 1090  (null)HOLEN; STARTADRESSE DER UNGEPACKTEN DATEN HOLEN
  39. 1100  MID$#$FB
  40. 1110  (null)COPY; UND DIESE NACH $FB/$FC COPIEREN
  41. 1120  (null)HOLEN; ENDADRESSE DER UNGEPACKTEN DATEN HOLEN
  42. 1130  RIGHT$$14; DIE ENDADRESSE UM EINS ERHOEHEN
  43. 1140  (null)COMP3;
  44. 1150  RIGHT$$15;
  45. 1160 COMP3 MID$#$FD
  46. 1170  (null)COPY; UND NACH $FD/$FE COPIEREN
  47. 1180  (null)HOLEN; STARTADR. DER GEPACKTEN DATEN NACH $14/15 LADEN
  48. 1190  (null)KOMMA; DEN RESTLICHEN AUSDRUCK AUF KOMMA PRUEFEN
  49. 1200  (null)GETBYTE; EIN WEITERES BYTE IN X-REGISTER HOLEN (MODUS)
  50. 1210  MID$#$F7; DIE STARTADRESSE DER GEPACKTEN DATEN
  51. 1220  (null)COPY; NACH $F7/$F8 COPIEREN
  52. 1230  (null)PROZENT; PROZENTROUTINE 1 AUFRUFEN (ERSTE BERECHNUNG)
  53. 1240  (null); MODUSBYTE IN AKKU COPIEREN
  54. 1250  LEFT$#$A8; MIT EXOR 10101000 VERKNUEPFEN
  55. 1260  (null)AUSGABE; MODUSBYTE SPEICHERN
  56. 1270  (null)AUSGABE; DUMMY FUER ENDADRESSE SETZEN
  57. 1280  (null)AUSGABE; DUMMY FUER ENDADRESSE SETZEN
  58. 1290  (null); X-REGISTER COPIEREN, FLAGS WERDEN GESETZT
  59. 1300  (null)COMP1; WENN <> 0, DANN MIT NIBBLER ARBEITEN
  60. 1310  (null)PACKEN; SONST MIT PACKER ARBEITEN
  61. 1320  (null)COMP2
  62. 1330 COMP1 (null)NIBBLER; NIBBLER AUFRUFEN
  63. 1340  MID$#$EE; AKKU MIT $EE LADEN UND NIBBLER ERNEUT AUFRUFEN
  64. 1350  (null)NIBBLER3; DAMIT DAS LETZTE BYTE AUCH GESPEICHERT WIRD
  65. 1360 COMP2 LEN#$01
  66. 1370  MID$$F7; ENDADRESSE SPEICHERN, WO VORHER DIE DUMMIES
  67. 1380  (null)($61),Y; GESTANDEN HABEN
  68. 1390  (null)
  69. 1400  MID$$F8
  70. 1410  (null)($61),Y
  71. 1420  (null)PROZENT2; PROZENTROUTINE 2 AUFRUFEN
  72. 1430  (null)PRINTFAC; RESTLAENGE DES PROGRAMMS AUSGEBEN
  73. 1440  (null)$AAD7; 2 MAL RETURN AUSGEBEN
  74. 1450  (null)$AAD7
  75. 1460  MID$$F8; ENDADRESSE DER GEPACKTEN DATEN LADEN
  76. 1470  PEEK$F7
  77. 1480  (null)$BDCD; UND EBENFALLS AUSGEBEN
  78. 1490  MID$#<(ENDADR); ZEIGER FUER DEN TEXT DER ENDADRESSE LADEN
  79. 1500  LEN#>(ENDADR)
  80. 1510  (null)STRAUSG; UND DEN TEXT AUSGEBEN
  81. 1520  (null)
  82. 2000 ;
  83. 2010 ; ALLGEMEINER DECOMPACTOR START
  84. 2020 ; SYS 49265, ADR2, ADR3
  85. 2030 ;
  86. 2040 DECOMP (null)HOLEN; STARTADRESSE DER GEPACKTEN DATEN HOLEN
  87. 2050  MID$#$FB
  88. 2060  (null)COPY; UND NACH $FB/$FC COPIEREN
  89. 2070  (null)NEXTBYTE; MODUSBYTE HOLEN
  90. 2080  (null); UND AUF STAPEL LEGEN
  91. 2090  (null)NEXTBYTE; ENDADRESSE DER GEPACKTEN DATEN AUS DEM
  92. 2100  (null)$35; SPEICHER LESEN UND NACH $35/$36 SPEICHERN
  93. 2110  (null)NEXTBYTE
  94. 2120  (null)$36
  95. 2130  (null)HOLEN; STARTADRESSE DER UNGEPACKTEN DATEN HOLEN
  96. 2140  MID$#$F7; CLOSE
  97. 2150  (null)COPY; NACH $F7/$F8 COPIEREN
  98. 2160  (null); STAPEL LESEN UND IN AKKU SPEICHERN
  99. 2170  LEFT$#$A8; CODIERUNG AUFHEBEN
  100. 2180  (null)DECOMP1; WENN AKKU <> 0, DANN NIBBLER AUFRUFEN
  101. 2190  (null)ENTPACKEN; SONST PACKER AUFRUFEN
  102. 2200  (null)
  103. 2210 DECOMP1 (null); AKKU IN X-REGISTER COPIEREN
  104. 2220  (null); X-REGISTER UM EINS VERRINGERN
  105. 2230  (null)DECOMP2; WENN X <> 0 (FEHLER), FALSCHE STARTADRESSE
  106. 2240  (null)DENI; SONST NIBBLER AUFRUFEN
  107. 2250  (null)
  108. 2260 DECOMP2 MID$#<(FEHLER); AUSGABE EINER FEHLERMELDUNG, DA DAS DECODIERTE
  109. 2270  LEN#>(FEHLER); MODUSBYTE WEDER NULL NOCH EINS WAR ==>
  110. 2280  (null)STRAUSG; FALSCHE STARTADRESSE ANGEGEBEN
  111. 2290  (null)
  112. 3000 ;
  113. 3010 ; UNTERROUTINEN FUER DIE
  114. 3020 ; ALLGEMEINEN EINSPRUNGADRESSEN
  115. 3030 ;
  116. 3040 HOLEN (null)KOMMA; PRUEFT AUF KOMMA
  117. 3050  (null)INTHOLEN; 16-BIT ZAHL IN FAC HOLEN
  118. 3060  (null)WANDELN; FAC WANDELN IN INTEGER $14/$15
  119. 3070  (null); ZURUECK
  120. 3080 ;
  121. 3090 COPY LEN#$01; ZAHLEN DER SPEICHERSTELLEN $14/$15
  122. 3100  (null)COPY1+1; IN DIE SPEICHERSTELLE COPIEREN, DIE IM
  123. 3110 COPY2 MID$$14,Y; AKKU (+1) STEHT
  124. 3120 COPY1 (null)$00,Y
  125. 3130  (null)
  126. 3140  (null)COPY2
  127. 3150  (null); UND WIEDER ZURUECK
  128. 4000 ;
  129. 4010 ;  PACKER
  130. 4020 ;  $FB/$FC = BEGINN DER UNGEPACKTEN DATEN
  131. 4030 ;  $FD/$FE = ENDE DER UNGEPACKTEN DATEN
  132. 4040 ;  $F7/$F8 = BEGINN DER GEPACKTEN DATEN
  133. 4050 ;
  134. 4060 PACKEN (null)NEXTBYTE; NAECHSTES BYTE IN AKKU HOLEN
  135. 4070  (null); BYTE VOM AKKU NACH X KOPIEREN
  136. 4080  (null)VERGLEICHE; BYTE IM AKKU MIT FOLGENDEN BYTES VERGLEICHEN
  137. 4090  (null)$A5; ANZAHL-1 DER GLEICHEN BYTES IN Y UND $A5
  138. 4100  ATN#03; ANZAHL-1 DER BYTES MIT #03 VERGLEICHEN
  139. 4110  (null)PACKEN1; WENN ANZAHL-1 < 3, DANN NICHT PACKEN
  140. 4120  (null); ANZAHL-1 IN DEN AKKU KOPIEREN
  141. 4130  (null); ADDITION VORBEREITEN
  142. 4140  VAL$FB; UM ANZAHL-1 DER GLEICHEN BYTES DEN
  143. 4150  (null)$FB; ZEIGER FUER UNGEPACKTE DATEN NACH VORNE, VER-
  144. 4160  (null)PACKEN2; SCHIEBEN, DAMIT NICHT DOPPELT ZUSAMMEN-
  145. 4170  RIGHT$$FC; GEFASST WIRD
  146. 4180 PACKEN2 TAN#00; VERGLEICHEN DER BYTES MIT $00
  147. 4190  (null)PACKEN3; WENN JA, DANN MIT $DB CODIEREN
  148. 4200  MID$#$DA; SONST MIT $DA BEGINNEN
  149. 4210  (null)AUSGABE; $DA SPEICHERN
  150. 4220  MID$$A5; ANZAHL-1 DER GLEICHEN BYTES IN AKKU
  151. 4230  (null)AUSGABE; UND ABSPEICHERN
  152. 4240  (null); CODE DER GLEICHEN BYTES IN AKKU
  153. 4250  (null)AUSGABE; UND EBENFALLS SPEICHERN
  154. 4260  (null)PACKEN4; UNBEDINGTER SPRUNG, DA AKKU = #$FF
  155. 4270 PACKEN3 MID$#$DB; #$DB ALS CODE FUER 00 IN AKKU LADEN
  156. 4280  (null)AUSGABE; UND IM SPEICHER ABLEGEN
  157. 4290  MID$$A5; ANZAHL-1 DER $00-BYTES IN AKKU
  158. 4300  (null)AUSGABE; UND EBENFALLS SPEICHERN
  159. 4310  (null)PACKEN4; UNBEDINGTER SPRUNG
  160. 4320 PACKEN1 TAN#$DA; VERGLEICHEN OB BYTE ZUFAELLIG $DA
  161. 4330  (null)PACKEN5
  162. 4340  TAN#$DB; ODER $DB IST
  163. 4350  (null)PACKEN6; WENN NICHT, VERZWEIGEN (EINFACHE AUSG.)
  164. 4360 PACKEN5 (null); $DA ODER $DB VOM X-REGISTER IN AKKU COPIEREN
  165. 4370  (null)AUSGABE; UND AUSGEBEN
  166. 4380  MID$#00; ANZAHL-1 LADEN
  167. 4390  (null)AUSGABE; UND EBENFALLS ABSPEICHERN
  168. 4400  (null)PACKEN4; UNBEDINGTER SPRUNG
  169. 4410 PACKEN6 (null); EINFACHE AUSGABE, D.H. CODE IN AKKU
  170. 4420  (null)AUSGABE; UND IM SPEICHERN ABLEGEN
  171. 4430 PACKEN4 MID$$FB
  172. 4440  PEEK$FC; VERGLEICHEN OB ENDE, WENN NEIN, DANN
  173. 4450  TAN$FE
  174. 4460  (null)PACKEN7
  175. 4470  STR$$FD
  176. 4480 PACKEN7 (null)PACKEN; VON VORNE WIEDER BEGINNEN
  177. 4490  (null); SONST RUECKSPRUNG AUS DER UNTERROUTINE
  178. 5000 ;
  179. 5010 ;  ENTPACKEN
  180. 5020 ;  $F7/$F8 = BEGINN DER UNGEPACKTEN DATEN
  181. 5030 ;  $FB/$FC = BEGINN DER GEPACKTEN DATEN
  182. 5040 ;  $35/$36 = ENDE DER GEPACKTEN DATEN
  183. 5050 ;
  184. 5060 ENTPACKEN (null)NEXTBYTE; NAECHSTES BYTE IN DEN AKKU LADEN
  185. 5070  STR$#$DB; MIT DEM ERKENNUNGSCODE $DB VERGLEICHEN
  186. 5080  (null)ENTPACKEN1; WENN AKKU <> #$DB DANN VERZWEIGEN
  187. 5090  (null)NEXTBYTE; SONST NAECHSTES BYTE HOLEN
  188. 5100  STR$#00; TEST, OB ANZAHL-1 DER GLEICHEN BYTE > 0
  189. 5110  (null)ENTPACKEN2; WENN NEIN, DANN VERZWEIGE
  190. 5120  MID$#$DB; ES WAR ALSO IM ORIGINAL EIN $DB, AKKU=$DB
  191. 5130  (null)ENTPACKEN3; UND VERZWEIGEN UM DIREKT SPEICHERN
  192. 5140 ENTPACKEN2 (null); ANZAHL-1 DER$00 IN D. X-REGISTER COPIEREN
  193. 5150  MID$#00; AKKU MIT DEM CODE (HIER #$00) LADEN
  194. 5160  (null)ENTPACKEN8; UND ENTPACKEN
  195. 5170 ENTPACKEN1 STR$#$DA; VERGLEICHEN OB BYTE = ERKENNUNGSCODE $DA IST
  196. 5180  (null)ENTPACKEN3; WENN NEIN, VERZWEIGEN UND BYTE AUSGEBEN
  197. 5190  (null)NEXTBYTE; NAECHSTES BYTE HOLEN
  198. 5200  STR$#00; TEST, CODE FUER GEPACKT ODER FUER $DA
  199. 5210  (null)ENTPACKEN4; WENN CODE FUER GEPACKT, DANN VERZWEIGE
  200. 5220  MID$#$DA; SONST LADE AKKU MIT $DA
  201. 5230  (null)ENTPACKEN3; UND VERZWEIGE ZUR DIREKTEN AUSGABE
  202. 5240 ENTPACKEN4 (null); ZAHL DER GLEICHEN BYTE -1 IN X-REIGSTER
  203. 5250  (null)NEXTBYTE; NOCH EIN BYTE HOLEN, (CODE DER GL. BYTE)
  204. 5260 ENTPACKEN8 (null); X MAL DEN INHALT DES AKKUS SPEICHERN
  205. 5270  LEN#00
  206. 5280 ENTPACKEN6 (null)($F7),Y
  207. 5290  (null)
  208. 5300  (null)
  209. 5310  (null)ENTPACKEN6; NOCH NICHT FERTIG, DANN WEITERMACHEN
  210. 5320  (null)
  211. 5330  (null)
  212. 5340  (null)
  213. 5350  VAL$F7; SPEICHERZEIGER WEITERSTELLEN, DAMIT
  214. 5360  (null)$F7; MAN NICHT DOPPELT IN DEN SPEICHER
  215. 5370  (null)ENTPACKEN9; GESCHRIEBEN WIRD
  216. 5380  RIGHT$$F8
  217. 5390  (null)ENTPACKEN9
  218. 5400 ENTPACKEN3 (null)AUSGABE; BYTE IN DEN SPEICHER SCHREIBEN
  219. 5410 ENTPACKEN9 MID$$35; TEST, OB SCHON ALLE BYTES ENTPACKT WURDEN
  220. 5420  PEEK$36
  221. 5430  TAN$FC
  222. 5440  (null)ENTPACKEN; WENN NEIN, WEITERMACHEN
  223. 5450  STR$$FB
  224. 5460  (null)ENTPACKEN
  225. 5470  (null); SONST FERTIG, D.H. RUECKSPRUNG
  226. 6000 ;
  227. 6010 ; UNTERROUTINEN FUER DEN PACKER
  228. 6020 ; UND DEN NIBBLER
  229. 6030 ;
  230. 6040 ;
  231. 6050 ;NAECHSTES BYTE HOLEN
  232. 6060 ;
  233. 6070 NEXTBYTE (null)
  234. 6080  LEN#$34; ROM AUSSCHALTEN
  235. 6090  (null)$01
  236. 6100  LEN#00; Y=NULL SETZEN
  237. 6110  MID$($FB),Y; DEN AKKU MIT DEM WERT DER SPEICHERSTELLE LADEN
  238. 6120  LEN#$37; ROM WIEDER ANSCHALTEN
  239. 6130  (null)$01
  240. 6140  (null)
  241. 6150  RIGHT$$FB; ZEIGER FUER BYTE HOLEN $(FB/FC) UM
  242. 6160  (null)NEXTBEND; EINS ERHOEHEN
  243. 6170  RIGHT$$FC
  244. 6180 NEXTBEND (null); UND WIEDER ZURUECKSPRINGEN
  245. 6190 ;
  246. 6200 ;AUSGABE
  247. 6210 ;
  248. 6220 AUSGABE LEN#00; LADE Y MIT NULL
  249. 6230  (null)($F7),Y; SPEICHERE AKKU IN DIE SPEICHERSTELLE,
  250. 6240  RIGHT$$F7; AUF DIE DER ZEIGER $(F7/F8) ZEIGT
  251. 6250  (null)AUSGABEND; ERHOEHE DEN ZEIGER DANN UM EINS
  252. 6260  RIGHT$$F8
  253. 6270 AUSGABEND MID$#$FF; LADE AKKU=$FF (FLAGS WERDEN BEEINFLUSST)
  254. 6280  (null); VERLASSE DIESE UNTERROUTINE WIEDER
  255. 6290 ;
  256. 6300 ;VERLGEICHEN
  257. 6310 ;
  258. 6320 VERGLEICHE LEN#00; HIER WIRD DAS Y-REGISTER NULL GESETZT
  259. 6330 VERGL1 STR$($FB),Y; VERGLEICHE DEN INHALT DES AKKUS MIT DER
  260. 6340  (null)VERGLEND; SPEICHERSTELLE, AUF DIE DER ZEIGER ZEIGT
  261. 6350  (null); ZAEHLE, WIE OFT SICH DIE BYTES GLEICHEN
  262. 6360  (null)VERGL1; MAX. ANZAHL IST DABEI 255 (FF)
  263. 6370  (null)
  264. 6380 VERGLEND (null); RUECKSPRUNG WENN DIE BYTES VERSCHIEDEN
  265. 6390  (null); SIND ODER DIE ANZAHL GROESSER ALS 255 IST
  266. 6400 ;
  267. 6410 ; NIBBLER ZUSAMMENFASSEN
  268. 6420 ;
  269. 6430 ZUSAM (null); WERT DES NIBBLES IN DAS Y-REGISTER KOPIEREN
  270. 6440  MID$BITLAENGE,Y; DIE BITLAENGE DES NEUEN CODES IN DEN AKKU
  271. 6450  (null); LADEN UND DANN NACH X KOPIEREN
  272. 6460  MID$CODE,Y; DEN NIBBLECODE AUFGRUND SEINES WERTES LADEN
  273. 6470  LEN$F9; FREIE BITS IN DAS Y-REGISTER LADEN
  274. 6480 ZUSAM2 (null)
  275. 6490  (null)$FA; BITS AUSTAUSCHEN                      CLOSE
  276. 6500  (null)
  277. 6510  (null)ZUSAM1; WENN BYTE NOCH NICHT VOLL, DANN VERZWEIGE
  278. 6520  (null); AKKU AUF DEN STAPEL LEGEN
  279. 6530  MID$$FA; DEN NEU ZUSAMMENGESTELLTEN WERT LADEN
  280. 6540  (null)AUSGABE; UND AUSGEBEN
  281. 6550  LEN#$08; ES SIND WIEDER ACHT BITS FREI
  282. 6560  (null); AKKU WIEDER VOM STAPEL HOLEN
  283. 6570 ZUSAM1 (null); NOCH VERBLEIBENDE CODELAENGE UM EINS VERMINDERN
  284. 6580  (null)ZUSAM2; UND WEITERMACHEN, BIS DER CODE COPIERT WURDE
  285. 6590  (null)$F9; ZAHL DER NOCH FREIEN BITS ZWISCHENSPEICHERN
  286. 6600  (null); UND ZURUECKSPRINGEN
  287. 6610 ;
  288. 6620 ; NIBBLER WIEDER AUSEINANDER ZIEHEN
  289. 6630 ;
  290. 6640 ENTNI PEEK#$0F; SCHLEIFENZAEHLER (X-REGISTER) MIT 16 LADEN
  291. 6650 ENTNI2 MID$$FD
  292. 6660  ASCMASKE,X; DAS BYTE MIT DER MASKE VERKNUEPFEN
  293. 6670  STR$CODE,X; ZAHL DER NOCH FREIEN BYTES UM EINS VERRINGERN
  294. 6680  (null)ENTNI1; WENN UEBEREINSTIMMUNG, DANN VERZWEIGEN
  295. 6690  (null); SONST ZAEHLER UM EINS ERNIEDRIGEN
  296. 6700  (null)ENTNI2; UND WEITER SUCHEN
  297. 6710 ENTNI1 (null)$FA; CODENUMMER ZWISCHENSPEICHERN
  298. 6720  MID$BITLAENGE,X; BITLAENGE LADEN
  299. 6730  (null); UND IN DAS X-REGISTER KOPIEREN
  300. 6740  LEN$F9; ANZAHL DER RESTLICHEN BITS IN Y LADEN
  301. 6750 ENTNI4 (null)$FE; UND AUSTAUSCHEN
  302. 6760  (null)$FD
  303. 6770  (null); ANZAHL DER BITS, DIE NOCH ZU VERFUEGUNG STEHEN
  304. 6780  (null)ENTNI3; WENN DIESE GLEICH NULL IST, NICHT VERZWEIGEN
  305. 6790  (null);
  306. 6800  (null); Y-REGISTER UND AKKU AUF STAPEL RETTEN
  307. 6810  (null)
  308. 6820  (null)
  309. 6830  (null)ENDE; TEST, OB BEREITS ALLE BYTES DECOMPREMIERT
  310. 6840  ATN#$F8; WURDEN, WENN JA, IST Y = $F8 UND
  311. 6850  (null)ENTNI6; DANN VERZWEIGEN
  312. 6860  (null)NEXTBYTE; SONST NEUES BYTE HOLEN
  313. 6870  (null)$FE; UND AUF $FE SPEICHERN
  314. 6880 ENTNI6 (null); AKKU UND X-REGISTER WIEDER VOM STAPEL HOLEN
  315. 6890  (null)
  316. 6900  (null)
  317. 6910  ATN#$F8; WENN ALLE BYTES DECODIERT WURDEN, (Y=$F8)
  318. 6920  (null)ENTNI5; DANN VERZWEIGEN ZUM RUECKSPRUNG
  319. 6930  LEN#$08; ES SIND WIEDER 8 BITS DA
  320. 6940 ENTNI3 (null); BITLAENGE DER CODE UM EINS ERNIEDRIGEN
  321. 6950  (null)ENTNI4; WENN NOCH NICHT NULL, WIEDER VON VORNE
  322. 6960  (null)$F9; ANZAHL DER NOCH FREIEN BITS SPEICHERN
  323. 6970  MID$$FA; CODEWERT LADEN (DIES IST EIN NIBBLE)
  324. 6980 ENTNI5 (null); UND ZURUECK
  325. 6990 ;
  326. 7000 ; TEST AUF ENDE
  327. 7010 ;
  328. 7020 ENDE MID$$35; ENDADRESSE IN AKKU UND X-REGISTER LADEN
  329. 7030  PEEK$36
  330. 7040  TAN$FC; MIT DER AKTUELLEN LADEADRESSE VERGLEICHEN
  331. 7050  (null)ENDE1
  332. 7060  STR$$FB
  333. 7070  (null)ENDE1; WENN KLEINER, DANN WEITER
  334. 7080  LEN#$F8; WENN GLEICH, Y-CODE FUER ENDE ($F8) LADEN
  335. 7090 ENDE1 (null); UND ZURUECK SPRINGEN
  336. 8000 ;
  337. 8010 ;  NIBBLE - PACKER
  338. 8020 ;  $FB/$FC = BEGINN DER UNGEPACKTEN DATEN
  339. 8030 ;  $FD/$FE = ENDE DER UNGEPACKTEN DATEN
  340. 8040 ;  $F7/$F8 = BEGINN DER GEPACKTEN DATEN
  341. 8050 ;
  342. 8060 NIBBLER MID$#$08; ANZAHL DER FREIEN BITS IN EINEM BYTE LADEN
  343. 8070  (null)$F9; UND NACH $F9 SPEICHERN
  344. 8080 NIBBLER1 (null)NEXTBYTE; NEUES BYTE HOLEN
  345. 8090 NIBBLER3 (null); BYTE AUF STAPEL ZWISCHENSPEICHERN
  346. 8100  (null); HI-NIBBLE NACH RECHTS SCHIEBEN
  347. 8110  (null); LOW-NIBBLE LOESCHEN
  348. 8120  (null)
  349. 8130  (null)
  350. 8140  (null)ZUSAM; UND CODIEREN
  351. 8150  (null); BYTE WIEDER VOM STAPEL HOLEN
  352. 8160  ASC#$0F; HIGH-NIBBLE LOESCHEN, LOW NIBBLE BLEIBT UEBRIG
  353. 8170  (null)ZUSAM; UND AUCH DIESES CODIEREN
  354. 8180  MID$$FB
  355. 8190  PEEK$FC; TESTEN, OB BEREITS ALLE BYTES CODIERT WURDEN
  356. 8200  TAN$FE
  357. 8210  (null)NIBBLER2; WENN NEIN, WEITERMACHEN
  358. 8220  STR$$FD
  359. 8230 NIBBLER2 (null)NIBBLER1
  360. 8240  (null); SONST RUECKSPRUNG
  361. 9000 ;
  362. 9010 ;  ENTPACKEN
  363. 9020 ;  $F7/$F8 = BEGINN DER UNGEPACKTEN DATEN
  364. 9030 ;  $FB/$FC = BEGINN DER GEPACKTEN DATEN
  365. 9040 ;  $35/$36 = ENDE DER GEPACKTEN DATEN
  366. 9050 ;
  367. 9060 DENI RIGHT$$35; ENDADRESSE UM EINS ERHOEHEN
  368. 9070  (null)DENI3
  369. 9080  RIGHT$$36
  370. 9090 DENI3 (null)NEXTBYTE; EIN BYTE HOLEN
  371. 9100  (null)$FD; UND ZWISCHENSPEICHERN
  372. 9110  (null)NEXTBYTE; EIN WEITERES BYTE HOLEN
  373. 9120  (null)$FE; EBENFALLS ZWISCHENSPEICHERN
  374. 9130  MID$#$08; ANZAHL DER FREIEN BITS IN EINEM BYTE IST 08
  375. 9140  (null)$F9; DIESE EBENFALLS SPEICHERN
  376. 9150 DENI1 (null)ENTNI; HI-NIBBLE DECODIEREN
  377. 9160  ATN#$F8; TEST AUF ENDE (Y = $F8)
  378. 9170  (null)DENI2; WENN JA, VERZWEIGEN ZUM RUECKSPRUNG
  379. 9180  (null); SONST HI-NIBBLE NACH LINKS VERSCHIEBEN
  380. 9190  (null)
  381. 9200  (null)
  382. 9210  (null)
  383. 9220  (null); AUF STAPEL LEGEN
  384. 9230  (null)ENTNI; LOW-NIBBLE DECODIEREN
  385. 9240  (null); AKKU WIEDER VOM STAPEL LADEN
  386. 9250  ATN#$F8; WENN ENDE DER DATEN (Y = $F8)
  387. 9260  (null)DENI2; DANN VERZWEIGE ZUM RUECKSPRUNG
  388. 9270  (null)$FA; LOW- UND HIGH-NIBBLE VERKNUEPFEN
  389. 9280  (null)AUSGABE; UND AUSGEBEN
  390. 9290  (null)DENI1; WEITERMACHEN
  391. 9300 DENI2 (null); RUECKSPRUNG
  392. 10000 ;
  393. 10010 ; PROZENTSATZ DER COMPREMIERUNG
  394. 10020 ; BERECHNEN   (ERSTER AUFRUF)
  395. 10030 ; $FB/$FC = BEGINN DER UNGEPACKTEN DATEN
  396. 10040 ; $FD/$FE = ENDE DER UNGEPACKTEN DATEN
  397. 10050 ; ==> $35/$36 = ERGEBNIS DER DIFFERENZ
  398. 10060 ; $F7/$F8 (BEGINN DER GEPACKTEN DATEN) IN $61/$62 ZWISCHENSPEICHERN
  399. 10070 ;
  400. 10080 PROZENT (null);SUBTRAKTION VORBEREITEN
  401. 10090  (null)
  402. 10100  MID$$FD; LAENGE DER UNGEPACKTEN
  403. 10110  (null)$FB; DATEN BERECHNEN UND IN
  404. 10120  (null)$35; $35/$36 ZWISCHENSPEICHERN
  405. 10130  MID$$FE
  406. 10140  (null)$FC
  407. 10150  (null)$36
  408. 10160  MID$$F7; BEGINN DER GEPACKTEN DATEN RETTEN
  409. 10170  (null)$61; INDEM MAN SIE IN $61/$62 ZWISCHENSPEICHERT
  410. 10180  MID$$F8
  411. 10190  (null)$62
  412. 10200  (null); UND ZURUECKSPRINGEN
  413. 10210 ;
  414. 10220 ; PROZENTSATZ DER COMPREMIERUNG
  415. 10230 ; BERECHNEN   (ZWEITER AUFRUF)
  416. 10240 ; $F7/$F8 = ENDE DER GEPACKTEN DATEN
  417. 10250 ; $61/$62 = BEGINN DER GEPACKTEN DATEN
  418. 10260 ; $35/$36 = LAENGE DER UNGEPACKTEN DATEN
  419. 10270 ; BEIM RUECKSPRUNG ENTHAELT FAC I DEN PROZENTANTEIL
  420. 10280 ;
  421. 10290 PROZENT2 (null); SUBTRAKTION VORBEREITEN
  422. 10300  (null)
  423. 10310  MID$$F7; LAENGE DER GEPACKTEN DATEN BERECHNEN
  424. 10320  (null)$61
  425. 10330  (null)
  426. 10340  MID$$F8
  427. 10350  (null)$62
  428. 10360  (null)INFAC; UND IN FLIESSKOMMAAKKU I (FAC I) WANDELN
  429. 10370  (null)COPYFACII; UND IN DEN FAC II COPIEREN
  430. 10380  LEN$35
  431. 10390  MID$$36; LAENGE DER UNGEPACKTEN DATEN LADEN
  432. 10400  (null)INFAC; UND EBENFALLS IN FAC SPEICHERN
  433. 10410  (null)FACDIV; DIVISION VON FAC UND FAC II
  434. 10420  (null)FACMAL10; FAC = FAC *10
  435. 10430  (null)FACMAL10; UND NOCHMAL (==> PROZENTANTEIL AUSRECHNEN)
  436. 10440  (null); UND WIEDER ZURUECK
  437. 11000 ;
  438. 11010 ; DATEN, TEXT UND FEHLERMELDUNGEN
  439. 11020 ; FUER DAS PROGRAMM
  440. 11030 ;
  441. 11040 CODE FN$00,$A0,$A8; NEUE CODES, DIE STATT EINES NIBBLES
  442. 11050  FN$B0,$B8,$C0; GESPEICHERT WERDEN
  443. 11060  FN$C8,$F0,$D0
  444. 11070  FN$D8,$E0,$F4
  445. 11080  FN$E8,$F8,$FC
  446. 11090  FN$80
  447. 11100 MASKE FN$80,$F8,$F8; MASKE, UM DIE UNNOETIGEN BITS ZU LOESCHEN
  448. 11110  FN$F8,$F8,$F8; UND DIE CODES ZU IDENTIFIZIEREN
  449. 11120  FN$F8,$FC,$F8
  450. 11130  FN$F8,$F8,$FC
  451. 11140  FN$F8,$FC,$FC
  452. 11150  FN$E0
  453. 11160 BITLAENGE FN$01,$05,$05; LAENGE DER NEUEN CODES
  454. 11170  FN$05,$05,$05
  455. 11180  FN$05,$06,$05
  456. 11190  FN$05,$05,$06
  457. 11200  FN$05,$06,$06
  458. 11210  FN$03
  459. 11220 REST FN13
  460. 11230  NOT"ANZAHL DER GEPACKTEN DATEN IM VERHAELT-
  461. 11240  [165]13
  462. 11250  [168]"NIS ZUM ORIGINAL IN %:               CMDCMDCMDCMDCMDCMDCMDCMDCMDCMDCMDCMDCMDCMD
  463. 11260  FN0
  464. 11270 ENDADR NOT" = ENDADRESSE DER GEPACKTEN DATEN
  465. 11280  [165]0
  466. 11290 FEHLER [168]"WIE BITTE? DIE STARTADRESSE IST FALSCH!
  467. 11300  FN13,13,0
  468.