home *** CD-ROM | disk | FTP | other *** search
/ 64'er Special 24 / 64er_Magazin_Sonderheft_24_19xx_Markt__Technik_de_Side_B.d64 / packer.src-giga (.txt) < prev    next >
Commodore BASIC  |  2022-10-26  |  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.